Updated pod spec

Added documentation for usage in a Swift project

CHANGELOG.md

@@ -1,5 +1,49 @@
 # Changelog
 
+## <a href="https://github.com/Jawbone/JBChartView/tree/v2.6.0">2.6.0</a>
+#### 07/24/14
+- Fixes issue <a href="https://github.com/Jawbone/JBChartView/pull/71">#71</a>.
+
+## <a href="https://github.com/Jawbone/JBChartView/tree/v2.5.5">2.5.5</a>
+#### 05/13/14
+- Fixes issue <a href="https://github.com/Jawbone/JBChartView/pull/57">#57</a>.
+
+## <a href="https://github.com/Jawbone/JBChartView/tree/v2.5.4">2.5.4</a>
+#### 05/07/14
+- Fixes issue <a href="https://github.com/Jawbone/JBChartView/pull/53">#53</a>.
+
+## <a href="https://github.com/Jawbone/JBChartView/tree/v2.5.3">2.5.3</a>
+#### 05/06/14
+- More compiler warning fixes.
+
+## <a href="https://github.com/Jawbone/JBChartView/tree/v2.5.2">2.5.2</a> 
+#### 05/06/14
+- Fixed compiler warnings. 
+
+## <a href="https://github.com/Jawbone/JBChartView/tree/v2.5.1">2.5.1</a> 
+#### 05/05/14
+- Additional fixes to issue <a href="https://github.com/Jawbone/JBChartView/pull/48">#48</a>.
+
+## <a href="https://github.com/Jawbone/JBChartView/tree/v2.5.0">2.5.0</a> 
+#### 05/04/14
+- Fixes issue <a href="https://github.com/Jawbone/JBChartView/pull/48">#48</a>.
+
+## <a href="https://github.com/Jawbone/JBChartView/tree/v2.4.3">2.4.3</a> 
+#### 05/04/14
+- Fixes issue <a href="https://github.com/Jawbone/JBChartView/pull/49">#49</a>.
+
+## <a href="https://github.com/Jawbone/JBChartView/tree/v2.4.2">2.4.2</a> 
+#### 04/30/14
+- Fixes issue <a href="https://github.com/Jawbone/JBChartView/pull/46">#46</a>.
+
+## <a href="https://github.com/Jawbone/JBChartView/tree/v2.4.1">2.4.1</a> 
+#### 04/30/14
+- Fixes issue <a href="https://github.com/Jawbone/JBChartView/pull/45">#45</a>.
+
+## <a href="https://github.com/Jawbone/JBChartView/tree/v2.4.0">2.4.0</a> 
+#### 04/28/14
+- Fixes issue <a href="https://github.com/Jawbone/JBChartView/pull/23">#23</a>.
+
 ## <a href="https://github.com/Jawbone/JBChartView/tree/v2.3.0">2.3.0</a> 
 #### 04/17/14
 - Fixes issue <a href="https://github.com/Jawbone/JBChartView/pull/34">#34</a>.

Classes/JBBarChartView.h

@@ -102,9 +102,22 @@
  */
 - (UIView *)barChartView:(JBBarChartView *)barChartView barViewAtIndex:(NSUInteger)index;
 
+/**
+ *  If you already implement barChartView:barViewAtIndex: delegate - this method has no effect.
+ *  If a custom UIView isn't supplied, a flat bar will be made automatically (default color black).
+ *
+ *  Default: if none specified - calls barChartView:barViewAtIndex:.
+ *
+ *  @param barChartView     The bar chart object requesting this information.
+ *  @param index            The 0-based index of a given bar (left to right, x-axis).
+ *
+ *  @return The color to be used to color a bar in the chart.
+ */
+- (UIColor *)barChartView:(JBBarChartView *)barChartView colorForBarViewAtIndex:(NSUInteger)index;
+
 /**
  *  The selection color to be overlayed on a bar during touch events. 
- *  The color is automically faded to transparent (vertically). The property showsVerticalSelection
+ *  The color is automatically faded to transparent (vertically). The property showsVerticalSelection
  *  must be YES for the color to apply.
  *
  *  Default: white color (faded to transparent).

Classes/JBBarChartView.m

@@ -18,6 +18,13 @@ NSInteger static const kJBBarChartViewUndefinedBarIndex = -1;
 // Colors (JBChartView)
 static UIColor *kJBBarChartViewDefaultBarColor = nil;
 
+@interface JBChartView (Private)
+
+- (BOOL)hasMaximumValue;
+- (BOOL)hasMinimumValue;
+
+@end
+
 @interface JBBarChartView ()
 
 @property (nonatomic, strong) NSDictionary *chartDataDictionary; // key = column, value = height
@@ -34,8 +41,6 @@ static UIColor *kJBBarChartViewDefaultBarColor = nil;
 // View quick accessors
 - (CGFloat)availableHeight;
 - (CGFloat)normalizedHeightForRawHeight:(NSNumber*)rawHeight;
-- (CGFloat)minHeight;
-- (CGFloat)maxHeight;
 - (CGFloat)barWidth;
 - (CGFloat)popOffset;
 
@@ -176,11 +181,24 @@ static UIColor *kJBBarChartViewDefaultBarColor = nil;
             else
             {
                 barView = [[UIView alloc] init];
-                barView.backgroundColor = kJBBarChartViewDefaultBarColor;
+                UIColor *backgroundColor = nil;
+
+                if ([self.dataSource respondsToSelector:@selector(barChartView:colorForBarViewAtIndex:)])
+                {
+                    backgroundColor = [self.dataSource barChartView:self colorForBarViewAtIndex:index];
+                    NSAssert(backgroundColor != nil, @"JBBarChartView // datasource function - (UIColor *)barChartView:(JBBarChartView *)barChartView colorForBarViewAtIndex:(NSUInteger)index must return a non-nil UIColor");
+                }
+                else
+                {
+                    backgroundColor = kJBBarChartViewDefaultBarColor;
+                }
+
+                barView.backgroundColor = backgroundColor;
             }
+
             CGFloat height = [self normalizedHeightForRawHeight:[self.chartDataDictionary objectForKey:key]];
             CGFloat extensionHeight = height > 0.0 ? kJBBarChartViewPopOffset : 0.0;
-            barView.frame = CGRectMake(xOffset, self.bounds.size.height - height - self.footerView.frame.size.height + self.headerPadding, [self barWidth], height + extensionHeight - self.headerPadding);
+            barView.frame = CGRectMake(xOffset, self.bounds.size.height - height - self.footerView.frame.size.height, [self barWidth], height + extensionHeight);
             [mutableBarViews addObject:barView];
 			
             // Add new bar
@@ -252,8 +270,8 @@ static UIColor *kJBBarChartViewDefaultBarColor = nil;
 
 - (CGFloat)normalizedHeightForRawHeight:(NSNumber*)rawHeight
 {
-    CGFloat minHeight = [self minHeight];
-    CGFloat maxHeight = [self maxHeight];
+    CGFloat minHeight = [self minimumValue];
+    CGFloat maxHeight = [self maximumValue];
     CGFloat value = [rawHeight floatValue];
     
     if ((maxHeight - minHeight) <= 0)
@@ -264,24 +282,6 @@ static UIColor *kJBBarChartViewDefaultBarColor = nil;
     return ((value - minHeight) / (maxHeight - minHeight)) * [self availableHeight];
 }
 
-- (CGFloat)minHeight
-{
-    if (self.mininumValue != kJBChartViewUndefinedMinimumValue)
-    {
-        return MIN(self.mininumValue, self.cachedMinHeight);
-    }
-    return self.cachedMinHeight;
-}
-
-- (CGFloat)maxHeight
-{
-    if (self.maximumValue != kJBChartViewUndefinedMaximumValue)
-    {
-        return MAX(self.maximumValue, self.cachedMaxHeight);
-    }
-    return self.cachedMaxHeight;
-}
-
 - (CGFloat)barWidth
 {
     NSUInteger barCount = [[self.chartDataDictionary allKeys] count];
@@ -380,8 +380,7 @@ static UIColor *kJBBarChartViewDefaultBarColor = nil;
 {
     if(_cachedMinHeight == kJBBarChartViewUndefinedCachedHeight)
     {
-        // min height is min value across all goals and values
-        NSArray *chartValues = [[[self.chartDataDictionary allValues] arrayByAddingObjectsFromArray:[self.chartDataDictionary allValues]] sortedArrayUsingSelector:@selector(compare:)];
+        NSArray *chartValues = [[NSMutableArray arrayWithArray:[self.chartDataDictionary allValues]] sortedArrayUsingSelector:@selector(compare:)];
         _cachedMinHeight =  [[chartValues firstObject] floatValue];
     }
     return _cachedMinHeight;
@@ -391,29 +390,28 @@ static UIColor *kJBBarChartViewDefaultBarColor = nil;
 {
     if (_cachedMaxHeight == kJBBarChartViewUndefinedCachedHeight)
     {
-        // max height is max value across all goals and values
-        NSArray *chartValues = [[[self.chartDataDictionary allValues] arrayByAddingObjectsFromArray:[self.chartDataDictionary allValues]] sortedArrayUsingSelector:@selector(compare:)];
+        NSArray *chartValues = [[NSMutableArray arrayWithArray:[self.chartDataDictionary allValues]] sortedArrayUsingSelector:@selector(compare:)];
         _cachedMaxHeight =  [[chartValues lastObject] floatValue];
     }
     return _cachedMaxHeight;
 }
 
-- (CGFloat)mininumValue
+- (CGFloat)minimumValue
 {
-    if ([super mininumValue] == kJBChartViewUndefinedMinimumValue)
+    if ([self hasMinimumValue])
     {
-        return self.cachedMinHeight;
+        return fminf(self.cachedMinHeight, [super minimumValue]);
     }
-    return [super mininumValue];
+    return self.cachedMinHeight;
 }
 
 - (CGFloat)maximumValue
 {
-    if ([super maximumValue] == kJBChartViewUndefinedMaximumValue)
+    if ([self hasMaximumValue])
     {
-        return self.cachedMaxHeight;
+        return fmaxf(self.cachedMaxHeight, [super maximumValue]);
     }
-    return [super maximumValue];
+    return self.cachedMaxHeight;    
 }
 
 #pragma mark - Touch Helpers

Classes/JBChartView.h

@@ -9,8 +9,6 @@
 #import <Foundation/Foundation.h>
 
 extern CGFloat const kJBChartViewDefaultAnimationDuration;
-extern CGFloat const kJBChartViewUndefinedMinimumValue; // helper for undefined min/max values
-extern CGFloat const kJBChartViewUndefinedMaximumValue;
 
 /**
  * At a minimum, a chart can support two states, along with animations to-and-from.
@@ -43,7 +41,10 @@ typedef NS_ENUM(NSInteger, JBChartViewState){
 
 /**
  *  The minimum and maxmimum values of the chart. 
- *  If no value(s) are supplied, the min and max values of the chart's data source are used.
+ *  If no value(s) are supplied:
+ *  
+ *  minimumValue = chart's data source min value. 
+ *  maxmimumValue = chart's data source max value.
  *
  *  If value(s) are supplied, they must be >= 0, otherwise an assertion will be thrown. 
  *  The min/max values are clamped to the ceiling and floor of the actual min/max values of the chart's data source;
@@ -51,9 +52,13 @@ typedef NS_ENUM(NSInteger, JBChartViewState){
  *
  *  For min/max modifications to take effect, reloadData must be called.
  */
