top tabs support - ios (#2454)

* top tabs support - ios

lib/ios/HMSegmentedControl.h

@@ -0,0 +1,262 @@
+//
+//  HMSegmentedControl.h
+//  HMSegmentedControl
+//
+//  Created by Hesham Abd-Elmegid on 23/12/12.
+//  Copyright (c) 2012-2015 Hesham Abd-Elmegid. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class HMSegmentedControl;
+
+typedef void (^IndexChangeBlock)(NSInteger index);
+typedef NSAttributedString *(^HMTitleFormatterBlock)(HMSegmentedControl *segmentedControl, NSString *title, NSUInteger index, BOOL selected);
+
+typedef NS_ENUM(NSInteger, HMSegmentedControlSelectionStyle) {
+    HMSegmentedControlSelectionStyleTextWidthStripe, // Indicator width will only be as big as the text width
+    HMSegmentedControlSelectionStyleFullWidthStripe, // Indicator width will fill the whole segment
+    HMSegmentedControlSelectionStyleBox, // A rectangle that covers the whole segment
+    HMSegmentedControlSelectionStyleArrow // An arrow in the middle of the segment pointing up or down depending on `HMSegmentedControlSelectionIndicatorLocation`
+};
+
+typedef NS_ENUM(NSInteger, HMSegmentedControlSelectionIndicatorLocation) {
+    HMSegmentedControlSelectionIndicatorLocationUp,
+    HMSegmentedControlSelectionIndicatorLocationDown,
+	HMSegmentedControlSelectionIndicatorLocationNone // No selection indicator
+};
+
+typedef NS_ENUM(NSInteger, HMSegmentedControlSegmentWidthStyle) {
+    HMSegmentedControlSegmentWidthStyleFixed, // Segment width is fixed
+    HMSegmentedControlSegmentWidthStyleDynamic, // Segment width will only be as big as the text width (including inset)
+};
+
+typedef NS_OPTIONS(NSInteger, HMSegmentedControlBorderType) {
+    HMSegmentedControlBorderTypeNone = 0,
+    HMSegmentedControlBorderTypeTop = (1 << 0),
+    HMSegmentedControlBorderTypeLeft = (1 << 1),
+    HMSegmentedControlBorderTypeBottom = (1 << 2),
+    HMSegmentedControlBorderTypeRight = (1 << 3)
+};
+
+enum {
+    HMSegmentedControlNoSegment = -1   // Segment index for no selected segment
+};
+
+typedef NS_ENUM(NSInteger, HMSegmentedControlType) {
+    HMSegmentedControlTypeText,
+    HMSegmentedControlTypeImages,
+	HMSegmentedControlTypeTextImages
+};
+
+typedef NS_ENUM(NSInteger, HMSegmentedControlImagePosition) {
+    HMSegmentedControlImagePositionBehindText,
+    HMSegmentedControlImagePositionLeftOfText,
+    HMSegmentedControlImagePositionRightOfText,
+    HMSegmentedControlImagePositionAboveText,
+    HMSegmentedControlImagePositionBelowText
+};
+
+@interface HMSegmentedControl : UIControl
+
+@property (nonatomic, strong) NSArray<NSString *> *sectionTitles;
+@property (nonatomic, strong) NSArray<UIImage *> *sectionImages;
+@property (nonatomic, strong) NSArray<UIImage *> *sectionSelectedImages;
+
+/**
+ Provide a block to be executed when selected index is changed.
+ 
+ Alternativly, you could use `addTarget:action:forControlEvents:`
+ */
+@property (nonatomic, copy) IndexChangeBlock indexChangeBlock;
+
+/**
+ Used to apply custom text styling to titles when set.
+ 
+ When this block is set, no additional styling is applied to the `NSAttributedString` object returned from this block.
+ */
+@property (nonatomic, copy) HMTitleFormatterBlock titleFormatter;
+
+/**
+ Text attributes to apply to item title text.
+ */
+@property (nonatomic, strong) NSDictionary *titleTextAttributes UI_APPEARANCE_SELECTOR;
+
+/*
+ Text attributes to apply to selected item title text.
+ 
+ Attributes not set in this dictionary are inherited from `titleTextAttributes`.
+ */
+@property (nonatomic, strong) NSDictionary *selectedTitleTextAttributes UI_APPEARANCE_SELECTOR;
+
+/**
+ Segmented control background color.
+ 
+ Default is `[UIColor whiteColor]`
+ */
+@property (nonatomic, strong) UIColor *backgroundColor UI_APPEARANCE_SELECTOR;
+
+/**
+ Color for the selection indicator stripe
+ 
+ Default is `R:52, G:181, B:229`
+ */
+@property (nonatomic, strong) UIColor *selectionIndicatorColor UI_APPEARANCE_SELECTOR;
+
+/**
+ Color for the selection indicator box
+ 
+ Default is selectionIndicatorColor
+ */
+@property (nonatomic, strong) UIColor *selectionIndicatorBoxColor UI_APPEARANCE_SELECTOR;
+
+/**
+ Color for the vertical divider between segments.
+ 
+ Default is `[UIColor blackColor]`
+ */
+@property (nonatomic, strong) UIColor *verticalDividerColor UI_APPEARANCE_SELECTOR;
+
+/**
+ Opacity for the seletion indicator box.
+ 
+ Default is `0.2f`
+ */
+@property (nonatomic) CGFloat selectionIndicatorBoxOpacity;
+
+/**
+ Width the vertical divider between segments that is added when `verticalDividerEnabled` is set to YES.
+ 
+ Default is `1.0f`
+ */
+@property (nonatomic, assign) CGFloat verticalDividerWidth;
+
+/**
+ Specifies the style of the control
+ 
+ Default is `HMSegmentedControlTypeText`
+ */
+@property (nonatomic, assign) HMSegmentedControlType type;
+
+/**
+ Specifies the style of the selection indicator.
+ 
+ Default is `HMSegmentedControlSelectionStyleTextWidthStripe`
+ */
+@property (nonatomic, assign) HMSegmentedControlSelectionStyle selectionStyle;
+
+/**
+ Specifies the style of the segment's width.
+ 
+ Default is `HMSegmentedControlSegmentWidthStyleFixed`
+ */
+@property (nonatomic, assign) HMSegmentedControlSegmentWidthStyle segmentWidthStyle;
+
+/**
+ Specifies the location of the selection indicator.
+ 
+ Default is `HMSegmentedControlSelectionIndicatorLocationUp`
+ */
+@property (nonatomic, assign) HMSegmentedControlSelectionIndicatorLocation selectionIndicatorLocation;
+
+/*
+ Specifies the border type.
+ 
+ Default is `HMSegmentedControlBorderTypeNone`
+ */
+@property (nonatomic, assign) HMSegmentedControlBorderType borderType;
+
+/**
+ Specifies the image position relative to the text. Only applicable for HMSegmentedControlTypeTextImages
+ 
+ Default is `HMSegmentedControlImagePositionBehindText`
+ */
+@property (nonatomic) HMSegmentedControlImagePosition imagePosition;
+
+/**
+ Specifies the distance between the text and the image. Only applicable for HMSegmentedControlTypeTextImages
+ 
+ Default is `0,0`
+ */
+@property (nonatomic) CGFloat textImageSpacing;
+
+/**
+ Specifies the border color.
+ 
+ Default is `[UIColor blackColor]`
+ */
+@property (nonatomic, strong) UIColor *borderColor;
+
+/**
+ Specifies the border width.
+ 
+ Default is `1.0f`
+ */
+@property (nonatomic, assign) CGFloat borderWidth;
+
+/**
+ Default is YES. Set to NO to deny scrolling by dragging the scrollView by the user.
+ */
+@property(nonatomic, getter = isUserDraggable) BOOL userDraggable;
+
+/**
+ Default is YES. Set to NO to deny any touch events by the user.
+ */
+@property(nonatomic, getter = isTouchEnabled) BOOL touchEnabled;
+
+/**
+ Default is NO. Set to YES to show a vertical divider between the segments.
+ */
+@property(nonatomic, getter = isVerticalDividerEnabled) BOOL verticalDividerEnabled;
+
+@property (nonatomic, getter=shouldStretchSegmentsToScreenSize) BOOL stretchSegmentsToScreenSize;
+
+/**
+ Index of the currently selected segment.
+ */
+@property (nonatomic, assign) NSInteger selectedSegmentIndex;
+
+/**
+ Height of the selection indicator. Only effective when `HMSegmentedControlSelectionStyle` is either `HMSegmentedControlSelectionStyleTextWidthStripe` or `HMSegmentedControlSelectionStyleFullWidthStripe`.
+ 
+ Default is 5.0
+ */
+@property (nonatomic, readwrite) CGFloat selectionIndicatorHeight;
+
+/**
+ Edge insets for the selection indicator.
+ NOTE: This does not affect the bounding box of HMSegmentedControlSelectionStyleBox
+ 
+ When HMSegmentedControlSelectionIndicatorLocationUp is selected, bottom edge insets are not used
+ 
+ When HMSegmentedControlSelectionIndicatorLocationDown is selected, top edge insets are not used
+ 
+ Defaults are top: 0.0f
+             left: 0.0f
+           bottom: 0.0f
+            right: 0.0f
+ */
+@property (nonatomic, readwrite) UIEdgeInsets selectionIndicatorEdgeInsets;
+
+/**
+ Inset left and right edges of segments.
+ 
+ Default is UIEdgeInsetsMake(0, 5, 0, 5)
+ */
+@property (nonatomic, readwrite) UIEdgeInsets segmentEdgeInset;
+
+@property (nonatomic, readwrite) UIEdgeInsets enlargeEdgeInset;
+
+/**
+ Default is YES. Set to NO to disable animation during user selection.
+ */
+@property (nonatomic) BOOL shouldAnimateUserSelection;
+
+- (id)initWithSectionTitles:(NSArray<NSString *> *)sectiontitles;
+- (id)initWithSectionImages:(NSArray<UIImage *> *)sectionImages sectionSelectedImages:(NSArray<UIImage *> *)sectionSelectedImages;
+- (instancetype)initWithSectionImages:(NSArray<UIImage *> *)sectionImages sectionSelectedImages:(NSArray<UIImage *> *)sectionSelectedImages titlesForSections:(NSArray<NSString *> *)sectiontitles;
+- (void)setSelectedSegmentIndex:(NSUInteger)index animated:(BOOL)animated;
+- (void)setIndexChangeBlock:(IndexChangeBlock)indexChangeBlock;
+- (void)setTitleFormatter:(HMTitleFormatterBlock)titleFormatter;
+
+@end

lib/ios/HMSegmentedControl.m

@@ -0,0 +1,958 @@
+//
+//  HMSegmentedControl.m
+//  HMSegmentedControl
+//
+//  Created by Hesham Abd-Elmegid on 23/12/12.
+//  Copyright (c) 2012-2015 Hesham Abd-Elmegid. All rights reserved.
+//
+
+#import "HMSegmentedControl.h"
+#import <QuartzCore/QuartzCore.h>
+#import <math.h>
+
+@interface HMScrollView : UIScrollView
+@end
+
+@interface HMSegmentedControl ()
+
+@property (nonatomic, strong) CALayer *selectionIndicatorStripLayer;
+@property (nonatomic, strong) CALayer *selectionIndicatorBoxLayer;
+@property (nonatomic, strong) CALayer *selectionIndicatorArrowLayer;
+@property (nonatomic, readwrite) CGFloat segmentWidth;
+@property (nonatomic, readwrite) NSArray<NSNumber *> *segmentWidthsArray;
+@property (nonatomic, strong) HMScrollView *scrollView;
+
+@end
+
+@implementation HMScrollView
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+    if (!self.dragging) {
+        [self.nextResponder touchesBegan:touches withEvent:event];
+    } else {
+        [super touchesBegan:touches withEvent:event];
+    }
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
+    if (!self.dragging) {
+        [self.nextResponder touchesMoved:touches withEvent:event];
+    } else{
+        [super touchesMoved:touches withEvent:event];
+    }
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+    if (!self.dragging) {
+        [self.nextResponder touchesEnded:touches withEvent:event];
+    } else {
+        [super touchesEnded:touches withEvent:event];
+    }
+}
+
+@end
+
+@implementation HMSegmentedControl
+
+- (id)initWithCoder:(NSCoder *)aDecoder {
+    self = [super initWithCoder:aDecoder];
+    if (self) {
+        [self commonInit];
+    }
+    return self;
+}
+
+- (id)initWithFrame:(CGRect)frame {
+    self = [super initWithFrame:frame];
+    
+    if (self) {
+        [self commonInit];
+    }
+    
+    return self;
+}
+
+- (id)initWithSectionTitles:(NSArray<NSString *> *)sectiontitles {
+    self = [super initWithFrame:CGRectZero];
+    
+    if (self) {
+        [self commonInit];
+        self.sectionTitles = sectiontitles;
+        self.type = HMSegmentedControlTypeText;
+    }
+    
+    return self;
+}
+
+- (id)initWithSectionImages:(NSArray<UIImage *> *)sectionImages sectionSelectedImages:(NSArray<UIImage *> *)sectionSelectedImages {
+    self = [super initWithFrame:CGRectZero];
+    
+    if (self) {
+        [self commonInit];
+        self.sectionImages = sectionImages;
+        self.sectionSelectedImages = sectionSelectedImages;
+        self.type = HMSegmentedControlTypeImages;
+    }
+    
+    return self;
+}
+
+- (instancetype)initWithSectionImages:(NSArray<UIImage *> *)sectionImages sectionSelectedImages:(NSArray<UIImage *> *)sectionSelectedImages titlesForSections:(NSArray<NSString *> *)sectiontitles {
+	self = [super initWithFrame:CGRectZero];
+    
+    if (self) {
+        [self commonInit];
+		
+		if (sectionImages.count != sectiontitles.count) {
+			[NSException raise:NSRangeException format:@"***%s: Images bounds (%ld) Don't match Title bounds (%ld)", sel_getName(_cmd), (unsigned long)sectionImages.count, (unsigned long)sectiontitles.count];
+        }
+		
+        self.sectionImages = sectionImages;
+        self.sectionSelectedImages = sectionSelectedImages;
+		self.sectionTitles = sectiontitles;
+        self.type = HMSegmentedControlTypeTextImages;
+    }
+    
+    return self;
+}
+
+- (void)awakeFromNib {
+    [super awakeFromNib];
+    
+    self.segmentWidth = 0.0f;
+}
+
+- (void)commonInit {
+    self.scrollView = [[HMScrollView alloc] init];
+    self.scrollView.scrollsToTop = NO;
+    self.scrollView.showsVerticalScrollIndicator = NO;
+    self.scrollView.showsHorizontalScrollIndicator = NO;
+    [self addSubview:self.scrollView];
+    
+    _backgroundColor = [UIColor whiteColor];
+    self.opaque = NO;
+    _selectionIndicatorColor = [UIColor colorWithRed:52.0f/255.0f green:181.0f/255.0f blue:229.0f/255.0f alpha:1.0f];
+    _selectionIndicatorBoxColor = _selectionIndicatorColor;
+
+    self.selectedSegmentIndex = 0;
+    self.segmentEdgeInset = UIEdgeInsetsMake(0, 5, 0, 5);
+    self.selectionIndicatorHeight = 5.0f;
+    self.selectionIndicatorEdgeInsets = UIEdgeInsetsMake(0.0f, 0.0f, 0.0f, 0.0f);
+    self.selectionStyle = HMSegmentedControlSelectionStyleTextWidthStripe;
+    self.selectionIndicatorLocation = HMSegmentedControlSelectionIndicatorLocationUp;
+    self.segmentWidthStyle = HMSegmentedControlSegmentWidthStyleFixed;
+    self.userDraggable = YES;
+    self.touchEnabled = YES;
+    self.verticalDividerEnabled = NO;
+    self.type = HMSegmentedControlTypeText;
+    self.verticalDividerWidth = 1.0f;
+    _verticalDividerColor = [UIColor blackColor];
+    self.borderColor = [UIColor blackColor];
+    self.borderWidth = 1.0f;
+    
+    self.shouldAnimateUserSelection = YES;
+    
+    self.selectionIndicatorArrowLayer = [CALayer layer];
+    self.selectionIndicatorStripLayer = [CALayer layer];
+    self.selectionIndicatorBoxLayer = [CALayer layer];
+    self.selectionIndicatorBoxLayer.opacity = self.selectionIndicatorBoxOpacity;
+    self.selectionIndicatorBoxLayer.borderWidth = 1.0f;
+    self.selectionIndicatorBoxOpacity = 0.2;
+    
+    self.contentMode = UIViewContentModeRedraw;
+}
+
+- (void)layoutSubviews {
+    [super layoutSubviews];
+    
+    [self updateSegmentsRects];
+}
+
+- (void)setFrame:(CGRect)frame {
+    [super setFrame:frame];
+    
+    [self updateSegmentsRects];
+}
+
+- (void)setSectionTitles:(NSArray<NSString *> *)sectionTitles {
+    _sectionTitles = sectionTitles;
+    
+    [self setNeedsLayout];
+    [self setNeedsDisplay];
+}
+
+- (void)setSectionImages:(NSArray<UIImage *> *)sectionImages {
+    _sectionImages = sectionImages;
+    
+    [self setNeedsLayout];
+    [self setNeedsDisplay];
+}
+
+- (void)setSelectionIndicatorLocation:(HMSegmentedControlSelectionIndicatorLocation)selectionIndicatorLocation {
+	_selectionIndicatorLocation = selectionIndicatorLocation;
+	
+	if (selectionIndicatorLocation == HMSegmentedControlSelectionIndicatorLocationNone) {
+		self.selectionIndicatorHeight = 0.0f;
+	}
+}
+
+- (void)setSelectionIndicatorBoxOpacity:(CGFloat)selectionIndicatorBoxOpacity {
+    _selectionIndicatorBoxOpacity = selectionIndicatorBoxOpacity;
+    
+    self.selectionIndicatorBoxLayer.opacity = _selectionIndicatorBoxOpacity;
+}
+
+- (void)setSegmentWidthStyle:(HMSegmentedControlSegmentWidthStyle)segmentWidthStyle {
+    // Force HMSegmentedControlSegmentWidthStyleFixed when type is HMSegmentedControlTypeImages.
+    if (self.type == HMSegmentedControlTypeImages) {
+        _segmentWidthStyle = HMSegmentedControlSegmentWidthStyleFixed;
+    } else {
+        _segmentWidthStyle = segmentWidthStyle;
+    }
+}
+
+- (void)setBorderType:(HMSegmentedControlBorderType)borderType {
+    _borderType = borderType;
+    [self setNeedsDisplay];
+}
+
+#pragma mark - Drawing
+
+- (CGSize)measureTitleAtIndex:(NSUInteger)index {
+    if (index >= self.sectionTitles.count) {
+        return CGSizeZero;
+    }
+    
+    id title = self.sectionTitles[index];
+    CGSize size = CGSizeZero;
+    BOOL selected = (index == self.selectedSegmentIndex) ? YES : NO;
+    if ([title isKindOfClass:[NSString class]] && !self.titleFormatter) {
+        NSDictionary *titleAttrs = selected ? [self resultingSelectedTitleTextAttributes] : [self resultingTitleTextAttributes];
+        size = [(NSString *)title sizeWithAttributes:titleAttrs];
+    } else if ([title isKindOfClass:[NSString class]] && self.titleFormatter) {
+        size = [self.titleFormatter(self, title, index, selected) size];
+    } else if ([title isKindOfClass:[NSAttributedString class]]) {
+        size = [(NSAttributedString *)title size];
+    } else {
+        NSAssert(title == nil, @"Unexpected type of segment title: %@", [title class]);
+        size = CGSizeZero;
+    }
+    return CGRectIntegral((CGRect){CGPointZero, size}).size;
+}
+
+- (NSAttributedString *)attributedTitleAtIndex:(NSUInteger)index {
+    id title = self.sectionTitles[index];
+    BOOL selected = (index == self.selectedSegmentIndex) ? YES : NO;
+    
+    if ([title isKindOfClass:[NSAttributedString class]]) {
+        return (NSAttributedString *)title;
+    } else if (!self.titleFormatter) {
+        NSDictionary *titleAttrs = selected ? [self resultingSelectedTitleTextAttributes] : [self resultingTitleTextAttributes];
+        
+        // the color should be cast to CGColor in order to avoid invalid context on iOS7
+        UIColor *titleColor = titleAttrs[NSForegroundColorAttributeName];
+        
+        if (titleColor) {
+            NSMutableDictionary *dict = [NSMutableDictionary dictionaryWithDictionary:titleAttrs];
+            
+            dict[NSForegroundColorAttributeName] = (id)titleColor.CGColor;
+            
+            titleAttrs = [NSDictionary dictionaryWithDictionary:dict];
+        }
+        
+        return [[NSAttributedString alloc] initWithString:(NSString *)title attributes:titleAttrs];
+    } else {
+        return self.titleFormatter(self, title, index, selected);
+    }
+}
+
+- (void)drawRect:(CGRect)rect {
+    [self.backgroundColor setFill];
+    UIRectFill([self bounds]);
+    
+    self.selectionIndicatorArrowLayer.backgroundColor = self.selectionIndicatorColor.CGColor;
+    
+    self.selectionIndicatorStripLayer.backgroundColor = self.selectionIndicatorColor.CGColor;
+    
+    self.selectionIndicatorBoxLayer.backgroundColor = self.selectionIndicatorBoxColor.CGColor;
+    self.selectionIndicatorBoxLayer.borderColor = self.selectionIndicatorBoxColor.CGColor;
+    
+    // Remove all sublayers to avoid drawing images over existing ones
+    self.scrollView.layer.sublayers = nil;
+    
+    CGRect oldRect = rect;
+    
+    if (self.type == HMSegmentedControlTypeText) {
+        [self.sectionTitles enumerateObjectsUsingBlock:^(id titleString, NSUInteger idx, BOOL *stop) {
+
+            CGFloat stringWidth = 0;
+            CGFloat stringHeight = 0;
+            CGSize size = [self measureTitleAtIndex:idx];
+            stringWidth = size.width;
+            stringHeight = size.height;
+            CGRect rectDiv = CGRectZero;
+            CGRect fullRect = CGRectZero;
+            
+            // Text inside the CATextLayer will appear blurry unless the rect values are rounded
+            BOOL locationUp = (self.selectionIndicatorLocation == HMSegmentedControlSelectionIndicatorLocationUp);
+            BOOL selectionStyleNotBox = (self.selectionStyle != HMSegmentedControlSelectionStyleBox);
+
+            CGFloat y = roundf((CGRectGetHeight(self.frame) - selectionStyleNotBox * self.selectionIndicatorHeight) / 2 - stringHeight / 2 + self.selectionIndicatorHeight * locationUp);
+            CGRect rect;
+            if (self.segmentWidthStyle == HMSegmentedControlSegmentWidthStyleFixed) {
+                rect = CGRectMake((self.segmentWidth * idx) + (self.segmentWidth - stringWidth) / 2, y, stringWidth, stringHeight);
+                rectDiv = CGRectMake((self.segmentWidth * idx) - (self.verticalDividerWidth / 2), self.selectionIndicatorHeight * 2, self.verticalDividerWidth, self.frame.size.height - (self.selectionIndicatorHeight * 4));
+                fullRect = CGRectMake(self.segmentWidth * idx, 0, self.segmentWidth, oldRect.size.height);
+            } else {
+                // When we are drawing dynamic widths, we need to loop the widths array to calculate the xOffset
+                CGFloat xOffset = 0;
+                NSInteger i = 0;
+                for (NSNumber *width in self.segmentWidthsArray) {
+                    if (idx == i)
+                        break;
+                    xOffset = xOffset + [width floatValue];
+                    i++;
+                }
+                
+                CGFloat widthForIndex = [[self.segmentWidthsArray objectAtIndex:idx] floatValue];
+                rect = CGRectMake(xOffset, y, widthForIndex, stringHeight);
+                fullRect = CGRectMake(self.segmentWidth * idx, 0, widthForIndex, oldRect.size.height);
+                rectDiv = CGRectMake(xOffset - (self.verticalDividerWidth / 2), self.selectionIndicatorHeight * 2, self.verticalDividerWidth, self.frame.size.height - (self.selectionIndicatorHeight * 4));
+            }
+            
+            // Fix rect position/size to avoid blurry labels
+            rect = CGRectMake(ceilf(rect.origin.x), ceilf(rect.origin.y), ceilf(rect.size.width), ceilf(rect.size.height));
+            
+            CATextLayer *titleLayer = [CATextLayer layer];
+            titleLayer.frame = rect;
+            titleLayer.alignmentMode = kCAAlignmentCenter;
+            if ([UIDevice currentDevice].systemVersion.floatValue < 10.0 ) {
+                titleLayer.truncationMode = kCATruncationEnd;
+            }
+            titleLayer.string = [self attributedTitleAtIndex:idx];
+            titleLayer.contentsScale = [[UIScreen mainScreen] scale];
+            
+            [self.scrollView.layer addSublayer:titleLayer];
+            
+            // Vertical Divider
+            if (self.isVerticalDividerEnabled && idx > 0) {
+                CALayer *verticalDividerLayer = [CALayer layer];
+                verticalDividerLayer.frame = rectDiv;
+                verticalDividerLayer.backgroundColor = self.verticalDividerColor.CGColor;
+                
+                [self.scrollView.layer addSublayer:verticalDividerLayer];
+            }
+        
+            [self addBackgroundAndBorderLayerWithRect:fullRect];
+        }];
+    } else if (self.type == HMSegmentedControlTypeImages) {
+        [self.sectionImages enumerateObjectsUsingBlock:^(id iconImage, NSUInteger idx, BOOL *stop) {
+            UIImage *icon = iconImage;
+            CGFloat imageWidth = icon.size.width;
+            CGFloat imageHeight = icon.size.height;
+            CGFloat y = roundf(CGRectGetHeight(self.frame) - self.selectionIndicatorHeight) / 2 - imageHeight / 2 + ((self.selectionIndicatorLocation == HMSegmentedControlSelectionIndicatorLocationUp) ? self.selectionIndicatorHeight : 0);
+            CGFloat x = self.segmentWidth * idx + (self.segmentWidth - imageWidth)/2.0f;
+            CGRect rect = CGRectMake(x, y, imageWidth, imageHeight);
+            
+            CALayer *imageLayer = [CALayer layer];
+            imageLayer.frame = rect;
+            
+            if (self.selectedSegmentIndex == idx) {
+                if (self.sectionSelectedImages) {
+                    UIImage *highlightIcon = [self.sectionSelectedImages objectAtIndex:idx];
+                    imageLayer.contents = (id)highlightIcon.CGImage;
+                } else {
+                    imageLayer.contents = (id)icon.CGImage;
+                }
+            } else {
+                imageLayer.contents = (id)icon.CGImage;
+            }
+            
+            [self.scrollView.layer addSublayer:imageLayer];
+            // Vertical Divider
+            if (self.isVerticalDividerEnabled && idx>0) {
+                CALayer *verticalDividerLayer = [CALayer layer];
+                verticalDividerLayer.frame = CGRectMake((self.segmentWidth * idx) - (self.verticalDividerWidth / 2), self.selectionIndicatorHeight * 2, self.verticalDividerWidth, self.frame.size.height-(self.selectionIndicatorHeight * 4));
+                verticalDividerLayer.backgroundColor = self.verticalDividerColor.CGColor;
+                
+                [self.scrollView.layer addSublayer:verticalDividerLayer];
+            }
+            
+            [self addBackgroundAndBorderLayerWithRect:rect];
+        }];
+    } else if (self.type == HMSegmentedControlTypeTextImages){
+		[self.sectionImages enumerateObjectsUsingBlock:^(id iconImage, NSUInteger idx, BOOL *stop) {
+            UIImage *icon = iconImage;
+            CGFloat imageWidth = icon.size.width;
+            CGFloat imageHeight = icon.size.height;
+			
+            CGSize stringSize = [self measureTitleAtIndex:idx];
+            CGFloat stringHeight = stringSize.height;
+            CGFloat stringWidth = stringSize.width;
+            
+            CGFloat imageXOffset = self.segmentWidth * idx; // Start with edge inset
+            CGFloat textXOffset  = self.segmentWidth * idx;
+            CGFloat imageYOffset = ceilf((self.frame.size.height - imageHeight) / 2.0); // Start in center
+            CGFloat textYOffset  = ceilf((self.frame.size.height - stringHeight) / 2.0);
+            
+            
+            if (self.segmentWidthStyle == HMSegmentedControlSegmentWidthStyleFixed) {
+                BOOL isImageInLineWidthText = self.imagePosition == HMSegmentedControlImagePositionLeftOfText || self.imagePosition == HMSegmentedControlImagePositionRightOfText;
+                if (isImageInLineWidthText) {
+                    CGFloat whitespace = self.segmentWidth - stringSize.width - imageWidth - self.textImageSpacing;
+                    if (self.imagePosition == HMSegmentedControlImagePositionLeftOfText) {
+                        imageXOffset += whitespace / 2.0;
+                        textXOffset = imageXOffset + imageWidth + self.textImageSpacing;
+                    } else {
+                        textXOffset += whitespace / 2.0;
+                        imageXOffset = textXOffset + stringWidth + self.textImageSpacing;
+                    }
+                } else {
+                    imageXOffset = self.segmentWidth * idx + (self.segmentWidth - imageWidth) / 2.0f; // Start with edge inset
+                    textXOffset  = self.segmentWidth * idx + (self.segmentWidth - stringWidth) / 2.0f;
+                    
+                    CGFloat whitespace = CGRectGetHeight(self.frame) - imageHeight - stringHeight - self.textImageSpacing;
+                    if (self.imagePosition == HMSegmentedControlImagePositionAboveText) {
+                        imageYOffset = ceilf(whitespace / 2.0);
+                        textYOffset = imageYOffset + imageHeight + self.textImageSpacing;
+                    } else if (self.imagePosition == HMSegmentedControlImagePositionBelowText) {
+                        textYOffset = ceilf(whitespace / 2.0);
+                        imageYOffset = textYOffset + stringHeight + self.textImageSpacing;
+                    }
+                }
+            } else if (self.segmentWidthStyle == HMSegmentedControlSegmentWidthStyleDynamic) {
+                // When we are drawing dynamic widths, we need to loop the widths array to calculate the xOffset
+                CGFloat xOffset = 0;
+                NSInteger i = 0;
+                
+                for (NSNumber *width in self.segmentWidthsArray) {
+                    if (idx == i) {
+                        break;
+                    }
+                    
+                    xOffset = xOffset + [width floatValue];
+                    i++;
+                }
+                
+                BOOL isImageInLineWidthText = self.imagePosition == HMSegmentedControlImagePositionLeftOfText || self.imagePosition == HMSegmentedControlImagePositionRightOfText;
+                if (isImageInLineWidthText) {
+                    if (self.imagePosition == HMSegmentedControlImagePositionLeftOfText) {
+                        imageXOffset = xOffset;
+                        textXOffset = imageXOffset + imageWidth + self.textImageSpacing;
+                    } else {
+                        textXOffset = xOffset;
+                        imageXOffset = textXOffset + stringWidth + self.textImageSpacing;
+                    }
+                } else {
+                    imageXOffset = xOffset + ([self.segmentWidthsArray[i] floatValue] - imageWidth) / 2.0f; // Start with edge inset
+                    textXOffset  = xOffset + ([self.segmentWidthsArray[i] floatValue] - stringWidth) / 2.0f;
+                    
+                    CGFloat whitespace = CGRectGetHeight(self.frame) - imageHeight - stringHeight - self.textImageSpacing;
+                    if (self.imagePosition == HMSegmentedControlImagePositionAboveText) {
+                        imageYOffset = ceilf(whitespace / 2.0);
+                        textYOffset = imageYOffset + imageHeight + self.textImageSpacing;
+                    } else if (self.imagePosition == HMSegmentedControlImagePositionBelowText) {
+                        textYOffset = ceilf(whitespace / 2.0);
+                        imageYOffset = textYOffset + stringHeight + self.textImageSpacing;
+                    }
+                }
+            }
+            
+            CGRect imageRect = CGRectMake(imageXOffset, imageYOffset, imageWidth, imageHeight);
+            CGRect textRect = CGRectMake(ceilf(textXOffset), ceilf(textYOffset), ceilf(stringWidth), ceilf(stringHeight));
+
+            CATextLayer *titleLayer = [CATextLayer layer];
+            titleLayer.frame = textRect;
+            titleLayer.alignmentMode = kCAAlignmentCenter;
+            titleLayer.string = [self attributedTitleAtIndex:idx];
+            if ([UIDevice currentDevice].systemVersion.floatValue < 10.0 ) {
+                titleLayer.truncationMode = kCATruncationEnd;
+            }
+            CALayer *imageLayer = [CALayer layer];
+            imageLayer.frame = imageRect;
+			
+            if (self.selectedSegmentIndex == idx) {
+                if (self.sectionSelectedImages) {
+                    UIImage *highlightIcon = [self.sectionSelectedImages objectAtIndex:idx];
+                    imageLayer.contents = (id)highlightIcon.CGImage;
+                } else {
+                    imageLayer.contents = (id)icon.CGImage;
+                }
+            } else {
+                imageLayer.contents = (id)icon.CGImage;
+            }
+            
+            [self.scrollView.layer addSublayer:imageLayer];
+			titleLayer.contentsScale = [[UIScreen mainScreen] scale];
+            [self.scrollView.layer addSublayer:titleLayer];
+			
+            [self addBackgroundAndBorderLayerWithRect:imageRect];
+        }];
+	}
+    
+    // Add the selection indicators
+    if (self.selectedSegmentIndex != HMSegmentedControlNoSegment) {
+        if (self.selectionStyle == HMSegmentedControlSelectionStyleArrow) {
+            if (!self.selectionIndicatorArrowLayer.superlayer) {
+                [self setArrowFrame];
+                [self.scrollView.layer addSublayer:self.selectionIndicatorArrowLayer];
+            }
+        } else {
+            if (!self.selectionIndicatorStripLayer.superlayer) {
+                self.selectionIndicatorStripLayer.frame = [self frameForSelectionIndicator];
+                [self.scrollView.layer addSublayer:self.selectionIndicatorStripLayer];
+                
+                if (self.selectionStyle == HMSegmentedControlSelectionStyleBox && !self.selectionIndicatorBoxLayer.superlayer) {
+                    self.selectionIndicatorBoxLayer.frame = [self frameForFillerSelectionIndicator];
+                    [self.scrollView.layer insertSublayer:self.selectionIndicatorBoxLayer atIndex:0];
+                }
+            }
+        }
+    }
+}
+
+- (void)addBackgroundAndBorderLayerWithRect:(CGRect)fullRect {
+    // Background layer
+    CALayer *backgroundLayer = [CALayer layer];
+    backgroundLayer.frame = fullRect;
+    [self.layer insertSublayer:backgroundLayer atIndex:0];
+    
+    // Border layer
+    if (self.borderType & HMSegmentedControlBorderTypeTop) {
+        CALayer *borderLayer = [CALayer layer];
+        borderLayer.frame = CGRectMake(0, 0, fullRect.size.width, self.borderWidth);
+        borderLayer.backgroundColor = self.borderColor.CGColor;
+        [backgroundLayer addSublayer: borderLayer];
+    }
+    if (self.borderType & HMSegmentedControlBorderTypeLeft) {
+        CALayer *borderLayer = [CALayer layer];
+        borderLayer.frame = CGRectMake(0, 0, self.borderWidth, fullRect.size.height);
+        borderLayer.backgroundColor = self.borderColor.CGColor;
+        [backgroundLayer addSublayer: borderLayer];
+    }
+    if (self.borderType & HMSegmentedControlBorderTypeBottom) {
+        CALayer *borderLayer = [CALayer layer];
+        borderLayer.frame = CGRectMake(0, fullRect.size.height - self.borderWidth, fullRect.size.width, self.borderWidth);
+        borderLayer.backgroundColor = self.borderColor.CGColor;
+        [backgroundLayer addSublayer: borderLayer];
+    }
+    if (self.borderType & HMSegmentedControlBorderTypeRight) {
+        CALayer *borderLayer = [CALayer layer];
+        borderLayer.frame = CGRectMake(fullRect.size.width - self.borderWidth, 0, self.borderWidth, fullRect.size.height);
+        borderLayer.backgroundColor = self.borderColor.CGColor;
+        [backgroundLayer addSublayer: borderLayer];
+    }
+}
+
+- (void)setArrowFrame {
+    self.selectionIndicatorArrowLayer.frame = [self frameForSelectionIndicator];
+    
+    self.selectionIndicatorArrowLayer.mask = nil;
+    
+    UIBezierPath *arrowPath = [UIBezierPath bezierPath];
+    
+    CGPoint p1 = CGPointZero;
+    CGPoint p2 = CGPointZero;
+    CGPoint p3 = CGPointZero;
+    
+    if (self.selectionIndicatorLocation == HMSegmentedControlSelectionIndicatorLocationDown) {
+        p1 = CGPointMake(self.selectionIndicatorArrowLayer.bounds.size.width / 2, 0);
+        p2 = CGPointMake(0, self.selectionIndicatorArrowLayer.bounds.size.height);
+        p3 = CGPointMake(self.selectionIndicatorArrowLayer.bounds.size.width, self.selectionIndicatorArrowLayer.bounds.size.height);
+    }
+    
+    if (self.selectionIndicatorLocation == HMSegmentedControlSelectionIndicatorLocationUp) {
+        p1 = CGPointMake(self.selectionIndicatorArrowLayer.bounds.size.width / 2, self.selectionIndicatorArrowLayer.bounds.size.height);
+        p2 = CGPointMake(self.selectionIndicatorArrowLayer.bounds.size.width, 0);
+        p3 = CGPointMake(0, 0);
+    }
+    
+    [arrowPath moveToPoint:p1];
+    [arrowPath addLineToPoint:p2];
+    [arrowPath addLineToPoint:p3];
+    [arrowPath closePath];
+    
+    CAShapeLayer *maskLayer = [[CAShapeLayer alloc] init];
+    maskLayer.frame = self.selectionIndicatorArrowLayer.bounds;
+    maskLayer.path = arrowPath.CGPath;
+    self.selectionIndicatorArrowLayer.mask = maskLayer;
+}
+
+- (CGRect)frameForSelectionIndicator {
+    CGFloat indicatorYOffset = 0.0f;
+    
+    if (self.selectionIndicatorLocation == HMSegmentedControlSelectionIndicatorLocationDown) {
+        indicatorYOffset = self.bounds.size.height - self.selectionIndicatorHeight + self.selectionIndicatorEdgeInsets.bottom;
+    }
+    
+    if (self.selectionIndicatorLocation == HMSegmentedControlSelectionIndicatorLocationUp) {
+        indicatorYOffset = self.selectionIndicatorEdgeInsets.top;
+    }
+    
+    CGFloat sectionWidth = 0.0f;
+    
+    if (self.type == HMSegmentedControlTypeText) {
+        CGFloat stringWidth = [self measureTitleAtIndex:self.selectedSegmentIndex].width;
+        sectionWidth = stringWidth;
+    } else if (self.type == HMSegmentedControlTypeImages) {
+        UIImage *sectionImage = [self.sectionImages objectAtIndex:self.selectedSegmentIndex];
+        CGFloat imageWidth = sectionImage.size.width;
+        sectionWidth = imageWidth;
+    } else if (self.type == HMSegmentedControlTypeTextImages) {
+		CGFloat stringWidth = [self measureTitleAtIndex:self.selectedSegmentIndex].width;
+		UIImage *sectionImage = [self.sectionImages objectAtIndex:self.selectedSegmentIndex];
+		CGFloat imageWidth = sectionImage.size.width;
+        sectionWidth = MAX(stringWidth, imageWidth);
+	}
+    
+    if (self.selectionStyle == HMSegmentedControlSelectionStyleArrow) {
+        CGFloat widthToEndOfSelectedSegment = (self.segmentWidth * self.selectedSegmentIndex) + self.segmentWidth;
+        CGFloat widthToStartOfSelectedIndex = (self.segmentWidth * self.selectedSegmentIndex);
+        
+        CGFloat x = widthToStartOfSelectedIndex + ((widthToEndOfSelectedSegment - widthToStartOfSelectedIndex) / 2) - (self.selectionIndicatorHeight/2);
+        return CGRectMake(x - (self.selectionIndicatorHeight / 2), indicatorYOffset, self.selectionIndicatorHeight * 2, self.selectionIndicatorHeight);
+    } else {
+        if (self.selectionStyle == HMSegmentedControlSelectionStyleTextWidthStripe &&
+            sectionWidth <= self.segmentWidth &&
+            self.segmentWidthStyle != HMSegmentedControlSegmentWidthStyleDynamic) {
+            CGFloat widthToEndOfSelectedSegment = (self.segmentWidth * self.selectedSegmentIndex) + self.segmentWidth;
+            CGFloat widthToStartOfSelectedIndex = (self.segmentWidth * self.selectedSegmentIndex);
+            
+            CGFloat x = ((widthToEndOfSelectedSegment - widthToStartOfSelectedIndex) / 2) + (widthToStartOfSelectedIndex - sectionWidth / 2);
+            return CGRectMake(x + self.selectionIndicatorEdgeInsets.left, indicatorYOffset, sectionWidth - self.selectionIndicatorEdgeInsets.right, self.selectionIndicatorHeight);
+        } else {
+            if (self.segmentWidthStyle == HMSegmentedControlSegmentWidthStyleDynamic) {
+                CGFloat selectedSegmentOffset = 0.0f;
+                
+                NSInteger i = 0;
+                for (NSNumber *width in self.segmentWidthsArray) {
+                    if (self.selectedSegmentIndex == i)
+                        break;
+                    selectedSegmentOffset = selectedSegmentOffset + [width floatValue];
+                    i++;
+                }
+                return CGRectMake(selectedSegmentOffset + self.selectionIndicatorEdgeInsets.left, indicatorYOffset, [[self.segmentWidthsArray objectAtIndex:self.selectedSegmentIndex] floatValue] - self.selectionIndicatorEdgeInsets.right, self.selectionIndicatorHeight + self.selectionIndicatorEdgeInsets.bottom);
+            }
+            
+            return CGRectMake((self.segmentWidth + self.selectionIndicatorEdgeInsets.left) * self.selectedSegmentIndex, indicatorYOffset, self.segmentWidth - self.selectionIndicatorEdgeInsets.right, self.selectionIndicatorHeight);
+        }
+    }
+}
+
+- (CGRect)frameForFillerSelectionIndicator {
+    if (self.segmentWidthStyle == HMSegmentedControlSegmentWidthStyleDynamic) {
+        CGFloat selectedSegmentOffset = 0.0f;
+        
+        NSInteger i = 0;
+        for (NSNumber *width in self.segmentWidthsArray) {
+            if (self.selectedSegmentIndex == i) {
+                break;
+            }
+            selectedSegmentOffset = selectedSegmentOffset + [width floatValue];
+            
+            i++;
+        }
+        
+        return CGRectMake(selectedSegmentOffset, 0, [[self.segmentWidthsArray objectAtIndex:self.selectedSegmentIndex] floatValue], CGRectGetHeight(self.frame));
+    }
+    return CGRectMake(self.segmentWidth * self.selectedSegmentIndex, 0, self.segmentWidth, CGRectGetHeight(self.frame));
+}
+
+- (void)updateSegmentsRects {
+    self.scrollView.contentInset = UIEdgeInsetsZero;
+    self.scrollView.frame = CGRectMake(0, 0, CGRectGetWidth(self.frame), CGRectGetHeight(self.frame));
+    
+    if ([self sectionCount] > 0) {
+        self.segmentWidth = self.frame.size.width / [self sectionCount];
+    }
+    
+    if (self.type == HMSegmentedControlTypeText && self.segmentWidthStyle == HMSegmentedControlSegmentWidthStyleFixed) {
+        [self.sectionTitles enumerateObjectsUsingBlock:^(id titleString, NSUInteger idx, BOOL *stop) {
+            CGFloat stringWidth = [self measureTitleAtIndex:idx].width + self.segmentEdgeInset.left + self.segmentEdgeInset.right;
+            self.segmentWidth = MAX(stringWidth, self.segmentWidth);
+        }];
+    } else if (self.type == HMSegmentedControlTypeText && self.segmentWidthStyle == HMSegmentedControlSegmentWidthStyleDynamic) {
+        NSMutableArray *mutableSegmentWidths = [NSMutableArray array];
+        
+        [self.sectionTitles enumerateObjectsUsingBlock:^(id titleString, NSUInteger idx, BOOL *stop) {
+            CGFloat stringWidth = [self measureTitleAtIndex:idx].width + self.segmentEdgeInset.left + self.segmentEdgeInset.right;
+            [mutableSegmentWidths addObject:[NSNumber numberWithFloat:stringWidth]];
+        }];
+        self.segmentWidthsArray = [mutableSegmentWidths copy];
+    } else if (self.type == HMSegmentedControlTypeImages) {
+        for (UIImage *sectionImage in self.sectionImages) {
+            CGFloat imageWidth = sectionImage.size.width + self.segmentEdgeInset.left + self.segmentEdgeInset.right;
+            self.segmentWidth = MAX(imageWidth, self.segmentWidth);
+        }
+    } else if (self.type == HMSegmentedControlTypeTextImages && self.segmentWidthStyle == HMSegmentedControlSegmentWidthStyleFixed){
+        //lets just use the title.. we will assume it is wider then images...
+        [self.sectionTitles enumerateObjectsUsingBlock:^(id titleString, NSUInteger idx, BOOL *stop) {
+            CGFloat stringWidth = [self measureTitleAtIndex:idx].width + self.segmentEdgeInset.left + self.segmentEdgeInset.right;
+            self.segmentWidth = MAX(stringWidth, self.segmentWidth);
+        }];
+    } else if (self.type == HMSegmentedControlTypeTextImages && self.segmentWidthStyle == HMSegmentedControlSegmentWidthStyleDynamic) {
+        NSMutableArray *mutableSegmentWidths = [NSMutableArray array];
+        __block CGFloat totalWidth = 0.0;
+        
+        int i = 0;
+        [self.sectionTitles enumerateObjectsUsingBlock:^(id titleString, NSUInteger idx, BOOL *stop) {
+            CGFloat stringWidth = [self measureTitleAtIndex:idx].width + self.segmentEdgeInset.right;
+            UIImage *sectionImage = [self.sectionImages objectAtIndex:i];
+            CGFloat imageWidth = sectionImage.size.width + self.segmentEdgeInset.left;
+            
+            CGFloat combinedWidth = 0.0;
+            if (self.imagePosition == HMSegmentedControlImagePositionLeftOfText || self.imagePosition == HMSegmentedControlImagePositionRightOfText) {
+                combinedWidth = imageWidth + stringWidth + self.textImageSpacing;
+            } else {
+                combinedWidth = MAX(imageWidth, stringWidth);
+            }
+            
+            totalWidth += combinedWidth;
+            
+            [mutableSegmentWidths addObject:[NSNumber numberWithFloat:combinedWidth]];
+        }];
+        
+        if (self.shouldStretchSegmentsToScreenSize && totalWidth < self.bounds.size.width) {
+            CGFloat whitespace = self.bounds.size.width - totalWidth;
+            CGFloat whitespaceForSegment = whitespace / [mutableSegmentWidths count];
+            [mutableSegmentWidths enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
+                CGFloat extendedWidth = whitespaceForSegment + [obj floatValue];
+                [mutableSegmentWidths replaceObjectAtIndex:idx withObject:[NSNumber numberWithFloat:extendedWidth]];
+            }];
+        }
+        
+        self.segmentWidthsArray = [mutableSegmentWidths copy];
+    }
+
+    self.scrollView.scrollEnabled = self.isUserDraggable;
+    self.scrollView.contentSize = CGSizeMake([self totalSegmentedControlWidth], self.frame.size.height);
+}
+
+- (NSUInteger)sectionCount {
+    if (self.type == HMSegmentedControlTypeText) {
+        return self.sectionTitles.count;
+    } else if (self.type == HMSegmentedControlTypeImages ||
+               self.type == HMSegmentedControlTypeTextImages) {
+        return self.sectionImages.count;
+    }
+    
+    return 0;
+}
+
+- (void)willMoveToSuperview:(UIView *)newSuperview {
+    // Control is being removed
+    if (newSuperview == nil)
+        return;
+    
+    if (self.sectionTitles || self.sectionImages) {
+        [self updateSegmentsRects];
+    }
+}
+
+#pragma mark - Touch
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+    UITouch *touch = [touches anyObject];
+    CGPoint touchLocation = [touch locationInView:self];
+    
+    CGRect enlargeRect =   CGRectMake(self.bounds.origin.x - self.enlargeEdgeInset.left,
+                      self.bounds.origin.y - self.enlargeEdgeInset.top,
+                      self.bounds.size.width + self.enlargeEdgeInset.left + self.enlargeEdgeInset.right,
+                      self.bounds.size.height + self.enlargeEdgeInset.top + self.enlargeEdgeInset.bottom);
+    
+    if (CGRectContainsPoint(enlargeRect, touchLocation)) {
+        NSInteger segment = 0;
+        if (self.segmentWidthStyle == HMSegmentedControlSegmentWidthStyleFixed) {
+            segment = (touchLocation.x + self.scrollView.contentOffset.x) / self.segmentWidth;
+        } else if (self.segmentWidthStyle == HMSegmentedControlSegmentWidthStyleDynamic) {
+            // To know which segment the user touched, we need to loop over the widths and substract it from the x position.
+            CGFloat widthLeft = (touchLocation.x + self.scrollView.contentOffset.x);
+            for (NSNumber *width in self.segmentWidthsArray) {
+                widthLeft = widthLeft - [width floatValue];
+                
+                // When we don't have any width left to substract, we have the segment index.
+                if (widthLeft <= 0)
+                    break;
+                
+                segment++;
+            }
+        }
+        
+        NSUInteger sectionsCount = 0;
+        
+        if (self.type == HMSegmentedControlTypeImages) {
+            sectionsCount = [self.sectionImages count];
+        } else if (self.type == HMSegmentedControlTypeTextImages || self.type == HMSegmentedControlTypeText) {
+            sectionsCount = [self.sectionTitles count];
+        }
+        
+        if (segment != self.selectedSegmentIndex && segment < sectionsCount) {
+            // Check if we have to do anything with the touch event
+            if (self.isTouchEnabled)
+                [self setSelectedSegmentIndex:segment animated:self.shouldAnimateUserSelection notify:YES];
+        }
+    }
+}
+
+#pragma mark - Scrolling
+
+- (CGFloat)totalSegmentedControlWidth {
+    if (self.type == HMSegmentedControlTypeText && self.segmentWidthStyle == HMSegmentedControlSegmentWidthStyleFixed) {
+        return self.sectionTitles.count * self.segmentWidth;
+    } else if (self.segmentWidthStyle == HMSegmentedControlSegmentWidthStyleDynamic) {
+        return [[self.segmentWidthsArray valueForKeyPath:@"@sum.self"] floatValue];
+    } else {
+        return self.sectionImages.count * self.segmentWidth;
+    }
+}
+
+- (void)scrollToSelectedSegmentIndex:(BOOL)animated {
+    CGRect rectForSelectedIndex = CGRectZero;
+    CGFloat selectedSegmentOffset = 0;
+    if (self.segmentWidthStyle == HMSegmentedControlSegmentWidthStyleFixed) {
+        rectForSelectedIndex = CGRectMake(self.segmentWidth * self.selectedSegmentIndex,
+                                          0,
+                                          self.segmentWidth,
+                                          self.frame.size.height);
+        
+        selectedSegmentOffset = (CGRectGetWidth(self.frame) / 2) - (self.segmentWidth / 2);
+    } else {
+        NSInteger i = 0;
+        CGFloat offsetter = 0;
+        for (NSNumber *width in self.segmentWidthsArray) {
+            if (self.selectedSegmentIndex == i)
+                break;
+            offsetter = offsetter + [width floatValue];
+            i++;
+        }
+        
+        rectForSelectedIndex = CGRectMake(offsetter,
+                                          0,
+                                          [[self.segmentWidthsArray objectAtIndex:self.selectedSegmentIndex] floatValue],
+                                          self.frame.size.height);
+        
+        selectedSegmentOffset = (CGRectGetWidth(self.frame) / 2) - ([[self.segmentWidthsArray objectAtIndex:self.selectedSegmentIndex] floatValue] / 2);
+    }
+    
+    
+    CGRect rectToScrollTo = rectForSelectedIndex;
+    rectToScrollTo.origin.x -= selectedSegmentOffset;
+    rectToScrollTo.size.width += selectedSegmentOffset * 2;
+    [self.scrollView scrollRectToVisible:rectToScrollTo animated:animated];
+}
+
+#pragma mark - Index Change
+
+- (void)setSelectedSegmentIndex:(NSInteger)index {
+    [self setSelectedSegmentIndex:index animated:NO notify:NO];
+}
+
+- (void)setSelectedSegmentIndex:(NSUInteger)index animated:(BOOL)animated {
+    [self setSelectedSegmentIndex:index animated:animated notify:NO];
+}
+
+- (void)setSelectedSegmentIndex:(NSUInteger)index animated:(BOOL)animated notify:(BOOL)notify {
+    _selectedSegmentIndex = index;
+    [self setNeedsDisplay];
+    
+    if (index == HMSegmentedControlNoSegment) {
+        [self.selectionIndicatorArrowLayer removeFromSuperlayer];
+        [self.selectionIndicatorStripLayer removeFromSuperlayer];
+        [self.selectionIndicatorBoxLayer removeFromSuperlayer];
+    } else {
+        [self scrollToSelectedSegmentIndex:animated];
+        
+        if (animated) {
+            // If the selected segment layer is not added to the super layer, that means no
+            // index is currently selected, so add the layer then move it to the new
+            // segment index without animating.
+            if(self.selectionStyle == HMSegmentedControlSelectionStyleArrow) {
+                if ([self.selectionIndicatorArrowLayer superlayer] == nil) {
+                    [self.scrollView.layer addSublayer:self.selectionIndicatorArrowLayer];
+                    
+                    [self setSelectedSegmentIndex:index animated:NO notify:YES];
+                    return;
+                }
+            }else {
+                if ([self.selectionIndicatorStripLayer superlayer] == nil) {
+                    [self.scrollView.layer addSublayer:self.selectionIndicatorStripLayer];
+                    
+                    if (self.selectionStyle == HMSegmentedControlSelectionStyleBox && [self.selectionIndicatorBoxLayer superlayer] == nil)
+                        [self.scrollView.layer insertSublayer:self.selectionIndicatorBoxLayer atIndex:0];
+                    
+                    [self setSelectedSegmentIndex:index animated:NO notify:YES];
+                    return;
+                }
+            }
+            
+            if (notify)
+                [self notifyForSegmentChangeToIndex:index];
+            
+            // Restore CALayer animations
+            self.selectionIndicatorArrowLayer.actions = nil;
+            self.selectionIndicatorStripLayer.actions = nil;
+            self.selectionIndicatorBoxLayer.actions = nil;
+            
+            // Animate to new position
+            [CATransaction begin];
+            [CATransaction setAnimationDuration:0.15f];
+            [CATransaction setAnimationTimingFunction:[CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionLinear]];
+            [self setArrowFrame];
+            self.selectionIndicatorBoxLayer.frame = [self frameForSelectionIndicator];
+            self.selectionIndicatorStripLayer.frame = [self frameForSelectionIndicator];
+            self.selectionIndicatorBoxLayer.frame = [self frameForFillerSelectionIndicator];
+            [CATransaction commit];
+        } else {
+            // Disable CALayer animations
+            NSMutableDictionary *newActions = [[NSMutableDictionary alloc] initWithObjectsAndKeys:[NSNull null], @"position", [NSNull null], @"bounds", nil];
+            self.selectionIndicatorArrowLayer.actions = newActions;
+            [self setArrowFrame];
+            
+            self.selectionIndicatorStripLayer.actions = newActions;
+            self.selectionIndicatorStripLayer.frame = [self frameForSelectionIndicator];
+            
+            self.selectionIndicatorBoxLayer.actions = newActions;
+            self.selectionIndicatorBoxLayer.frame = [self frameForFillerSelectionIndicator];
+            
+            if (notify)
+                [self notifyForSegmentChangeToIndex:index];
+        }
+    }
+}
+
+- (void)notifyForSegmentChangeToIndex:(NSInteger)index {
+    if (self.superview)
+        [self sendActionsForControlEvents:UIControlEventValueChanged];
+    
+    if (self.indexChangeBlock)
+        self.indexChangeBlock(index);
+}
+
+#pragma mark - Styling Support
+
+- (NSDictionary *)resultingTitleTextAttributes {
+    NSDictionary *defaults = @{
+        NSFontAttributeName : [UIFont systemFontOfSize:19.0f],
+        NSForegroundColorAttributeName : [UIColor blackColor],
+    };
+    
+    NSMutableDictionary *resultingAttrs = [NSMutableDictionary dictionaryWithDictionary:defaults];
+    
+    if (self.titleTextAttributes) {
+        [resultingAttrs addEntriesFromDictionary:self.titleTextAttributes];
+    }
+
+    return [resultingAttrs copy];
+}
+
+- (NSDictionary *)resultingSelectedTitleTextAttributes {
+    NSMutableDictionary *resultingAttrs = [NSMutableDictionary dictionaryWithDictionary:[self resultingTitleTextAttributes]];
+    
+    if (self.selectedTitleTextAttributes) {
+        [resultingAttrs addEntriesFromDictionary:self.selectedTitleTextAttributes];
+    }
+    
+    return [resultingAttrs copy];
+}
+
+@end