-@property (nonatomic, assign) CGFloat mininumValue;
+@property (nonatomic, assign) CGFloat minimumValue;
 @property (nonatomic, assign) CGFloat maximumValue;
 
+// reset to default (chart's data source min & max value)
+- (void)resetMinimumValue;
+- (void)resetMaximumValue;
+
 /**
  *  Charts can either be expanded or contracted. 
  *  By default, a chart should be expanded on initialization.

Classes/JBChartView.m

@@ -8,15 +8,17 @@
 
 #import "JBChartView.h"
 
+// Numerics
 CGFloat const kJBChartViewDefaultAnimationDuration = 0.25f;
-CGFloat const kJBChartViewUndefinedMinimumValue = -1.0f;
-CGFloat const kJBChartViewUndefinedMaximumValue = -1.0f;
 
 // Color (JBChartSelectionView)
 static UIColor *kJBChartVerticalSelectionViewDefaultBgColor = nil;
 
 @interface JBChartView ()
 
+@property (nonatomic, assign) BOOL hasMaximumValue;
+@property (nonatomic, assign) BOOL hasMinimumValue;
+
 // Construction
 - (void)constructChartView;
 
@@ -59,8 +61,6 @@ static UIColor *kJBChartVerticalSelectionViewDefaultBgColor = nil;
 - (void)constructChartView
 {
     self.clipsToBounds = YES;
-    _mininumValue = kJBChartViewUndefinedMinimumValue;
-    _maximumValue = kJBChartViewUndefinedMaximumValue;
 }
 
 #pragma mark - Public
@@ -138,16 +138,28 @@ static UIColor *kJBChartVerticalSelectionViewDefaultBgColor = nil;
     [self setState:state animated:NO];
 }
 
-- (void)setMininumValue:(CGFloat)mininumValue
+- (void)setMinimumValue:(CGFloat)minimumValue
 {
-    NSAssert(mininumValue >= 0, @"JBChartView // the minimumValue must be >= 0.");
-    _mininumValue = mininumValue;
+    NSAssert(minimumValue >= 0, @"JBChartView // the minimumValue must be >= 0.");
+    _minimumValue = minimumValue;
+    _hasMinimumValue = YES;
 }
 
 - (void)setMaximumValue:(CGFloat)maximumValue
 {
     NSAssert(maximumValue >= 0, @"JBChartView // the maximumValue must be >= 0.");
     _maximumValue = maximumValue;
+    _hasMaximumValue = YES;
+}
+
+- (void)resetMinimumValue
+{
+    _hasMinimumValue = NO; // clears min
+}
+
+- (void)resetMaximumValue
+{
+    _hasMaximumValue = NO; // clears max
 }
 
 @end

Classes/JBLineChartView.h

@@ -127,6 +127,18 @@ typedef NS_ENUM(NSInteger, JBLineChartViewLineStyle){
  */
 - (UIColor *)lineChartView:(JBLineChartView *)lineChartView colorForLineAtLineIndex:(NSUInteger)lineIndex;
 
+/**
+ *  Returns the fill color of particular line at lineIndex within the chart.
+ *
+ *  Default: clear color.
+ *
+ *  @param lineChartView    The line chart object requesting this information.
+ *  @param lineIndex        An index number identifying a line in the chart.
+ *
+ *  @return The fill color to show under a line in the chart.
+ */
+- (UIColor *)lineChartView:(JBLineChartView *)lineChartView fillColorForLineAtLineIndex:(NSUInteger)lineIndex;
+
 /**
  *  Returns the color of a particular dot in a line at lineIndex within the chart.
  *  For this value to apply, showsDotsForLineAtLineIndex: must return YES for the line at lineIndex.
@@ -207,6 +219,19 @@ typedef NS_ENUM(NSInteger, JBLineChartViewLineStyle){
  */
 - (UIColor *)lineChartView:(JBLineChartView *)lineChartView selectionColorForLineAtLineIndex:(NSUInteger)lineIndex;
 
+/**
+ *  Returns the selection fill color to be overlayed under a line within the chart during touch events.
+ *  The property showsLineSelection must be YES for the color to apply.
+ *
+ *  Default: clear color.
+ *
+ *  @param lineChartView    The line chart object requesting this information.
+ *  @param lineIndex        An index number identifying a line in the chart.
+ *
+ *  @return The color to be used to highlight under a line during chart selections.
+ */
+- (UIColor *)lineChartView:(JBLineChartView *)lineChartView selectionFillColorForLineAtLineIndex:(NSUInteger)lineIndex;
+
 /**
  *  Returns the selection color to be overlayed on a line within the chart during touch events.
  *  The property showsLineSelection must be YES for the color to apply.
@@ -249,14 +274,14 @@ typedef NS_ENUM(NSInteger, JBLineChartViewLineStyle){
 - (BOOL)lineChartView:(JBLineChartView *)lineChartView showsDotsForLineAtLineIndex:(NSUInteger)lineIndex;
 
 /**
- *  Returns whether or not a line should be smoothed (rounded end caps and connections).
+ *  Returns whether or not a line should be rendered with curved connections and rounded end caps.
  *
  *  Default: NO
  *
  *  @param lineChartView    The line chart object requesting this information.
  *  @param lineIndex        An index number identifying a line in the chart.
  *
- *  @return Whether or not a line should smooth it's ends and connections. 
+ *  @return Whether or not a line should smooth it's connections and end caps.
  */
 - (BOOL)lineChartView:(JBLineChartView *)lineChartView smoothLineAtLineIndex:(NSUInteger)lineIndex;
 