lib/ios/RNNCommandsHandler.h

@@ -6,7 +6,7 @@
 
 @interface RNNCommandsHandler : NSObject
 
--(instancetype) initWithStore:(RNNStore*)store controllerFactory:(RNNControllerFactory*)controllerFactory andBridge:(RCTBridge*)bridge;
+-(instancetype) initWithStore:(RNNStore*)store controllerFactory:(RNNControllerFactory*)controllerFactory;
 
 -(void) setRoot:(NSDictionary*)layout completion:(RNNTransitionCompletionBlock)completion;
 

lib/ios/RNNCommandsHandler.m

@@ -8,14 +8,12 @@
 @implementation RNNCommandsHandler {
 	RNNControllerFactory *_controllerFactory;
 	RNNStore *_store;
-	RCTBridge* _bridge;
 	RNNNavigationStackManager* _navigationStackManager;
 	RNNModalManager* _modalManager;
 }
 
--(instancetype) initWithStore:(RNNStore*)store controllerFactory:(RNNControllerFactory*)controllerFactory andBridge:(RCTBridge*)bridge {
+-(instancetype) initWithStore:(RNNStore*)store controllerFactory:(RNNControllerFactory*)controllerFactory {
 	self = [super init];
-	_bridge = bridge;
 	_store = store;
 	_controllerFactory = controllerFactory;
 	_navigationStackManager = [[RNNNavigationStackManager alloc] initWithStore:_store];
@@ -58,9 +56,6 @@
 	[self assertReady];
 	
 	UIViewController<RNNRootViewProtocol> *newVc = [_controllerFactory createLayoutAndSaveToStore:layout];
-	UIViewController *fromVc = [_store findContainerForId:containerId];
-	[_bridge.uiManager setAvailableSize:fromVc.view.bounds.size forRootView:newVc.view];
-
 	[_navigationStackManager push:newVc onTop:containerId completion:completion];
 }
 

lib/ios/RNNControllerFactory.h

@@ -10,7 +10,8 @@
 
 -(instancetype)initWithRootViewCreator:(id <RNNRootViewCreator>)creator
 								 store:(RNNStore*)store
-						  eventEmitter:(RNNEventEmitter*)eventEmitter;
+						  eventEmitter:(RNNEventEmitter*)eventEmitter
+							 andBridge:(RCTBridge*)bridge;
 
 -(UIViewController<RNNRootViewProtocol> *)createLayoutAndSaveToStore:(NSDictionary*)layout;
 

lib/ios/RNNControllerFactory.m

@@ -7,11 +7,13 @@
 #import "RNNNavigationOptions.h"
 #import "RNNNavigationController.h"
 #import "RNNTabBarController.h"
+#import "RNNTopTabsViewController.h"
 
 @implementation RNNControllerFactory {
 	id<RNNRootViewCreator> _creator;
 	RNNStore *_store;
 	RNNEventEmitter *_eventEmitter;
+	RCTBridge *_bridge;
 }
 
 # pragma mark public
@@ -19,12 +21,14 @@
 
 - (instancetype)initWithRootViewCreator:(id <RNNRootViewCreator>)creator
 								  store:(RNNStore *)store
-						   eventEmitter:(RNNEventEmitter*)eventEmitter {
+						   eventEmitter:(RNNEventEmitter*)eventEmitter
+							  andBridge:(RCTBridge *)bridge {
 	
 	self = [super init];
 	_creator = creator;
 	_store = store;
 	_eventEmitter = eventEmitter;
+	_bridge = bridge;
 	
 	return self;
 }
@@ -40,7 +44,7 @@
 	
 	UIViewController<RNNRootViewProtocol> *result;
 	
-	if ( node.isContainer) {
+	if ( node.isContainer || node.isTopTab) {
 		result = [self createContainer:node];
 	}
 	
@@ -52,6 +56,10 @@
 		result = [self createTabs:node];
 	}
 	
+	else if (node.isTopTabs) {
+		result = [self createTopTabs:node];
+	}
+	
 	else if (node.isSideMenuRoot) {
 		result = [self createSideMenu:node];
 	}
@@ -82,7 +90,11 @@
 	RNNAnimator* animator = [[RNNAnimator alloc] initWithAnimationsDictionary:customTransition];
 	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:node.data[@"navigationOptions"]];
 	NSString* containerId = node.nodeId;
-	return [[RNNRootViewController alloc] initWithName:name withOptions:options withContainerId:containerId rootViewCreator:_creator eventEmitter:_eventEmitter animator:animator];
+	RNNRootViewController* container = [[RNNRootViewController alloc] initWithName:name withOptions:options withContainerId:containerId rootViewCreator:_creator eventEmitter:_eventEmitter animator:animator];
+	CGSize availableSize = UIApplication.sharedApplication.delegate.window.bounds.size;
+	[_bridge.uiManager setAvailableSize:availableSize forRootView:container.view];
+	
+	return container;
 }
 
 - (UIViewController<RNNRootViewProtocol> *)createContainerStack:(RNNLayoutNode*)node {
@@ -113,6 +125,22 @@
 	return vc;
 }
 
+- (UIViewController<RNNRootViewProtocol> *)createTopTabs:(RNNLayoutNode*)node {
+	RNNTopTabsViewController* vc = [[RNNTopTabsViewController alloc] init];
+	
+	NSMutableArray* controllers = [NSMutableArray new];
+	for (NSDictionary *child in node.children) {
+		RNNRootViewController* childVc = (RNNRootViewController*)[self fromTree:child];
+		childVc.topTabsViewController = vc;
+		[controllers addObject:childVc];
+		[_bridge.uiManager setAvailableSize:vc.contentView.bounds.size forRootView:childVc.view];
+	}
+	
+	[vc setViewControllers:controllers];
+	
+	return vc;
+}
+
 - (UIViewController<RNNRootViewProtocol> *)createSideMenu:(RNNLayoutNode*)node {
 	NSMutableArray* childrenVCs = [NSMutableArray new];
 	

lib/ios/RNNLayoutNode.h

@@ -14,6 +14,8 @@
 -(BOOL)isContainer;
 -(BOOL)isContainerStack;
 -(BOOL)isTabs;
+-(BOOL)isTopTabs;
+-(BOOL)isTopTab;
 -(BOOL)isSideMenuRoot;
 -(BOOL)isSideMenuLeft;
 -(BOOL)isSideMenuRight;

lib/ios/RNNLayoutNode.m

@@ -25,6 +25,14 @@
 {
 	return [self.type isEqualToString:@"BottomTabs"];
 }
+-(BOOL)isTopTabs
+{
+	return [self.type isEqualToString:@"TopTabs"];
+}
+-(BOOL)isTopTab
+{
+	return [self.type isEqualToString:@"TopTab"];
+}
 -(BOOL)isSideMenuRoot
 {
 	return [self.type isEqualToString:@"SideMenuRoot"];

lib/ios/RNNNavigationOptions.h

@@ -4,6 +4,7 @@
 #import "RNNTabBarOptions.h"
 #import "RNNSideMenuOptions.h"
 #import "RNNTabItemOptions.h"
+#import "RNNTopTabOptions.h"
 
 extern const NSInteger BLUR_STATUS_TAG;
 extern const NSInteger BLUR_TOPBAR_TAG;
@@ -23,6 +24,7 @@ extern const NSInteger TOP_BAR_TRANSPARENT_TAG;
 @property (nonatomic, strong) NSNumber* popGesture;
 @property (nonatomic, strong) RNNTopBarOptions* topBar;
 @property (nonatomic, strong) RNNTabBarOptions* bottomTabs;
+@property (nonatomic, strong) RNNTopTabOptions* topTab;
 @property (nonatomic, strong) RNNSideMenuOptions* sideMenu;
 @property (nonatomic, strong) UIImage* backgroundImage;
 @property (nonatomic, strong) UIImage* rootBackgroundImage;
@@ -39,5 +41,6 @@ extern const NSInteger TOP_BAR_TRANSPARENT_TAG;
 -(void)storeOriginalTopBarImages:(UIViewController*)viewController;
 
 - (void)applyTabBarItemOptions:(UIViewController*)viewController;
+- (void)applyTopTab:(UIViewController*)viewController;
 
 @end

lib/ios/RNNNavigationOptions.m

@@ -4,6 +4,7 @@
 #import "RNNTabBarController.h"
 #import "RNNTopBarOptions.h"
 #import "RNNSideMenuController.h"
+#import "RNNRootViewController.h"
 
 const NSInteger BLUR_STATUS_TAG = 78264801;
 const NSInteger BLUR_TOPBAR_TAG = 78264802;
@@ -26,6 +27,7 @@ const NSInteger TOP_BAR_TRANSPARENT_TAG = 78264803;
 	self.leftButtons = [navigationOptions objectForKey:@"leftButtons"];
 	self.rightButtons = [navigationOptions objectForKey:@"rightButtons"];
 	self.topBar = [[RNNTopBarOptions alloc] initWithDict:[navigationOptions objectForKey:@"topBar"]];
+	self.topTab = [[RNNTopTabOptions alloc] initWithDict:[navigationOptions objectForKey:@"topTab"]];
 	self.bottomTabs = [[RNNTabBarOptions alloc] initWithDict:[navigationOptions objectForKey:@"bottomTabs"]];
 	self.sideMenu = [[RNNSideMenuOptions alloc] initWithDict:[navigationOptions objectForKey:@"sideMenu"]];
 	self.backgroundImage = [RCTConvert UIImage:[navigationOptions objectForKey:@"backgroundImage"]];
@@ -41,6 +43,8 @@ const NSInteger TOP_BAR_TRANSPARENT_TAG = 78264803;
 			[self.topBar mergeWith:[otherOptions objectForKey:key]];
 		} else if ([key isEqualToString:@"bottomTabs"]) {
 			[self.bottomTabs mergeWith:[otherOptions objectForKey:key]];
+		} else if ([key isEqualToString:@"topTab"]) {
+			[self.topTab mergeWith:[otherOptions objectForKey:key]];
 		} else if ([key isEqualToString:@"sideMenu"]) {
 			[self.sideMenu mergeWith:[otherOptions objectForKey:@"sideMenu"]];
 		} else if ([key isEqualToString:@"bottomTab"]) {
@@ -291,6 +295,15 @@ const NSInteger TOP_BAR_TRANSPARENT_TAG = 78264803;
 	}
 	
 	[self applyTabBarItemOptions:viewController];
+	[self applyTopTab:viewController];
+}
+
+- (void)applyTopTab:(RNNRootViewController*)viewController {
+	if (self.topTab) {
+		if (self.topTab.title) {
+			[viewController.topTabsViewController viewController:viewController changedTitle:self.topTab.title];
+		}
+	}
 }
 
 - (void)applyTabBarItemOptions:(UIViewController*)viewController {

lib/ios/RNNRootViewController.h

@@ -6,6 +6,7 @@
 #import "RNNEventEmitter.h"
 #import "RNNNavigationOptions.h"
 #import "RNNAnimator.h"
+#import "RNNTopTabsViewController.h"
 #import "RNNRootViewProtocol.h"
 
 @interface RNNRootViewController : UIViewController	<RNNRootViewProtocol>
@@ -14,6 +15,7 @@
 @property (nonatomic, strong) RNNAnimator* animator;
 @property (nonatomic, strong) RNNEventEmitter *eventEmitter;
 @property (nonatomic, strong) NSString* containerId;
+@property (nonatomic, strong) RNNTopTabsViewController* topTabsViewController;
 
 -(instancetype)initWithName:(NSString*)name
 				withOptions:(RNNNavigationOptions*)options
@@ -25,5 +27,8 @@
 
 -(void)applyNavigationButtons;
 -(void)applyTabBarItem;
+-(void)applyTopTabsOptions;
+
+-(BOOL)isAnimated;
 
 @end

lib/ios/RNNRootViewController.m

@@ -106,8 +106,6 @@
 
 }
 