Classes/JBLineChartView.m

@@ -24,6 +24,8 @@ CGFloat static const kJBLineChartLinesViewMiterLimit = -5.0;
 CGFloat static const kJBLineChartLinesViewDefaultLinePhase = 1.0f;
 CGFloat static const kJBLineChartLinesViewDefaultDimmedOpacity = 0.20f;
 NSInteger static const kJBLineChartLinesViewUnselectedLineIndex = -1;
+CGFloat static const kJBLineChartLinesViewSmoothThresholdSlope = 0.01f;
+NSInteger static const kJBLineChartLinesViewSmoothThresholdVertical = 1;
 
 // Numerics (JBLineChartDotsView)
 NSInteger static const kJBLineChartDotsViewDefaultRadiusFactor = 3; // 3x size of line width
@@ -44,10 +46,19 @@ static NSArray *kJBLineChartLineViewDefaultDashPattern = nil;
 
 // Colors (JBLineChartView)
 static UIColor *kJBLineChartViewDefaultLineColor = nil;
-static UIColor *kJBLineChartViewDefaultDotColor = nil;
+static UIColor *kJBLineChartViewDefaultLineFillColor = nil;
 static UIColor *kJBLineChartViewDefaultLineSelectionColor = nil;
+static UIColor *kJBLineChartViewDefaultLineSelectionFillColor = nil;
+static UIColor *kJBLineChartViewDefaultDotColor = nil;
 static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
 
+@interface JBChartView (Private)
+
+- (BOOL)hasMaximumValue;
+- (BOOL)hasMinimumValue;
+
+@end
+
 @interface JBLineLayer : CAShapeLayer
 
 @property (nonatomic, assign) NSUInteger tag;
@@ -55,6 +66,12 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
 
 @end
 
+@interface JBFillLayer : CAShapeLayer
+
+@property (nonatomic, assign) NSUInteger tag;
+
+@end
+
 @interface JBLineChartPoint : NSObject
 
 @property (nonatomic, assign) CGPoint position;
@@ -80,6 +97,7 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
 
 // View helpers
 - (JBLineLayer *)lineLayerForLineIndex:(NSUInteger)lineIndex;
+- (JBFillLayer *)fillLayerForLineIndex:(NSUInteger)lineIndex;
 
 @end
 
@@ -88,6 +106,8 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
 - (NSArray *)chartDataForLineChartLinesView:(JBLineChartLinesView*)lineChartLinesView;
 - (UIColor *)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView colorForLineAtLineIndex:(NSUInteger)lineIndex;
 - (UIColor *)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView selectedColorForLineAtLineIndex:(NSUInteger)lineIndex;
+- (UIColor *)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView fillColorForLineAtLineIndex:(NSUInteger)lineIndex;
+- (UIColor *)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView selectedFillColorForLineAtLineIndex:(NSUInteger)lineIndex;
 - (CGFloat)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView widthForLineAtLineIndex:(NSUInteger)lineIndex;
 - (CGFloat)paddingForLineChartLinesView:(JBLineChartLinesView *)lineChartLinesView;
 - (JBLineChartViewLineStyle)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView lineStyleForLineAtLineIndex:(NSUInteger)lineIndex;
@@ -147,8 +167,6 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
 // View quick accessors
 - (CGFloat)normalizedHeightForRawHeight:(CGFloat)rawHeight;
 - (CGFloat)availableHeight;
-- (CGFloat)minHeight;
-- (CGFloat)maxHeight;
 - (CGFloat)padding;
 - (NSUInteger)dataCount;
 
@@ -175,8 +193,10 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
 	if (self == [JBLineChartView class])
 	{
 		kJBLineChartViewDefaultLineColor = [UIColor blackColor];
-        kJBLineChartViewDefaultDotColor = [UIColor blackColor];
+        kJBLineChartViewDefaultLineFillColor = [UIColor clearColor];
 		kJBLineChartViewDefaultLineSelectionColor = [UIColor whiteColor];
+        kJBLineChartViewDefaultLineSelectionFillColor = [UIColor clearColor];
+        kJBLineChartViewDefaultDotColor = [UIColor blackColor];
         kJBLineChartViewDefaultDotSelectionColor = [UIColor whiteColor];
 	}
 }
@@ -244,7 +264,7 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
         CGFloat pointSpace = (self.bounds.size.width - (chartPadding * 2)) / ([self dataCount] - 1); // Space in between points
         CGFloat xOffset = chartPadding;
         CGFloat yOffset = 0;
-       
+
         NSMutableArray *mutableChartData = [NSMutableArray array];
         NSAssert([self.dataSource respondsToSelector:@selector(numberOfLinesInLineChartView:)], @"JBLineChartView // dataSource must implement - (NSUInteger)numberOfLinesInLineChartView:(JBLineChartView *)lineChartView");
         for (NSUInteger lineIndex=0; lineIndex<[self.dataSource numberOfLinesInLineChartView:self]; lineIndex++)
@@ -253,7 +273,7 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
             NSUInteger dataCount = [self.dataSource lineChartView:self numberOfVerticalValuesAtLineIndex:lineIndex];
             NSMutableArray *chartPointData = [NSMutableArray array];
             for (NSUInteger horizontalIndex=0; horizontalIndex<dataCount; horizontalIndex++)