-
-
 -(void)applyNavigationButtons{
 	[self.navigationButtons applyLeftButtons:self.navigationOptions.leftButtons rightButtons:self.navigationOptions.rightButtons];
 }
@@ -116,6 +114,10 @@
 	[self.navigationOptions applyTabBarItemOptions:self];
 }
 
+-(void)applyTopTabsOptions {
+	[self.navigationOptions applyTopTab:self];
+}
+
 /**
  *	fix for #877, #878
  */

lib/ios/RNNSegmentedControl.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+#import "HMSegmentedControl.h"
+
+@interface RNNSegmentedControl : HMSegmentedControl
+
+- (void)setTitle:(NSString*)title atIndex:(NSUInteger)index;
+
+@end

lib/ios/RNNSegmentedControl.m

@@ -0,0 +1,11 @@
+#import "RNNSegmentedControl.h"
+
+@implementation RNNSegmentedControl
+
+- (void)setTitle:(NSString*)title atIndex:(NSUInteger)index {
+	NSMutableArray* mutableTitles = [[NSMutableArray alloc] initWithArray:self.sectionTitles];
+	[mutableTitles setObject:title atIndexedSubscript:index];
+	[self setSectionTitles:mutableTitles];
+}
+
+@end

lib/ios/RNNTopTabOptions.h