-            {                
+            {               
                 NSAssert([self.delegate respondsToSelector:@selector(lineChartView:verticalValueForHorizontalIndex:atLineIndex:)], @"JBLineChartView // delegate must implement - (CGFloat)lineChartView:(JBLineChartView *)lineChartView verticalValueForHorizontalIndex:(NSUInteger)horizontalIndex atLineIndex:(NSUInteger)lineIndex");
                 CGFloat rawHeight =  [self.delegate lineChartView:self verticalValueForHorizontalIndex:horizontalIndex atLineIndex:lineIndex];
                 NSAssert(rawHeight >= 0, @"JBLineChartView // delegate function - (CGFloat)lineChartView:(JBLineChartView *)lineChartView verticalValueForHorizontalIndex:(NSUInteger)horizontalIndex atLineIndex:(NSUInteger)lineIndex must return a CGFloat >= 0");
@@ -288,7 +308,7 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
         // Create new line and overlay subviews
         self.linesView = [[JBLineChartLinesView alloc] initWithFrame:CGRectOffset(mainViewRect, 0, self.headerView.frame.size.height + self.headerPadding)];
         self.linesView.delegate = self;
-        
+
         // Add new lines view
         if (self.footerView)
         {
@@ -382,8 +402,8 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
 
 - (CGFloat)normalizedHeightForRawHeight:(CGFloat)rawHeight
 {
-    CGFloat minHeight = [self minHeight];
-    CGFloat maxHeight = [self maxHeight];
+    CGFloat minHeight = [self minimumValue];
+    CGFloat maxHeight = [self maximumValue];
 
     if ((maxHeight - minHeight) <= 0)
     {
@@ -398,30 +418,12 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
     return self.bounds.size.height - self.headerView.frame.size.height - self.footerView.frame.size.height - self.headerPadding;
 }
 
-- (CGFloat)minHeight
-{
-    if (self.mininumValue != kJBChartViewUndefinedMinimumValue)
-    {
-        return MIN(self.mininumValue, self.cachedMinHeight);
-    }
-    return self.cachedMinHeight;
-}
-
-- (CGFloat)maxHeight
-{    
-    if (self.maximumValue != kJBChartViewUndefinedMaximumValue)
-    {
-        return MAX(self.maximumValue, self.cachedMaxHeight);
-    }
-    return self.cachedMaxHeight;
-}
-
 - (CGFloat)padding
 {
     CGFloat maxLineWidth = 0.0f;
     NSAssert([self.dataSource respondsToSelector:@selector(numberOfLinesInLineChartView:)], @"JBLineChartView // dataSource must implement - (NSUInteger)numberOfLinesInLineChartView:(JBLineChartView *)lineChartView");
 
-    for (int lineIndex=0; lineIndex<[self.dataSource numberOfLinesInLineChartView:self]; lineIndex++)
+    for (NSUInteger lineIndex=0; lineIndex<[self.dataSource numberOfLinesInLineChartView:self]; lineIndex++)
     {
         BOOL showsDots = NO;
         if ([self.dataSource respondsToSelector:@selector(lineChartView:showsDotsForLineAtLineIndex:)])
@@ -494,6 +496,24 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
     return kJBLineChartViewDefaultLineSelectionColor;
 }
 
+- (UIColor *)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView fillColorForLineAtLineIndex:(NSUInteger)lineIndex
+{
+    if ([self.dataSource respondsToSelector:@selector(lineChartView:fillColorForLineAtLineIndex:)])
+    {
+        return [self.dataSource lineChartView:self fillColorForLineAtLineIndex:lineIndex];
+    }
+    return kJBLineChartViewDefaultLineFillColor;
+}
+
+- (UIColor *)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView selectedFillColorForLineAtLineIndex:(NSUInteger)lineIndex
+{
+    if ([self.dataSource respondsToSelector:@selector(lineChartView:selectionFillColorForLineAtLineIndex:)])
+    {
+        return [self.dataSource lineChartView:self selectionFillColorForLineAtLineIndex:lineIndex];
+    }
+    return kJBLineChartViewDefaultLineSelectionFillColor;
+}
+
 - (CGFloat)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView widthForLineAtLineIndex:(NSUInteger)lineIndex
 {
     if ([self.dataSource respondsToSelector:@selector(lineChartView:widthForLineAtLineIndex:)])
@@ -508,15 +528,6 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
     return [self padding];
 }
 
-- (BOOL)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView smoothLineAtLineIndex:(NSUInteger)lineIndex
-{
-    if ([self.dataSource respondsToSelector:@selector(lineChartView:smoothLineAtLineIndex:)])
-    {
-        return [self.dataSource lineChartView:self smoothLineAtLineIndex:lineIndex];
-    }
-    return NO;
-}
-
 - (JBLineChartViewLineStyle)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView lineStyleForLineAtLineIndex:(NSUInteger)lineIndex
 {
     if ([self.dataSource respondsToSelector:@selector(lineChartView:lineStyleForLineAtLineIndex:)])
@@ -526,6 +537,15 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
     return JBLineChartViewLineStyleSolid;
 }
 
+- (BOOL)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView smoothLineAtLineIndex:(NSUInteger)lineIndex
+{
+    if ([self.dataSource respondsToSelector:@selector(lineChartView:smoothLineAtLineIndex:)])
+    {
+        return [self.dataSource lineChartView:self smoothLineAtLineIndex:lineIndex];
+    }
+    return NO;
+}
+
 #pragma mark - JBLineChartDotsViewDelegate
 
 - (NSArray *)chartDataForLineChartDotsView:(JBLineChartDotsView*)lineChartDotsView
@@ -633,7 +653,7 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
             } completion:^(BOOL finished) {
                 [UIView animateWithDuration:kJBLineChartViewStateAnimationDuration delay:0.0 options:UIViewAnimationOptionBeginFromCurrentState animations:^{
                     adjustViewFrames();
-                } completion:^(BOOL finished) {
+                } completion:^(BOOL adjustFinished) {
                     if (callback)
                     {
                         callback();
@@ -722,22 +742,22 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
     return _cachedMaxHeight;
 }
 
-- (CGFloat)mininumValue
+- (CGFloat)minimumValue
 {
-    if ([super mininumValue] == kJBChartViewUndefinedMinimumValue)
+    if ([self hasMinimumValue])
     {
-        return self.cachedMinHeight;
+        return fminf(self.cachedMinHeight, [super minimumValue]);
     }
-    return [super mininumValue];
+    return self.cachedMinHeight;
 }
 
 - (CGFloat)maximumValue
 {
-    if ([super maximumValue] == kJBChartViewUndefinedMaximumValue)
+    if ([self hasMaximumValue])
     {
-        return self.cachedMaxHeight;
+        return fmaxf(self.cachedMaxHeight, [super maximumValue]);
     }
-    return [super maximumValue];
+    return self.cachedMaxHeight;
 }
 
 #pragma mark - Touch Helpers
@@ -789,8 +809,8 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
 - (NSInteger)lineIndexForPoint:(CGPoint)point
 {
     // Find the horizontal indexes
-    NSInteger leftHorizontalIndex = [self horizontalIndexForPoint:point indexClamp:JBLineChartHorizontalIndexClampLeft];
-    NSInteger rightHorizontalIndex = [self horizontalIndexForPoint:point indexClamp:JBLineChartHorizontalIndexClampRight];
+    NSUInteger leftHorizontalIndex = [self horizontalIndexForPoint:point indexClamp:JBLineChartHorizontalIndexClampLeft];
+    NSUInteger rightHorizontalIndex = [self horizontalIndexForPoint:point indexClamp:JBLineChartHorizontalIndexClampRight];
     
     // Padding
     CGFloat chartPadding = [self padding];
@@ -963,7 +983,7 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
     self = [super init];
     if (self)
     {
-        self.zPosition = 0.0f;
+        self.zPosition = 0.1f;
         self.fillColor = [UIColor clearColor].CGColor;
     }
     return self;
@@ -989,6 +1009,24 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
 
 @end
 
+@implementation JBFillLayer
+
+#pragma mark - Alloc/Init
+
+- (id)init
+{
+    self = [super init];
+    if (self)
+    {
+        self.zPosition = 0.0f;
+        self.strokeColor = [UIColor clearColor].CGColor;
+        self.lineWidth = 0.0f;
+    }
+    return self;
+}
+
+@end
+
 @implementation JBLineChartPoint
 
 #pragma mark - Alloc/Init
@@ -1051,18 +1089,57 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
         UIBezierPath *path = [UIBezierPath bezierPath];
         path.miterLimit = kJBLineChartLinesViewMiterLimit;
         
+        JBLineChartPoint *previousLineChartPoint = nil;
+        CGFloat previousSlope = 0.0f;
+        
+        NSAssert([self.delegate respondsToSelector:@selector(lineChartLinesView:smoothLineAtLineIndex:)], @"JBLineChartLinesView // delegate must implement - (BOOL)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView smoothLineAtLineIndex:(NSUInteger)lineIndex");
+        BOOL smoothLine = [self.delegate lineChartLinesView:self smoothLineAtLineIndex:lineIndex];
+        
         NSUInteger index = 0;
-        for (JBLineChartPoint *lineChartPoint in [lineData sortedArrayUsingSelector:@selector(compare:)])
+        NSArray *sortedLineData = [lineData sortedArrayUsingSelector:@selector(compare:)];
+        CGFloat firstXPosition = 0.0f;
+        CGFloat lastXPosition = 0.0f;
+        for (JBLineChartPoint *lineChartPoint in sortedLineData)
         {
             if (index == 0)
             {
                 [path moveToPoint:CGPointMake(lineChartPoint.position.x, fmin(self.bounds.size.height - padding, fmax(padding, lineChartPoint.position.y)))];
+                firstXPosition = lineChartPoint.position.x;
             }
             else
             {
-                [path addLineToPoint:CGPointMake(lineChartPoint.position.x, fmin(self.bounds.size.height - padding, fmax(padding, lineChartPoint.position.y)))];
+                JBLineChartPoint *nextLineChartPoint = nil;
+                if (index != ([lineData count] - 1))
+                {
+                    nextLineChartPoint = [sortedLineData objectAtIndex:(index + 1)];
+                }
+                
+                CGFloat nextSlope = (nextLineChartPoint != nil) ? ((nextLineChartPoint.position.y - lineChartPoint.position.y)) / ((nextLineChartPoint.position.x - lineChartPoint.position.x)) : previousSlope;
+                CGFloat currentSlope = ((lineChartPoint.position.y - previousLineChartPoint.position.y)) / (lineChartPoint.position.x-previousLineChartPoint.position.x);
+                
+                BOOL deltaFromNextSlope = ((currentSlope >= (nextSlope + kJBLineChartLinesViewSmoothThresholdSlope)) || (currentSlope <= (nextSlope - kJBLineChartLinesViewSmoothThresholdSlope)));
+                BOOL deltaFromPreviousSlope = ((currentSlope >= (previousSlope + kJBLineChartLinesViewSmoothThresholdSlope)) || (currentSlope <= (previousSlope - kJBLineChartLinesViewSmoothThresholdSlope)));
+                BOOL deltaFromPreviousY = (lineChartPoint.position.y >= previousLineChartPoint.position.y + kJBLineChartLinesViewSmoothThresholdVertical) || (lineChartPoint.position.y <= previousLineChartPoint.position.y - kJBLineChartLinesViewSmoothThresholdVertical);
+                
+                if (smoothLine && deltaFromNextSlope && deltaFromPreviousSlope && deltaFromPreviousY)
+                {
+                    CGFloat deltaX = lineChartPoint.position.x - previousLineChartPoint.position.x;
+                    CGFloat controlPointX = previousLineChartPoint.position.x + (deltaX / 2);
+                    
+                    CGPoint controlPoint1 = CGPointMake(controlPointX, previousLineChartPoint.position.y);
+                    CGPoint controlPoint2 = CGPointMake(controlPointX, lineChartPoint.position.y);
+                    
+                    [path addCurveToPoint:CGPointMake(lineChartPoint.position.x, fmin(self.bounds.size.height - padding, fmax(padding, lineChartPoint.position.y))) controlPoint1:controlPoint1 controlPoint2:controlPoint2];
+                }
+                else
+                {
+                    [path addLineToPoint:CGPointMake(lineChartPoint.position.x, fmin(self.bounds.size.height - padding, fmax(padding, lineChartPoint.position.y)))];
+                }
+                
+                lastXPosition = lineChartPoint.position.x;
+                previousSlope = currentSlope;
             }
-            
+            previousLineChartPoint = lineChartPoint;
             index++;
         }
         
@@ -1072,30 +1149,54 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
             shapeLayer = [JBLineLayer layer];
         }
         
+        JBFillLayer *shapeFillLayer = [self fillLayerForLineIndex:lineIndex];
+        if (shapeFillLayer == nil)
+        {
+            shapeFillLayer = [JBFillLayer layer];
+        }
+        
         shapeLayer.tag = lineIndex;
+        shapeFillLayer.tag = lineIndex;
+        
         NSAssert([self.delegate respondsToSelector:@selector(lineChartLinesView:lineStyleForLineAtLineIndex:)], @"JBLineChartLinesView // delegate must implement - (JBLineChartViewLineStyle)lineChartLineView:(JBLineChartLinesView *)lineChartLinesView lineStyleForLineAtLineIndex:(NSUInteger)lineIndex");
         shapeLayer.lineStyle = [self.delegate lineChartLinesView:self lineStyleForLineAtLineIndex:lineIndex];
         
         NSAssert([self.delegate respondsToSelector:@selector(lineChartLinesView:colorForLineAtLineIndex:)], @"JBLineChartLinesView // delegate must implement - (UIColor *)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView colorForLineAtLineIndex:(NSUInteger)lineIndex");
         shapeLayer.strokeColor = [self.delegate lineChartLinesView:self colorForLineAtLineIndex:lineIndex].CGColor;
         
-        NSAssert([self.delegate respondsToSelector:@selector(lineChartLinesView:smoothLineAtLineIndex:)], @"JBLineChartLinesView // delegate must implement - (UIColor *)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView colorForLineAtLineIndex:(NSUInteger)lineIndex");
-        BOOL smoothLine = [self.delegate lineChartLinesView:self smoothLineAtLineIndex:lineIndex];
-        if (smoothLine)
+        NSAssert([self.delegate respondsToSelector:@selector(lineChartLinesView:fillColorForLineAtLineIndex:)], @"JBLineChartLinesView // delegate must implement - (UIColor *)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView fillColorForLineAtLineIndex:(NSUInteger)lineIndex");
+        shapeFillLayer.fillColor = [self.delegate lineChartLinesView:self fillColorForLineAtLineIndex:lineIndex].CGColor;
+        
+        if (smoothLine == YES)
         {
             shapeLayer.lineCap = kCALineCapRound;
             shapeLayer.lineJoin = kCALineJoinRound;
+            shapeFillLayer.lineCap = kCALineCapRound;
+            shapeFillLayer.lineJoin = kCALineJoinRound;
         }
         else
         {
             shapeLayer.lineCap = kCALineCapButt;
             shapeLayer.lineJoin = kCALineJoinMiter;
+            shapeFillLayer.lineCap = kCALineCapButt;
+            shapeFillLayer.lineJoin = kCALineJoinMiter;
         }
         
         NSAssert([self.delegate respondsToSelector:@selector(lineChartLinesView:widthForLineAtLineIndex:)], @"JBLineChartLinesView // delegate must implement - (CGFloat)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView widthForLineAtLineIndex:(NSUInteger)lineIndex");
         shapeLayer.lineWidth = [self.delegate lineChartLinesView:self widthForLineAtLineIndex:lineIndex];
         shapeLayer.path = path.CGPath;
         shapeLayer.frame = self.bounds;
+        
+        // Continue the path for the fill layer (close and fill)
+        UIBezierPath *fillPath = [path copy];
+        
+        [fillPath addLineToPoint:CGPointMake(lastXPosition, self.bounds.size.height - padding)];
+        [fillPath addLineToPoint:CGPointMake(firstXPosition, self.bounds.size.height - padding)];
+        
+        shapeFillLayer.path = fillPath.CGPath;
+        shapeFillLayer.frame = self.bounds;
+        
+        [self.layer addSublayer:shapeFillLayer];
         [self.layer addSublayer:shapeLayer];
 
         lineIndex++;
@@ -1118,12 +1219,14 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
 {
     _selectedLineIndex = selectedLineIndex;
     
+    __weak JBLineChartLinesView* weakSelf = self;
+    
     dispatch_block_t adjustLines = ^{
-        for (CALayer *layer in [self.layer sublayers])
+        for (CALayer *layer in [weakSelf.layer sublayers])
         {
             if ([layer isKindOfClass:[JBLineLayer class]])
             {
-                if (((JBLineLayer *)layer).tag == _selectedLineIndex)
+                if (((NSInteger)((JBLineLayer *)layer).tag) == weakSelf.selectedLineIndex)
                 {
                     NSAssert([self.delegate respondsToSelector:@selector(lineChartLinesView:selectedColorForLineAtLineIndex:)], @"JBLineChartLinesView // delegate must implement - (UIColor *)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView selectedColorForLineAtLineIndex:(NSUInteger)lineIndex");
                     ((JBLineLayer *)layer).strokeColor = [self.delegate lineChartLinesView:self selectedColorForLineAtLineIndex:((JBLineLayer *)layer).tag].CGColor;
@@ -1133,7 +1236,22 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
                 {
                     NSAssert([self.delegate respondsToSelector:@selector(lineChartLinesView:colorForLineAtLineIndex:)], @"JBLineChartLinesView // delegate must implement - (UIColor *)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView colorForLineAtLineIndex:(NSUInteger)lineIndex");
                     ((JBLineLayer *)layer).strokeColor = [self.delegate lineChartLinesView:self colorForLineAtLineIndex:((JBLineLayer *)layer).tag].CGColor;
-                    ((JBLineLayer *)layer).opacity = (_selectedLineIndex == kJBLineChartLinesViewUnselectedLineIndex) ? 1.0f : kJBLineChartLinesViewDefaultDimmedOpacity;
+                    ((JBLineLayer *)layer).opacity = (weakSelf.selectedLineIndex == kJBLineChartLinesViewUnselectedLineIndex) ? 1.0f : kJBLineChartLinesViewDefaultDimmedOpacity;
+                }
+            }
+            else if ([layer isKindOfClass:[JBFillLayer class]])
+            {
+                if (((NSInteger)((JBFillLayer *)layer).tag) == weakSelf.selectedLineIndex)
+                {
+                    NSAssert([self.delegate respondsToSelector:@selector(lineChartLinesView:selectedFillColorForLineAtLineIndex:)], @"JBLineChartLinesView // delegate must implement - (UIColor *)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView selectedFillColorForLineAtLineIndex:(NSUInteger)lineIndex");
+                    ((JBFillLayer *)layer).fillColor = [self.delegate lineChartLinesView:self selectedFillColorForLineAtLineIndex:((JBLineLayer *)layer).tag].CGColor;
+                    ((JBFillLayer *)layer).opacity = 1.0f;
+                }
+                else
+                {
+                    NSAssert([self.delegate respondsToSelector:@selector(lineChartLinesView:fillColorForLineAtLineIndex:)], @"JBLineChartLinesView // delegate must implement - (UIColor *)lineChartLinesView:(JBLineChartLinesView *)lineChartLinesView fillColorForLineAtLineIndex:(NSUInteger)lineIndex");
+                    ((JBFillLayer *)layer).fillColor = [self.delegate lineChartLinesView:self fillColorForLineAtLineIndex:((JBLineLayer *)layer).tag].CGColor;
+                    ((JBFillLayer *)layer).opacity = (weakSelf.selectedLineIndex == kJBLineChartLinesViewUnselectedLineIndex) ? 1.0f : kJBLineChartLinesViewDefaultDimmedOpacity;
                 }
             }
         }
@@ -1168,6 +1286,8 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
     }
 }
 
+#pragma mark - View Helpers
+
 - (JBLineLayer *)lineLayerForLineIndex:(NSUInteger)lineIndex
 {
     for (CALayer *layer in [self.layer sublayers])
@@ -1183,6 +1303,21 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
     return nil;
 }
 
+- (JBFillLayer *)fillLayerForLineIndex:(NSUInteger)lineIndex
+{
+    for (CALayer *layer in [self.layer sublayers])
+    {
+        if ([layer isKindOfClass:[JBFillLayer class]])
+        {
+            if (((JBFillLayer *)layer).tag == lineIndex)
+            {
+                return (JBFillLayer *)layer;
+            }
+        }
+    }
+    return nil;
+}
+
 @end
 
 @implementation JBLineChartDotsView
@@ -1228,7 +1363,7 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
             NSMutableArray *mutableDotViews = [NSMutableArray array];
             NSUInteger horizontalIndex = 0;
             for (JBLineChartPoint *lineChartPoint in [lineData sortedArrayUsingSelector:@selector(compare:)])
-            {                
+            {                               
                 NSAssert([self.delegate respondsToSelector:@selector(lineChartDotsView:dotRadiusForLineAtLineIndex:)], @"JBLineChartDotsView // delegate must implement - (CGFloat)lineChartDotsView:(JBLineChartDotsView *)lineChartDotsView dotRadiusForLineAtLineIndex:(NSUInteger)lineIndex");
                 CGFloat dotRadius = [self.delegate lineChartDotsView:self dotRadiusForLineAtLineIndex:lineIndex];
                 
@@ -1256,16 +1391,18 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
 {
     _selectedLineIndex = selectedLineIndex;
     
+    __weak JBLineChartDotsView* weakSelf = self;
+    
     dispatch_block_t adjustDots = ^{
-        [self.dotViewsDict enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
+        [weakSelf.dotViewsDict enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
             NSUInteger horizontalIndex = 0;
             for (JBLineChartDotView *dotView in (NSArray *)obj)
             {
                 if ([key isKindOfClass:[NSNumber class]])
                 {
-                    NSUInteger lineIndex = [((NSNumber *)key) intValue];
+                    NSInteger lineIndex = [((NSNumber *)key) intValue];
 
-                    if (_selectedLineIndex == lineIndex)
+                    if (weakSelf.selectedLineIndex == lineIndex)
                     {
                         NSAssert([self.delegate respondsToSelector:@selector(lineChartDotsView:selectedColorForDotAtHorizontalIndex:atLineIndex:)], @"JBLineChartDotsView // delegate must implement - (UIColor *)lineChartDotsView:(JBLineChartDotsView *)lineChartDotsView selectedColorForDotAtHorizontalIndex:(NSUInteger)horizontalIndex atLineIndex:(NSUInteger)lineIndex");
                         dotView.backgroundColor = [self.delegate lineChartDotsView:self selectedColorForDotAtHorizontalIndex:horizontalIndex atLineIndex:lineIndex];
@@ -1274,7 +1411,7 @@ static UIColor *kJBLineChartViewDefaultDotSelectionColor = nil;
                     {
                         NSAssert([self.delegate respondsToSelector:@selector(lineChartDotsView:colorForDotAtHorizontalIndex:atLineIndex:)], @"JBLineChartDotsView // delegate must implement - (UIColor *)lineChartDotsView:(JBLineChartDotsView *)lineChartDotsView colorForDotAtHorizontalIndex:(NSUInteger)horizontalIndex atLineIndex:(NSUInteger)lineIndex");
                         dotView.backgroundColor = [self.delegate lineChartDotsView:self colorForDotAtHorizontalIndex:horizontalIndex atLineIndex:lineIndex];
-                        dotView.alpha = (_selectedLineIndex == kJBLineChartDotsViewUnselectedLineIndex) ? 1.0f : 0.0f; // hide dots on off-selection
+                        dotView.alpha = (weakSelf.selectedLineIndex == kJBLineChartDotsViewUnselectedLineIndex) ? 1.0f : 0.0f; // hide dots on off-selection
                     }
                 }
                 horizontalIndex++;

JBChartView.podspec

@@ -1,17 +1,19 @@
 Pod::Spec.new do |s|
   s.name         = "JBChartView"
-  s.version      = "2.3.0"
+  s.version      = "2.6.0"
   s.summary      = "Jawbone's iOS-based charting library for both line and bar graphs."
   s.homepage     = "https://github.com/Jawbone/JBChartView"
 
+  s.screenshot   = "https://raw.github.com/Jawbone/JBChartView/master/Screenshots/main.jpg"
+
   s.license      = { :type => 'Apache', :file => 'LICENSE' }
   s.author       = { "Terry Worona" => "tworona@jawbone.com" }
   s.source       = { 
 	:git => "https://github.com/Jawbone/JBChartView.git",
-	:tag => "v2.3.0"
+	:tag => "v2.6.0"
   }
 
   s.platform     = :ios, '7.0'
-  s.source_files  = 'Classes', 'Classes/**/*.{h,m}'
+  s.source_files = 'Classes/**/*.{h,m}'
   s.requires_arc = true
 end

JBChartViewDemo/JBChartViewDemo/Controllers/JBBarChartViewController.m

@@ -21,7 +21,7 @@ CGFloat const kJBBarChartViewControllerChartHeaderHeight = 80.0f;
 CGFloat const kJBBarChartViewControllerChartHeaderPadding = 10.0f;
 CGFloat const kJBBarChartViewControllerChartFooterHeight = 25.0f;
 CGFloat const kJBBarChartViewControllerChartFooterPadding = 5.0f;
-CGFloat const kJBBarChartViewControllerBarPadding = 1;
+NSUInteger kJBBarChartViewControllerBarPadding = 1;
 NSInteger const kJBBarChartViewControllerNumBars = 12;
 NSInteger const kJBBarChartViewControllerMaxBarHeight = 10;
 NSInteger const kJBBarChartViewControllerMinBarHeight = 5;
@@ -107,6 +107,7 @@ NSString * const kJBBarChartViewControllerNavButtonViewKey = @"view";
     self.barChartView.delegate = self;
     self.barChartView.dataSource = self;
     self.barChartView.headerPadding = kJBBarChartViewControllerChartHeaderPadding;
+    self.barChartView.minimumValue = 0.0f;
     self.barChartView.backgroundColor = kJBColorBarChartBackground;
     
     JBChartHeaderView *headerView = [[JBChartHeaderView alloc] initWithFrame:CGRectMake(kJBBarChartViewControllerChartPadding, ceil(self.view.bounds.size.height * 0.5) - ceil(kJBBarChartViewControllerChartHeaderHeight * 0.5), self.view.bounds.size.width - (kJBBarChartViewControllerChartPadding * 2), kJBBarChartViewControllerChartHeaderHeight)];
@@ -155,11 +156,9 @@ NSString * const kJBBarChartViewControllerNavButtonViewKey = @"view";
     return kJBBarChartViewControllerBarPadding;
 }
 
-- (UIView *)barChartView:(JBBarChartView *)barChartView barViewAtIndex:(NSUInteger)index
+- (UIColor *)barChartView:(JBBarChartView *)barChartView colorForBarViewAtIndex:(NSUInteger)index
 {
-    UIView *barView = [[UIView alloc] init];
-    barView.backgroundColor = (index % 2 == 0) ? kJBColorBarChartBarBlue : kJBColorBarChartBarGreen;
-    return barView;
+    return (index % 2 == 0) ? kJBColorBarChartBarBlue : kJBColorBarChartBarGreen;
 }
 
 - (UIColor *)barSelectionColorForBarChartView:(JBBarChartView *)barChartView

JBChartViewDemo/JBChartViewDemo/Footers/JBBarChartFooterView.h

@@ -10,7 +10,6 @@
 
 @interface JBBarChartFooterView : UIView
 
-@property (nonatomic, strong) UIColor *footerBackgroundColor; // footer background (default = black)
 @property (nonatomic, assign) CGFloat padding; // label left & right padding (default = 4.0)
 @property (nonatomic, readonly) UILabel *leftLabel;
 @property (nonatomic, readonly) UILabel *rightLabel;

JBChartViewDemo/JBChartViewDemo/Footers/JBBarChartFooterView.m

@@ -10,30 +10,12 @@
 
 // Numerics
 CGFloat const kJBBarChartFooterPolygonViewDefaultPadding = 4.0f;
-CGFloat const kJBBarChartFooterPolygonViewArrowHeight = 8.0f;
-CGFloat const kJBBarChartFooterPolygonViewArrowWidth = 16.0f;
 
 // Colors
-static UIColor *kJBBarChartFooterPolygonViewDefaultBackgroundColor = nil;
+static UIColor *kJBBarChartFooterViewDefaultBackgroundColor = nil;
 
-@protocol JBBarChartFooterPolygonViewDelegate;
+@interface JBBarChartFooterView ()
 
-@interface JBBarChartFooterPolygonView : UIView
-
-@property (nonatomic, weak) id<JBBarChartFooterPolygonViewDelegate> delegate;
-
-@end
-
-@protocol JBBarChartFooterPolygonViewDelegate <NSObject>
-
-- (UIColor *)backgroundColorForChartFooterPolygonView:(JBBarChartFooterPolygonView *)chartFooterPolygonView;
-- (CGFloat)paddingForChartFooterPolygonView:(JBBarChartFooterPolygonView *)chartFooterPolygonView;
-
-@end
-
-@interface JBBarChartFooterView () <JBBarChartFooterPolygonViewDelegate>
-
-@property (nonatomic, strong) JBBarChartFooterPolygonView *polygonView;
 @property (nonatomic, strong) UILabel *leftLabel;
 @property (nonatomic, strong) UILabel *rightLabel;
 
@@ -47,7 +29,7 @@ static UIColor *kJBBarChartFooterPolygonViewDefaultBackgroundColor = nil;
 {
 	if (self == [JBBarChartFooterView class])
 	{
-		kJBBarChartFooterPolygonViewDefaultBackgroundColor = kJBColorBarChartControllerBackground;
+		kJBBarChartFooterViewDefaultBackgroundColor = kJBColorBarChartControllerBackground;
 	}
 }
 
@@ -56,15 +38,10 @@ static UIColor *kJBBarChartFooterPolygonViewDefaultBackgroundColor = nil;
     self = [super initWithFrame:frame];
     if (self)
     {
-        self.backgroundColor = kJBBarChartFooterPolygonViewDefaultBackgroundColor;
+        self.backgroundColor = kJBBarChartFooterViewDefaultBackgroundColor;
         
-        _footerBackgroundColor = kJBBarChartFooterPolygonViewDefaultBackgroundColor;
         _padding = kJBBarChartFooterPolygonViewDefaultPadding;
         
-        _polygonView = [[JBBarChartFooterPolygonView alloc] initWithFrame:CGRectMake(self.bounds.origin.x, self.bounds.origin.y - kJBBarChartFooterPolygonViewArrowHeight, self.bounds.size.width, self.bounds.size.height + kJBBarChartFooterPolygonViewArrowHeight)];
-        _polygonView.delegate = self;
-        [self addSubview:_polygonView];
-        
         _leftLabel = [[UILabel alloc] init];
         _leftLabel.adjustsFontSizeToFitWidth = YES;
         _leftLabel.font = kJBFontFooterLabel;
@@ -100,95 +77,4 @@ static UIColor *kJBBarChartFooterPolygonViewDefaultBackgroundColor = nil;
     self.rightLabel.frame = CGRectMake(CGRectGetMaxX(_leftLabel.frame), yOffset, width, self.bounds.size.height);
 }
 
-#pragma mark - JBBarChartFooterPolygonViewDelegate
-
-- (UIColor *)backgroundColorForChartFooterPolygonView:(JBBarChartFooterPolygonView *)chartFooterPolygonView
-{
-    return self.footerBackgroundColor;
-}
-
-- (CGFloat)paddingForChartFooterPolygonView:(JBBarChartFooterPolygonView *)chartFooterPolygonView
-{
-    return self.padding;
-}
-
-@end
-
-@implementation JBBarChartFooterPolygonView
-
-#pragma mark - Alloc/Init
-
-- (id)initWithFrame:(CGRect)frame
-{
-    self = [super initWithFrame:frame];
-    if (self)
-    {
-        self.backgroundColor = [UIColor clearColor];
-    }
-    return self;
-}
-
-#pragma mark - Drawing
-
-- (void)drawRect:(CGRect)rect
-{
-    [super drawRect:rect];
-    
-    CGContextRef context = UIGraphicsGetCurrentContext();
-    
-    // Background gradient
-    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
-    CGFloat locations[] = { 0.0, 1.0 };
-    
-    NSAssert([self.delegate respondsToSelector:@selector(backgroundColorForChartFooterPolygonView:)], @"JBChartFooterPolygonView // delegate must implement - (UIColor *)backgroundColorForChartFooterPolygonView");
-    NSAssert([self.delegate respondsToSelector:@selector(paddingForChartFooterPolygonView:)], @"JBChartFooterPolygonView // delegate must implement - (CGFloat)paddingForChartFooterPolygonView");
-
-    UIColor *bgColor = [self.delegate backgroundColorForChartFooterPolygonView:self];
-    
-    NSArray *colors = @[(__bridge id)bgColor.CGColor, (__bridge id)bgColor.CGColor];
-    CGGradientRef gradient = CGGradientCreateWithColors(colorSpace, (__bridge CFArrayRef) colors, locations);
-    
-    // Polygon shape
-    CGFloat xOffset = self.bounds.origin.x;
-    CGFloat width = self.bounds.size.width;
-    CGFloat height = self.bounds.size.height;
-    CGFloat padding = [self.delegate paddingForChartFooterPolygonView:self];
-    NSArray *polygonPoints = @[[NSValue valueWithCGPoint:CGPointMake(xOffset, height)],
-                               [NSValue valueWithCGPoint:CGPointMake(xOffset, kJBBarChartFooterPolygonViewArrowHeight)],
-                               [NSValue valueWithCGPoint:CGPointMake(xOffset + padding, kJBBarChartFooterPolygonViewArrowHeight)],
-                               [NSValue valueWithCGPoint:CGPointMake(xOffset + padding + ceil(kJBBarChartFooterPolygonViewArrowWidth * 0.5), 0)],
-                               [NSValue valueWithCGPoint:CGPointMake(xOffset + padding + kJBBarChartFooterPolygonViewArrowWidth, kJBBarChartFooterPolygonViewArrowHeight)],
-                               [NSValue valueWithCGPoint:CGPointMake(width - padding - kJBBarChartFooterPolygonViewArrowWidth, kJBBarChartFooterPolygonViewArrowHeight)],
-                               [NSValue valueWithCGPoint:CGPointMake(width - padding - ceil(kJBBarChartFooterPolygonViewArrowWidth * 0.5), 0.0)],
-                               [NSValue valueWithCGPoint:CGPointMake(width - padding, kJBBarChartFooterPolygonViewArrowHeight)],
-                               [NSValue valueWithCGPoint:CGPointMake(width, kJBBarChartFooterPolygonViewArrowHeight)],
-                               [NSValue valueWithCGPoint:CGPointMake(width, height)],
-                               [NSValue valueWithCGPoint:CGPointMake(xOffset, height)]];
-    
-    // Draw polygon
-    NSValue *pointValue = polygonPoints[0];
-    CGContextSaveGState(context);
-    {
-        NSInteger index = 0;
-        for (pointValue in polygonPoints)
-        {
-            CGPoint point = [pointValue CGPointValue];
-            if (index == 0)
-            {
-                CGContextMoveToPoint(context, point.x, point.y);
-            }
-            else
-            {
-                CGContextAddLineToPoint(context, point.x, point.y);
-            }
-            index++;
-        }
-        CGContextClip(context);
-        CGContextDrawLinearGradient(context, gradient, CGPointMake(CGRectGetMidX(rect), CGRectGetMinY(rect)), CGPointMake(CGRectGetMidX(rect), CGRectGetMaxY(rect)), 0);
-    }
-    CGContextRestoreGState(context);
-	CGGradientRelease(gradient);
-	CGColorSpaceRelease(colorSpace);
-}
-
 @end

README.md

@@ -1,7 +1,7 @@
 # JBChartView
 <br/>
 <p align="center">	
-	<img src="https://raw.github.com/Jawbone/JBChartView/master/Screenshots/main.png">
+	<img src="https://raw.github.com/Jawbone/JBChartView/master/Screenshots/main.jpg">
 </p>
 
 Introducing <b>JBChartView - </b> Jawbone's iOS-based charting library for both line and bar graphs. It is easy to set-up, and highly customizable. 
@@ -21,10 +21,15 @@ Refer to the <a href="https://github.com/Jawbone/JBChartView/blob/master/CHANGEL
 - Requires iOS 7 or later
 - Requires Automatic Reference Counting (ARC)
 
-## Demo
+## Demo Project
 
 Build and run the <i>JBChartViewDemo</i> project in Xcode. The demo demonstrates the use of both the line and bar charts. It also outlines how a chart's appearance can be customized. 
 
+## More Demos
+
+- <a href="https://github.com/Jawbone/anscombe-quartet-ios">Amsombe's Quartet</a>: project showcasing the use of JBChartView in the classic data visualization example known as Anscombe's Quartet.
+- <a href="https://github.com/Jawbone/spark-friends-ios">Spark Friends</a>: project showcasing the use of JBChartView in the context of sparklines and (fake) user step data. 
+
 ## Installation
 
 <a href="http://cocoapods.org/" target="_blank">CocoaPods</a> is the recommended method of installing JBChartView.
@@ -38,7 +43,7 @@ Simply add the following line to your <code>Podfile</code>:
 Your Podfile should look something like:
 
 	platform :ios, '7.0'
-	pod 'JBChartView', '~> 2.3.0'
+	pod 'JBChartView', '~> 2.6.0'
 	
 ### The Old School Way
 
@@ -52,6 +57,17 @@ The simpliest way to use JBChartView with your application is to drag and drop t
 
 All JBChartView implementations have a similiar data source and delgate pattern to <i>UITableView</i>. If you're familiar with using a <i>UITableView</i> or <i>UITableViewController</i>, using a JBChartView subclass should be a breeze!
 
+#### Swift Projects
+
+To use JBCartView in a Swift project add the following to your bridging header (JBChartView-Bridging-Header.h):
+
+	#import <UIKit/UIKit.h>
+	#import "JBChartView/JBChartView.h"
+	#import "JBChartView/JBBarChartView.h"
+	#import "JBChartView/JBLineChartView.h"
+
+For more information about adding bridging headers see <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/MixandMatch.html" target="_blank">Swift and Objective-C in the Same Project</a>.
+
 #### JBBarChartView
 
 To initialize a <i>JBBarChartView</i>, you only need a few lines of code (see below). Bar charts can also be initialized via a <b>nib</b> or with a <b>frame</b>.
@@ -63,14 +79,14 @@ To initialize a <i>JBBarChartView</i>, you only need a few lines of code (see be
     
 At a minimum, you need to inform the data source how many bars are in the chart:
 
-	- (NSInteger)numberOfBarsInBarChartView:(JBBarChartView *)barChartView
+	- (NSUInteger)numberOfBarsInBarChartView:(JBBarChartView *)barChartView
 	{
 		return ...; // number of bars in chart
 	}
 
 Secondly, you need to inform the delegate the height of each bar (automatically normalized across the entire chart):
     
-    - (CGFloat)barChartView:(JBBarChartView *)barChartView heightForBarViewAtAtIndex:(NSInteger)index
+    - (CGFloat)barChartView:(JBBarChartView *)barChartView heightForBarViewAtAtIndex:(NSUInteger)index
     {
 		return ...; // height of bar at index
 	}
@@ -140,6 +156,10 @@ By default, a chart's bars will be black and flat. They can be customized by sup
 	{
 		return ...; // color of line in chart
 	}
+	
+If you don't require a custom UIView, simply supply a color for the bar instead:
+
+	- (UIColor *)barChartView:(JBBarChartView *)barChartView colorForBarViewAtIndex:(NSUInteger)index;
 
 Furthermore, the color of the selection bar (on touch events) can be customized via the <i>optional</i> protocol:
 
@@ -171,6 +191,11 @@ The color, width and style of each line in the chart can be customized via the <
 		return ...; // color of line in chart
 	}
 	
+	- (UIColor *)lineChartView:(JBLineChartView *)lineChartView fillColorForLineAtLineIndex:(NSUInteger)lineIndex
+	{
+		return ...; // color of area under line in chart
+	}
+	
 	- (CGFloat)lineChartView:(JBLineChartView *)lineChartView widthForLineAtLineIndex:(NSUInteger)lineIndex
 	{
 		return ...; // width of line in chart
@@ -198,6 +223,11 @@ Furthermore, the color and width of the selection view along with the color of t
 		return ...; // color of selected line
 	}
 	
+	- (UIColor *)lineChartView:(JBLineChartView *)lineChartView selectionFillColorForLineAtLineIndex:(NSUInteger)lineIndex
+	{
+		return ...; // color of area under selected line
+	}
+	
 By default, each line will not show dots for each point. To enable this on a per-line basis:
 
 	- (BOOL)lineChartView:(JBLineChartView *)lineChartView showsDotsForLineAtLineIndex:(NSUInteger)lineIndex;
@@ -212,7 +242,7 @@ To customize the color of each dot during selection and non-selection events (de
 
 	- (UIColor *)lineChartView:(JBLineChartView *)lineChartView selectionColorForDotAtHorizontalIndex:(NSUInteger)horizontalIndex atLineIndex:(NSUInteger)lineIndex;
 	
-As well, by default, each line will have squared off end caps and connection points. To enable line smoothing:
+As well, by default, each line will have squared off end caps and connection points. To enable rounded connections and end caps:
 
 	- (BOOL)lineChartView:(JBLineChartView *)lineChartView smoothLineAtLineIndex:(NSUInteger)lineIndex;
 		
@@ -229,6 +259,21 @@ Lastly, a line chart's selection events are delegated back via:
 	}
 	
 The <b>touchPoint</b> is especially important as it allows you to add custom elements to your chart during  selection events. Refer to the demo project (<b>JBLineChartViewController</b>) to see how a tooltip can be used to display additional information during selection events.
+
+## Minimum & Maximum Values
+
+By default, a chart's minimum and maximum values are equal to the min and max supplied by the dataSource. You can override either value via:
+
+	- (void)setMinimumValue:(CGFloat)minimumValue;
+	- (void)setMaximumValue:(CGFloat)maximumValue;
+
+If value(s) are supplied, they must be >= 0, otherwise an assertion will be thrown. To reset the values back to their original defaults:
+
+	- (void)resetMinimumValue;
+	- (void)resetMaximumValue;
+	
+The min/max values are clamped to the ceiling and floor of the actual min/max values of the chart's data source; for example, if a maximumValue of 20 is supplied & the chart's actual max is 100, then 100 will be used. For min/max modifications to take effect, reloadData must be called.
+
 	
 ## License