@@ -0,0 +1,14 @@
+#import <Foundation/Foundation.h>
+
+extern const NSInteger BLUR_TOPBAR_TAG;
+
+@interface RNNTopTabOptions : NSObject
+
+@property (nonatomic, strong) NSString* title;
+
+-(instancetype)init;
+-(instancetype)initWithDict:(NSDictionary *)topBarOptions;
+-(void)mergeWith:(NSDictionary*)otherOptions;
+
+@end
+

lib/ios/RNNTopTabOptions.m

@@ -0,0 +1,23 @@
+#import "RNNTopTabOptions.h"
+
+@implementation RNNTopTabOptions
+
+-(instancetype)init {
+	return [self initWithDict:@{}];
+}
+
+-(instancetype)initWithDict:(NSDictionary *)tabBarOptions {
+	self = [super init];
+	
+	self.title = [tabBarOptions valueForKey:@"title"];
+	
+	return self;
+}
+
+-(void)mergeWith:(NSDictionary *)otherOptions {
+	for (id key in otherOptions) {
+		[self setValue:[otherOptions objectForKey:key] forKey:key];
+	}
+}
+@end
+

lib/ios/RNNTopTabsViewController.h

@@ -0,0 +1,14 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <React/RCTUIManager.h>
+#import "RNNRootViewProtocol.h"
+
+@interface RNNTopTabsViewController : UIViewController <RNNRootViewProtocol>
+
+@property (nonatomic, retain) UIView* contentView;
+
+- (void)setViewControllers:(NSArray*)viewControllers;
+- (void)viewController:(UIViewController*)vc changedTitle:(NSString*)title;
+- (instancetype)init;
+
+@end

lib/ios/RNNTopTabsViewController.m

@@ -0,0 +1,79 @@
+#import "RNNTopTabsViewController.h"
+#import "RNNSegmentedControl.h"
+#import "RNNRootViewController.h"
+#import "ReactNativeNavigation.h"
+
+@interface RNNTopTabsViewController () {
+	NSArray* _viewControllers;
+	UIViewController* _currentViewController;
+	RNNSegmentedControl* _segmentedControl;
+}
+
+@end
+
+@implementation RNNTopTabsViewController
+
+- (instancetype)init {
+	self = [super init];
+		
+	[self.view setBackgroundColor:[UIColor whiteColor]];
+	self.edgesForExtendedLayout = UIRectEdgeNone;
+	
+	[self createTabBar];
+	[self createContentView];
+	
+	return self;
+}
+
+- (void)createTabBar {
+	_segmentedControl = [[RNNSegmentedControl alloc] initWithSectionTitles:@[@"", @"", @""]];
+	_segmentedControl.frame = CGRectMake(0, 0, self.view.bounds.size.width, 50);
+	_segmentedControl.selectionIndicatorLocation = HMSegmentedControlSelectionIndicatorLocationNone;
+	_segmentedControl.selectionStyle = HMSegmentedControlSelectionStyleBox;
+	_segmentedControl.selectedSegmentIndex = HMSegmentedControlNoSegment;
+	
+	[_segmentedControl addTarget:self action:@selector(segmentedControlChangedValue:) forControlEvents:UIControlEventValueChanged];
+	[self.view addSubview:_segmentedControl];
+}
+
+- (void)segmentedControlChangedValue:(HMSegmentedControl*)segmentedControl {
+	[self setSelectedViewControllerIndex:segmentedControl.selectedSegmentIndex];
+}
+
+- (void)createContentView {
+	_contentView = [[UIView alloc] initWithFrame:CGRectMake(0, 50, self.view.bounds.size.width, self.view.bounds.size.height - 50)];
+	_contentView.backgroundColor = [UIColor grayColor];
+	[self.view addSubview:_contentView];
+}
+
+- (void)setSelectedViewControllerIndex:(NSUInteger)index {
+	UIViewController *toVC = _viewControllers[index];
+	[_contentView addSubview:toVC.view];
+	[_currentViewController.view removeFromSuperview];
+	_currentViewController = toVC;
+}
+
+- (void)setViewControllers:(NSArray *)viewControllers {
+	_viewControllers = viewControllers;
+	for (RNNRootViewController* childVc in viewControllers) {
+		[childVc.view setFrame:_contentView.bounds];
+		[childVc applyTopTabsOptions];
+	}
+	
+	[self setSelectedViewControllerIndex:0];
+}
+
+- (void)viewController:(UIViewController*)vc changedTitle:(NSString*)title {
+	NSUInteger vcIndex = [_viewControllers indexOfObject:vc];
+	[_segmentedControl setTitle:title atIndex:vcIndex];
+}
+
+- (void)viewDidLoad {
+    [super viewDidLoad];
+}
+
+- (BOOL)isAnimated {
+	return NO;
+}
+
+@end

lib/ios/ReactNativeNavigation.m

@@ -69,8 +69,8 @@
 	RNNEventEmitter *eventEmitter = [[RNNEventEmitter alloc] init];
 	
 	id<RNNRootViewCreator> rootViewCreator = [[RNNReactRootViewCreator alloc] initWithBridge:bridge];
-	RNNControllerFactory *controllerFactory = [[RNNControllerFactory alloc] initWithRootViewCreator:rootViewCreator store:_store eventEmitter:eventEmitter];
-	_commandsHandler = [[RNNCommandsHandler alloc] initWithStore:_store controllerFactory:controllerFactory andBridge:bridge];
+	RNNControllerFactory *controllerFactory = [[RNNControllerFactory alloc] initWithRootViewCreator:rootViewCreator store:_store eventEmitter:eventEmitter andBridge:bridge];
+	_commandsHandler = [[RNNCommandsHandler alloc] initWithStore:_store controllerFactory:controllerFactory];
 	RNNBridgeModule *bridgeModule = [[RNNBridgeModule alloc] initWithCommandsHandler:_commandsHandler];
 	
 	return @[bridgeModule,eventEmitter];

lib/ios/ReactNativeNavigation.xcodeproj/project.pbxproj

@@ -57,6 +57,14 @@
 		268692831E5054F800E2C612 /* RNNStore.m in Sources */ = {isa = PBXBuildFile; fileRef = 268692811E5054F800E2C612 /* RNNStore.m */; };
 		26916C981E4B9E7700D13680 /* RNNReactRootViewCreator.h in Headers */ = {isa = PBXBuildFile; fileRef = 26916C961E4B9E7700D13680 /* RNNReactRootViewCreator.h */; };
 		26916C991E4B9E7700D13680 /* RNNReactRootViewCreator.m in Sources */ = {isa = PBXBuildFile; fileRef = 26916C971E4B9E7700D13680 /* RNNReactRootViewCreator.m */; };
+		507F43C51FF4F17C00D9425B /* RNNTopTabsViewController.h in Headers */ = {isa = PBXBuildFile; fileRef = 507F43C31FF4F17C00D9425B /* RNNTopTabsViewController.h */; };
+		507F43C61FF4F17C00D9425B /* RNNTopTabsViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = 507F43C41FF4F17C00D9425B /* RNNTopTabsViewController.m */; };
+		507F43C91FF4F9CC00D9425B /* RNNTopTabOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 507F43C71FF4F9CC00D9425B /* RNNTopTabOptions.h */; };
+		507F43CA1FF4F9CC00D9425B /* RNNTopTabOptions.m in Sources */ = {isa = PBXBuildFile; fileRef = 507F43C81FF4F9CC00D9425B /* RNNTopTabOptions.m */; };
+		507F43F41FF4FCFE00D9425B /* HMSegmentedControl.h in Headers */ = {isa = PBXBuildFile; fileRef = 507F43F21FF4FCFE00D9425B /* HMSegmentedControl.h */; };
+		507F43F51FF4FCFE00D9425B /* HMSegmentedControl.m in Sources */ = {isa = PBXBuildFile; fileRef = 507F43F31FF4FCFE00D9425B /* HMSegmentedControl.m */; };
+		507F43F81FF525B500D9425B /* RNNSegmentedControl.h in Headers */ = {isa = PBXBuildFile; fileRef = 507F43F61FF525B500D9425B /* RNNSegmentedControl.h */; };
+		507F43F91FF525B500D9425B /* RNNSegmentedControl.m in Sources */ = {isa = PBXBuildFile; fileRef = 507F43F71FF525B500D9425B /* RNNSegmentedControl.m */; };
 		507F44201FFA8A8800D9425B /* RNNRootViewProtocol.h in Headers */ = {isa = PBXBuildFile; fileRef = 507F441F1FFA8A8800D9425B /* RNNRootViewProtocol.h */; };
 		50CB3B691FDE911400AA153B /* RNNSideMenuOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 50CB3B671FDE911400AA153B /* RNNSideMenuOptions.h */; };
 		50CB3B6A1FDE911400AA153B /* RNNSideMenuOptions.m in Sources */ = {isa = PBXBuildFile; fileRef = 50CB3B681FDE911400AA153B /* RNNSideMenuOptions.m */; };
@@ -208,6 +216,14 @@
 		26916C941E4B9CCC00D13680 /* RNNRootViewCreator.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNRootViewCreator.h; sourceTree = "<group>"; };
 		26916C961E4B9E7700D13680 /* RNNReactRootViewCreator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RNNReactRootViewCreator.h; sourceTree = "<group>"; };
 		26916C971E4B9E7700D13680 /* RNNReactRootViewCreator.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RNNReactRootViewCreator.m; sourceTree = "<group>"; };
+		507F43C31FF4F17C00D9425B /* RNNTopTabsViewController.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNTopTabsViewController.h; sourceTree = "<group>"; };
+		507F43C41FF4F17C00D9425B /* RNNTopTabsViewController.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNTopTabsViewController.m; sourceTree = "<group>"; };
+		507F43C71FF4F9CC00D9425B /* RNNTopTabOptions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNTopTabOptions.h; sourceTree = "<group>"; };
+		507F43C81FF4F9CC00D9425B /* RNNTopTabOptions.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNTopTabOptions.m; sourceTree = "<group>"; };
+		507F43F21FF4FCFE00D9425B /* HMSegmentedControl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = HMSegmentedControl.h; sourceTree = "<group>"; };
+		507F43F31FF4FCFE00D9425B /* HMSegmentedControl.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = HMSegmentedControl.m; sourceTree = "<group>"; };
+		507F43F61FF525B500D9425B /* RNNSegmentedControl.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNSegmentedControl.h; sourceTree = "<group>"; };
+		507F43F71FF525B500D9425B /* RNNSegmentedControl.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNSegmentedControl.m; sourceTree = "<group>"; };
 		507F441F1FFA8A8800D9425B /* RNNRootViewProtocol.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RNNRootViewProtocol.h; sourceTree = "<group>"; };
 		50CB3B671FDE911400AA153B /* RNNSideMenuOptions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNSideMenuOptions.h; sourceTree = "<group>"; };
 		50CB3B681FDE911400AA153B /* RNNSideMenuOptions.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNSideMenuOptions.m; sourceTree = "<group>"; };
@@ -398,6 +414,15 @@
 			path = Animations;
 			sourceTree = "<group>";
 		};
+		507F43F11FF4FCD800D9425B /* HMSegmentControl */ = {
+			isa = PBXGroup;
+			children = (
+				507F43F21FF4FCFE00D9425B /* HMSegmentedControl.h */,
+				507F43F31FF4FCFE00D9425B /* HMSegmentedControl.m */,
+			);
+			name = HMSegmentControl;
+			sourceTree = "<group>";
+		};
 		7B1E4C4B1E2D173700C3A525 /* Controllers */ = {
 			isa = PBXGroup;
 			children = (
@@ -438,8 +463,14 @@
 				A7626BFC1FC2FB2C00492FB8 /* RNNTopBarOptions.m */,
 				A7626BFF1FC578AB00492FB8 /* RNNTabBarOptions.h */,
 				A7626C001FC5796200492FB8 /* RNNTabBarOptions.m */,
+				507F43C71FF4F9CC00D9425B /* RNNTopTabOptions.h */,
+				507F43C81FF4F9CC00D9425B /* RNNTopTabOptions.m */,
 				50CB3B671FDE911400AA153B /* RNNSideMenuOptions.h */,
 				50CB3B681FDE911400AA153B /* RNNSideMenuOptions.m */,
+				507F43C31FF4F17C00D9425B /* RNNTopTabsViewController.h */,
+				507F43C41FF4F17C00D9425B /* RNNTopTabsViewController.m */,
+				507F43F61FF525B500D9425B /* RNNSegmentedControl.h */,
+				507F43F71FF525B500D9425B /* RNNSegmentedControl.m */,
 				507F441F1FFA8A8800D9425B /* RNNRootViewProtocol.h */,
 			);
 			name = Controllers;
@@ -508,6 +539,7 @@
 				7BD721F31E2D3AA100724059 /* Bridge */,
 				7B1E4C4B1E2D173700C3A525 /* Controllers */,
 				263905881E4C6F440023D7D3 /* RNNSideMenu */,
+				507F43F11FF4FCD800D9425B /* HMSegmentControl */,
 				7B49FEBC1E95090800DEB3EA /* ReactNativeNavigationTests */,
 				D8AFADBE1BEE6F3F00A4592D /* Products */,
 				7B49FED01E950A7A00DEB3EA /* Frameworks */,
@@ -582,6 +614,7 @@
 				263905B71E4C6F440023D7D3 /* UIViewController+MMDrawerController.h in Headers */,
 				263905BB1E4C6F440023D7D3 /* RCCDrawerHelper.h in Headers */,
 				263905CC1E4C6F440023D7D3 /* SidebarWunderlistAnimation.h in Headers */,
+				507F43F41FF4FCFE00D9425B /* HMSegmentedControl.h in Headers */,
 				7B4928081E70415400555040 /* RNNCommandsHandler.h in Headers */,
 				263905AE1E4C6F440023D7D3 /* MMDrawerBarButtonItem.h in Headers */,
 				50F5DFC11F407A8C001A00BC /* RNNTabBarController.h in Headers */,
@@ -590,6 +623,7 @@
 				263905C21E4C6F440023D7D3 /* SidebarAnimation.h in Headers */,
 				E8E518361F83B94A000467AC /* RNNViewLocation.h in Headers */,
 				263905B51E4C6F440023D7D3 /* MMExampleDrawerVisualStateManager.h in Headers */,
+				507F43C51FF4F17C00D9425B /* RNNTopTabsViewController.h in Headers */,
 				263905C61E4C6F440023D7D3 /* SidebarFeedlyAnimation.h in Headers */,
 				7B1126A31E2D2B6C00F9B03B /* RNNSplashScreen.h in Headers */,
 				261F0E641E6EC94900989DE2 /* RNNModalManager.h in Headers */,
@@ -622,7 +656,9 @@
 				263905D61E4C94970023D7D3 /* RNNSideMenuController.h in Headers */,
 				263905C81E4C6F440023D7D3 /* SidebarFlipboardAnimation.h in Headers */,
 				7BEF0D1C1E43771B003E96B0 /* RNNLayoutNode.h in Headers */,
+				507F43C91FF4F9CC00D9425B /* RNNTopTabOptions.h in Headers */,
 				E8A5CD521F464F0400E89D0D /* RNNAnimator.h in Headers */,
+				507F43F81FF525B500D9425B /* RNNSegmentedControl.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -762,12 +798,15 @@
 				2145452A1F4DC85F006E8DA1 /* RCTHelpers.m in Sources */,
 				263905C11E4C6F440023D7D3 /* SidebarAirbnbAnimation.m in Sources */,
 				263905D71E4C94970023D7D3 /* RNNSideMenuController.m in Sources */,
+				507F43CA1FF4F9CC00D9425B /* RNNTopTabOptions.m in Sources */,
 				26916C991E4B9E7700D13680 /* RNNReactRootViewCreator.m in Sources */,
 				214545251F4DC125006E8DA1 /* RNNUIBarButtonItem.m in Sources */,
 				263905B81E4C6F440023D7D3 /* UIViewController+MMDrawerController.m in Sources */,
 				263905CD1E4C6F440023D7D3 /* SidebarWunderlistAnimation.m in Sources */,
 				263905CF1E4C6F440023D7D3 /* TheSidebarController.m in Sources */,
 				E8A430121F9CB87B00B61A20 /* RNNAnimatedView.m in Sources */,
+				507F43F51FF4FCFE00D9425B /* HMSegmentedControl.m in Sources */,
+				507F43C61FF4F17C00D9425B /* RNNTopTabsViewController.m in Sources */,
 				50EB93421FE14A3E00BD8EEE /* RNNTabItemOptions.m in Sources */,
 				E8367B811F7A8A4700675C05 /* VICMAImageView.m in Sources */,
 				A7626C011FC5796200492FB8 /* RNNTabBarOptions.m in Sources */,
@@ -776,6 +815,7 @@
 				7B4928091E70415400555040 /* RNNCommandsHandler.m in Sources */,
 				268692831E5054F800E2C612 /* RNNStore.m in Sources */,
 				7BC9346E1E26886E00EFA125 /* RNNControllerFactory.m in Sources */,
+				507F43F91FF525B500D9425B /* RNNSegmentedControl.m in Sources */,
 				E8E5182F1F83A48B000467AC /* RNNTransitionStateHolder.m in Sources */,
 				263905B61E4C6F440023D7D3 /* MMExampleDrawerVisualStateManager.m in Sources */,
 				E8E518331F83B3E0000467AC /* RNNUtils.m in Sources */,

lib/ios/ReactNativeNavigationTests/RNNCommandsHandlerTest.m

@@ -10,7 +10,6 @@
 
 @property (nonatomic, strong) RNNStore* store;
 @property (nonatomic, strong) RNNCommandsHandler* uut;
-@property (nonatomic, strong) RCTBridge* bridge;
 
 @end
 
@@ -20,8 +19,7 @@
 	[super setUp];
 //	[self.store setReadyToReceiveCommands:true];
 	self.store = [[RNNStore alloc] init];
-	self.bridge = nil;
-	self.uut = [[RNNCommandsHandler alloc] initWithStore:self.store controllerFactory:nil andBridge:self.bridge];
+	self.uut = [[RNNCommandsHandler alloc] initWithStore:self.store controllerFactory:nil];
 }
 
 
@@ -40,7 +38,7 @@
 -(NSArray*) getPublicMethodNamesForObject:(NSObject*)obj{
 	NSMutableArray* skipMethods = [NSMutableArray new];
 
-	[skipMethods addObject:@"initWithStore:controllerFactory:andBridge:"];
+	[skipMethods addObject:@"initWithStore:controllerFactory:"];
 	[skipMethods addObject:@"assertReady"];
 	[skipMethods addObject:@".cxx_destruct"];
 

lib/ios/ReactNativeNavigationTests/RNNControllerFactoryTest.m

@@ -21,7 +21,7 @@
 	[super setUp];
 	self.creator = nil;
 	self.store = [RNNStore new];
-	self.factory = [[RNNControllerFactory alloc] initWithRootViewCreator:self.creator store:self.store eventEmitter:nil];
+	self.factory = [[RNNControllerFactory alloc] initWithRootViewCreator:self.creator store:self.store eventEmitter:nil andBridge:nil];
 }
 
 - (void)tearDown {