Merge branch 'v2' into newAPI

README.md

 ## Why Rebuild react-native-navigation?
 
 ### A New & Improved Core Architecture
-react-native-navigation has a few issues which are unsolvable in its current architecture. These issues stem from the same problem: you cannot specify on which screen you wish to make an action. Whenever you want to push a screen, show a modal or any other action, the action defaults to originate from your current screen. In most cases this is fine, but becoms problematic in specific edge cases. For example: <br>
+react-native-navigation has a few issues which are unsolvable in its current architecture. These issues stem from the same problem: you cannot specify on which screen you wish to make an action. Whenever you want to push a screen, show a modal or any other action, the action defaults to originate from your current screen. In most cases this is fine, but becomes problematic in specific edge cases. For example: <br>
 * What if you want to update your navbar icons and the user pops the screen? Your icons might update on the wrong screen.
 * What if you want to push a screen as a result of a redux action?
 

lib/android/app/src/main/java/com/reactnativenavigation/parse/NavigationOptions.java

 		result.topTabsOptions = TopTabsOptions.parse(json.optJSONObject("topTabs"));
         result.topTabOptions = TopTabOptions.parse(typefaceManager, json.optJSONObject("topTab"));
 		result.bottomTabsOptions = BottomTabsOptions.parse(json.optJSONObject("bottomTabs"));
-		result.rightButtons = Button.parseJsonArray(json.optJSONArray("rightButtons"));
-        result.leftButtons = Button.parseJsonArray(json.optJSONArray("leftButtons"));
 
 		return result.withDefaultOptions(defaultOptions);
 	}
     @NonNull public TopTabsOptions topTabsOptions = new TopTabsOptions();
     @NonNull public TopTabOptions topTabOptions = new TopTabOptions();
     @NonNull public BottomTabsOptions bottomTabsOptions = new BottomTabsOptions();
-    public ArrayList<Button> leftButtons;
-    public ArrayList<Button> rightButtons;
 
 	public void mergeWith(final NavigationOptions other) {
         topBarOptions.mergeWith(other.topBarOptions);
         topTabsOptions.mergeWith(other.topTabsOptions);
         bottomTabsOptions.mergeWith(other.bottomTabsOptions);
-
-        if(other.leftButtons != null) {
-            leftButtons = other.leftButtons;
-        }
-
-        if(other.rightButtons != null) {
-            rightButtons = other.rightButtons;
-        }
     }
 
     NavigationOptions withDefaultOptions(final NavigationOptions other) {

lib/android/app/src/main/java/com/reactnativenavigation/parse/TopBarOptions.java

 
 import org.json.JSONObject;
 
+import java.util.ArrayList;
+
 public class TopBarOptions implements DEFAULT_VALUES {
 
 	public static TopBarOptions parse(TypefaceLoader typefaceManager, JSONObject json) {
 		options.textFontFamily = typefaceManager.getTypeFace(json.optString("textFontFamily", NO_VALUE));
 		options.hidden = NavigationOptions.BooleanOptions.parse(json.optString("hidden"));
 		options.animateHide = NavigationOptions.BooleanOptions.parse(json.optString("animateHide"));
+		options.rightButtons = Button.parseJsonArray(json.optJSONArray("rightButtons"));
+		options.leftButtons = Button.parseJsonArray(json.optJSONArray("leftButtons"));
 
 		return options;
 	}
 	@Nullable public Typeface textFontFamily;
 	public NavigationOptions.BooleanOptions hidden = NavigationOptions.BooleanOptions.False;
 	public NavigationOptions.BooleanOptions animateHide = NavigationOptions.BooleanOptions.False;
+	public ArrayList<Button> leftButtons;
+	public ArrayList<Button> rightButtons;
 
 	void mergeWith(final TopBarOptions other) {
 		if (!NO_VALUE.equals(other.title)) title = other.title;
 			hidden = other.hidden;
 		if (other.animateHide != NavigationOptions.BooleanOptions.NoValue)
 			animateHide = other.animateHide;
+		if(other.leftButtons != null)
+			leftButtons = other.leftButtons;
+		if(other.rightButtons != null)
+			rightButtons = other.rightButtons;
 	}
 
     void mergeWithDefault(TopBarOptions defaultOptions) {
             hidden = defaultOptions.hidden;
         if (animateHide == NavigationOptions.BooleanOptions.NoValue)
             animateHide = defaultOptions.animateHide;
+		if(leftButtons == null)
+			leftButtons = defaultOptions.leftButtons;
+		if(rightButtons == null)
+			rightButtons = defaultOptions.rightButtons;
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/presentation/OptionsPresenter.java

 
     public void applyOptions(NavigationOptions options) {
         applyTopBarOptions(options.topBarOptions);
-        applyButtons(options.leftButtons, options.rightButtons);
+        applyButtons(options.topBarOptions.leftButtons, options.topBarOptions.rightButtons);
         applyTopTabsOptions(options.topTabsOptions);
         applyTopTabOptions(options.topTabOptions);
     }

lib/ios/HMSegmentedControl.h

+//
+//  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

+//
+//  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/RNNTabItemOptions.h → lib/ios/RNNBottomTabOptions.h

-#import <Foundation/Foundation.h>
+#import "RNNOptions.h"
 
-@interface RNNTabItemOptions : NSObject
+@interface RNNBottomTabOptions : RNNOptions
 
 @property (nonatomic) NSUInteger tag;
 @property (nonatomic, strong) NSString* title;
 @property (nonatomic, strong) NSNumber* visible;
 @property (nonatomic, strong) NSDictionary* icon;
 
--(instancetype)initWithDict:(NSDictionary*)tabItemDict;
-
--(void)mergeWith:(NSDictionary *)otherOptions;
-
--(void)resetOptions;
-
 @end

lib/ios/RNNBottomTabOptions.m

+#import "RNNBottomTabOptions.h"
+
+@implementation RNNBottomTabOptions
+
+-(instancetype)initWithDict:(NSDictionary *)tabItemDict {
+	self = [super init];
+	
+	[self mergeWith:tabItemDict];
+	self.tag = [tabItemDict[@"tag"] integerValue];
+	
+	return self;
+}
+
+- (void)applyOn:(UIViewController *)viewController {
+	if (self.title || self.icon) {
+		UITabBarItem* tabItem = [[UITabBarItem alloc] initWithTitle:self.title image:[RCTConvert UIImage:self.icon] tag:self.tag];
+		tabItem.accessibilityIdentifier = self.testID;
+		[viewController.navigationController setTabBarItem:tabItem];
+	}
+	
+	if (self.badge) {
+		NSString *badge = [RCTConvert NSString:self.badge];
+		if (viewController.navigationController) {
+			viewController.navigationController.tabBarItem.badgeValue = badge;
+		} else {
+			viewController.tabBarItem.badgeValue = badge;
+		}
+	}
+	
+	if (self.visible) {
+		[viewController.tabBarController setSelectedIndex:[viewController.tabBarController.viewControllers indexOfObject:viewController]];
+	}
+	
+	[self resetOptions];
+}
+
+-(void)mergeWith:(NSDictionary *)otherOptions {
+	for (id key in otherOptions) {
+		[self setValue:[otherOptions objectForKey:key] forKey:key];
+	}
+}
+
+-(void)resetOptions {
+	self.title = nil;
+	self.badge = nil;
+	self.visible = nil;
+	self.icon = nil;
+	self.testID = nil;
+}
+
+@end

lib/ios/RNNTabBarOptions.h → lib/ios/RNNBottomTabsOptions.h

-#import <Foundation/Foundation.h>
+#import "RNNOptions.h"
 
-extern const NSInteger BLUR_TOPBAR_TAG;
-
-@interface RNNTabBarOptions : NSObject
+@interface RNNBottomTabsOptions : RNNOptions
 
 @property (nonatomic, strong) NSNumber* hidden;
 @property (nonatomic, strong) NSNumber* animateHide;
 @property (nonatomic, strong) NSNumber* drawUnder;
 @property (nonatomic, strong) NSString* currentTabId;
 
--(instancetype)init;
--(instancetype)initWithDict:(NSDictionary *)topBarOptions;
--(void)mergeWith:(NSDictionary*)otherOptions;
-- (void)resetOptions;
-
 @end

lib/ios/RNNBottomTabsOptions.m

+#import "RNNBottomTabsOptions.h"
+#import "RNNTabBarController.h"
+extern const NSInteger BLUR_TOPBAR_TAG;
+
+@implementation RNNBottomTabsOptions
+
+- (void)applyOn:(UIViewController *)viewController {
+	if (self.currentTabIndex) {
+		[viewController.tabBarController setSelectedIndex:[self.currentTabIndex unsignedIntegerValue]];
+	}
+	
+	if (self.currentTabId) {
+		[(RNNTabBarController*)viewController.tabBarController setSelectedIndexByContainerID:self.currentTabId];
+	}
+	
+	if (self.hidden) {
+		[((RNNTabBarController *)viewController.tabBarController) setTabBarHidden:[self.hidden boolValue] animated:[self.animateHide boolValue]];
+	}
+	
+	if (self.testID) {
+		viewController.tabBarController.tabBar.accessibilityIdentifier = self.testID;
+	}
+	
+	if (self.drawUnder) {
+		if ([self.drawUnder boolValue]) {
+			viewController.edgesForExtendedLayout |= UIRectEdgeBottom;
+		} else {
+			viewController.edgesForExtendedLayout &= ~UIRectEdgeBottom;
+		}
+	}
+	
+	[self resetOptions];
+}
+
+- (void)resetOptions {
+	self.currentTabId = nil;
+	self.currentTabIndex = nil;
+}
+
+-(void)mergeWith:(NSDictionary *)otherOptions {
+	for (id key in otherOptions) {
+		[self setValue:[otherOptions objectForKey:key] forKey:key];
+	}
+}
+@end

lib/ios/RNNBridgeManager.h

+#import <Foundation/Foundation.h>
+#import <React/RCTBridge.h>
+
+@interface RNNBridgeManager : NSObject <RCTBridgeDelegate>
+
+- (instancetype)initWithJsCodeLocation:(NSURL *)jsCodeLocation launchOptions:(NSDictionary *)launchOptions;
+
+@property (readonly, nonatomic, strong) RCTBridge *bridge;
+
+@end

lib/ios/RNNBridgeManager.m

+#import "RNNBridgeManager.h"
+
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+
+#import "RNNEventEmitter.h"
+#import "RNNSplashScreen.h"
+#import "RNNBridgeModule.h"
+#import "RNNRootViewCreator.h"
+#import "RNNReactRootViewCreator.h"
+
+@interface RNNBridgeManager() <RCTBridgeDelegate>
+
+@property (nonatomic, strong, readwrite) RCTBridge *bridge;
+
+@end
+
+@implementation RNNBridgeManager {
+	NSURL* _jsCodeLocation;
+	NSDictionary* _launchOptions;
+	RCTBridge* _bridge;
+
+	RNNStore* _store;
+
+	RNNCommandsHandler* _commandsHandler;
+}
+
+- (instancetype)initWithJsCodeLocation:(NSURL *)jsCodeLocation launchOptions:(NSDictionary *)launchOptions {
+	if (self = [super init]) {
+		_jsCodeLocation = jsCodeLocation;
+		_launchOptions = launchOptions;
+		
+		_store = [RNNStore new];
+		_bridge = [[RCTBridge alloc] initWithDelegate:self launchOptions:_launchOptions];
+
+		[[NSNotificationCenter defaultCenter] addObserver:self
+												 selector:@selector(onJavaScriptLoaded)
+													 name:RCTJavaScriptDidLoadNotification
+												   object:nil];
+		[[NSNotificationCenter defaultCenter] addObserver:self
+												 selector:@selector(onJavaScriptWillLoad)
+													 name:RCTJavaScriptWillStartLoadingNotification
+												   object:nil];
+		[[NSNotificationCenter defaultCenter] addObserver:self
+												 selector:@selector(onBridgeWillReload)
+													 name:RCTBridgeWillReloadNotification
+												   object:nil];
+	}
+	return self;
+}
+
+# pragma mark - RCTBridgeDelegate
+
+- (NSURL *)sourceURLForBridge:(RCTBridge *)bridge {
+	return _jsCodeLocation;
+}
+
+- (NSArray<id<RCTBridgeModule>> *)extraModulesForBridge:(RCTBridge *)bridge {
+	RNNEventEmitter *eventEmitter = [[RNNEventEmitter alloc] init];
+
+	id<RNNRootViewCreator> rootViewCreator = [[RNNReactRootViewCreator alloc] initWithBridge: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];
+}
+
+# pragma mark - JavaScript & Bridge Notifications
+
+- (void)onJavaScriptWillLoad {
+	[_store clean];
+}
+
+- (void)onJavaScriptLoaded {
+	[_store setReadyToReceiveCommands:true];
+	[[_bridge moduleForClass:[RNNEventEmitter class]] sendOnAppLaunched];
+}
+
+- (void)onBridgeWillReload {
+	UIApplication.sharedApplication.delegate.window.rootViewController =  nil;
+}
+
+@end
+

lib/ios/RNNCommandsHandler.h

 
 @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

 @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];
 		[CATransaction setCompletionBlock:completion];
 		
 		[rootVc.navigationOptions applyOn:vc];
-		[rootVc applyNavigationButtons];
 		
 		[CATransaction commit];
 	}
 
 -(void) push:(NSString*)containerId layout:(NSDictionary*)layout completion:(RNNTransitionCompletionBlock)completion {
 	[self assertReady];
-	UIViewController *newVc = [_controllerFactory createLayoutAndSaveToStore:layout];
-	UIViewController *fromVc = [_store findContainerForId:containerId];
-	[_bridge.uiManager setAvailableSize:fromVc.view.bounds.size forRootView:newVc.view];
+	
+	UIViewController<RNNRootViewProtocol> *newVc = [_controllerFactory createLayoutAndSaveToStore:layout];
 	[_navigationStackManager push:newVc onTop:containerId completion:completion];
 }
 

lib/ios/RNNControllerFactory.h

 #import "RNNRootViewCreator.h"
 #import "RNNStore.h"
 #import "RNNEventEmitter.h"
+#import "RNNRootViewProtocol.h"
 
 @interface RNNControllerFactory : NSObject
 
 -(instancetype)initWithRootViewCreator:(id <RNNRootViewCreator>)creator
 								 store:(RNNStore*)store
-						  eventEmitter:(RNNEventEmitter*)eventEmitter;
+						  eventEmitter:(RNNEventEmitter*)eventEmitter
+							 andBridge:(RCTBridge*)bridge;
 
--(UIViewController*)createLayoutAndSaveToStore:(NSDictionary*)layout;
+-(UIViewController<RNNRootViewProtocol> *)createLayoutAndSaveToStore:(NSDictionary*)layout;
 
 @end

lib/ios/RNNControllerFactory.m

 #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
 
 - (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;
 }
 
-- (UIViewController*)createLayoutAndSaveToStore:(NSDictionary*)layout {
+- (UIViewController<RNNRootViewProtocol> *)createLayoutAndSaveToStore:(NSDictionary*)layout {
 	return [self fromTree:layout];
 }
 
 # pragma mark private
 
-- (UIViewController*)fromTree:(NSDictionary*)json {
+- (UIViewController<RNNRootViewProtocol> *)fromTree:(NSDictionary*)json {
 	RNNLayoutNode* node = [RNNLayoutNode create:json];
 	
-	UIViewController* result;
+	UIViewController<RNNRootViewProtocol> *result;
 	
-	if ( node.isContainer) {
+	if ( node.isContainer || node.isTopTab) {
 		result = [self createContainer:node];
 	}
 	
 		result = [self createTabs:node];
 	}
 	
+	else if (node.isTopTabs) {
+		result = [self createTopTabs:node];
+	}
+	
 	else if (node.isSideMenuRoot) {
 		result = [self createSideMenu:node];
 	}
 	return result;
 }
 
-- (RNNRootViewController*)createContainer:(RNNLayoutNode*)node {
+- (UIViewController<RNNRootViewProtocol> *)createContainer:(RNNLayoutNode*)node {
 	NSString* name = node.data[@"name"];
 	NSDictionary* customTransition = node.data[@"customTransition"];
 	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;
 }
 
-- (RNNNavigationController*)createContainerStack:(RNNLayoutNode*)node {
+- (UIViewController<RNNRootViewProtocol> *)createContainerStack:(RNNLayoutNode*)node {
 	RNNNavigationController* vc = [[RNNNavigationController alloc] init];
 	
 	NSMutableArray* controllers = [NSMutableArray new];
 	return vc;
 }
 
--(RNNTabBarController*)createTabs:(RNNLayoutNode*)node {
+-(UIViewController<RNNRootViewProtocol> *)createTabs:(RNNLayoutNode*)node {
 	RNNTabBarController* vc = [[RNNTabBarController alloc] init];
 	
 	NSMutableArray* controllers = [NSMutableArray new];
 	for (NSDictionary *child in node.children) {
-		UIViewController* childVc = [self fromTree:child];
+		UIViewController* childVc = (UIViewController*)[self fromTree:child];
 		RNNRootViewController* rootView = (RNNRootViewController *)childVc.childViewControllers.firstObject;
 		[rootView applyTabBarItem];
 		
 	return vc;
 }
 
-- (UIViewController*)createSideMenu:(RNNLayoutNode*)node {
+- (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];
 	
 	
 }
 
 
-- (UIViewController*)createSideMenuChild:(RNNLayoutNode*)node type:(RNNSideMenuChildType)type {
-	UIViewController* child = [self fromTree:node.children[0]];
+- (UIViewController<RNNRootViewProtocol> *)createSideMenuChild:(RNNLayoutNode*)node type:(RNNSideMenuChildType)type {
+	UIViewController* child = (UIViewController*)[self fromTree:node.children[0]];
 	RNNSideMenuChildVC *sideMenuChild = [[RNNSideMenuChildVC alloc] initWithChild: child type:type];
 	
 	return sideMenuChild;

lib/ios/RNNLayoutNode.h

 -(BOOL)isContainer;
 -(BOOL)isContainerStack;
 -(BOOL)isTabs;
+-(BOOL)isTopTabs;
+-(BOOL)isTopTab;
 -(BOOL)isSideMenuRoot;
 -(BOOL)isSideMenuLeft;
 -(BOOL)isSideMenuRight;

lib/ios/RNNLayoutNode.m

 {
 	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/RNNNavigationButtons.h

 
 @interface RNNNavigationButtons : NSObject
 
--(instancetype)init;
 -(instancetype)initWithViewController:(RNNRootViewController*)viewController;
 
 -(void)applyLeftButtons:(NSArray*)leftButtons rightButtons:(NSArray*)rightButtons;

lib/ios/RNNNavigationButtons.m

 #import "RCTHelpers.h"
 
 @interface RNNNavigationButtons()
+
 @property (weak, nonatomic) RNNRootViewController* viewController;
+@property (strong, nonatomic) NSArray* rightButtons;
+@property (strong, nonatomic) NSArray* leftButtons;
 
 @end
 
 @implementation RNNNavigationButtons
 
--(instancetype)init {
-	return [super init];
-}
-
 -(instancetype)initWithViewController:(RNNRootViewController*)viewController {
 	self = [super init];
 	
 }
 
 -(void)applyLeftButtons:(NSArray*)leftButtons rightButtons:(NSArray*)rightButtons {
-	if(leftButtons) {
+	if (leftButtons) {
 		[self setButtons:leftButtons side:@"left" animated:NO];
 	}
 	
-	if(rightButtons) {
+	if (rightButtons) {
 		[self setButtons:rightButtons side:@"right" animated:NO];
 	}
 }
 		}
 	}
 	
-	if ([side isEqualToString:@"left"])
-	{
-		[self.viewController.navigationItem setLeftBarButtonItems:barButtonItems animated:animated];
+	if ([side isEqualToString:@"left"]) {
+		self.leftButtons = barButtonItems;
+		[self.viewController.navigationItem setLeftBarButtonItems:self.leftButtons animated:animated];
 	}
 	
-	if ([side isEqualToString:@"right"])
-	{
-		[self.viewController.navigationItem setRightBarButtonItems:barButtonItems animated:animated];
+	if ([side isEqualToString:@"right"]) {
+		self.rightButtons = barButtonItems;
+		[self.viewController.navigationItem setRightBarButtonItems:self.rightButtons animated:animated];
 	}
 }
 
 	NSString* buttonId = dictionary[@"id"];
 	NSString* title = dictionary[@"title"];
 	
-	if(!buttonId){
+	if (!buttonId) {
 		@throw [NSException exceptionWithName:@"NSInvalidArgumentException" reason:[@"button id is not specified " stringByAppendingString:title] userInfo:nil];
 	}
 	
 	return barButtonItem;
 }
 
--(void)onButtonPress:(RNNUIBarButtonItem*)barButtonItem
-{
+-(void)onButtonPress:(RNNUIBarButtonItem*)barButtonItem {
 	[self.viewController.eventEmitter sendOnNavigationButtonPressed:self.viewController.containerId buttonId:barButtonItem.buttonId];
 }
+
 @end

lib/ios/RNNNavigationController.h

 #import <UIKit/UIKit.h>
+#import "RNNRootViewProtocol.h"
 
-@interface RNNNavigationController : UINavigationController
+@interface RNNNavigationController : UINavigationController <RNNRootViewProtocol>
 
 @end

lib/ios/RNNNavigationController.m

 	return self.viewControllers.lastObject.supportedInterfaceOrientations;
 }
 
+- (BOOL)isCustomTransitioned {
+	return NO;
+}
+
 @end

lib/ios/RNNNavigationOptions.h

 #import <Foundation/Foundation.h>
-#import <UIKit/UIKit.h>
 #import "RNNTopBarOptions.h"
-#import "RNNTabBarOptions.h"
+#import "RNNBottomTabsOptions.h"
+#import "RNNBottomTabOptions.h"
 #import "RNNSideMenuOptions.h"
-#import "RNNTabItemOptions.h"
+#import "RNNTopTabOptions.h"
+#import "RNNTopTabsOptions.h"
 
 extern const NSInteger BLUR_STATUS_TAG;
 extern const NSInteger BLUR_TOPBAR_TAG;
 extern const NSInteger TOP_BAR_TRANSPARENT_TAG;
 
-@interface RNNNavigationOptions : NSObject
+@interface RNNNavigationOptions : RNNOptions
+
+@property (nonatomic, strong) RNNTopBarOptions* topBar;
+@property (nonatomic, strong) RNNBottomTabsOptions* bottomTabs;
+@property (nonatomic, strong) RNNBottomTabOptions* bottomTab;
+@property (nonatomic, strong) RNNTopTabsOptions* topTabs;
+@property (nonatomic, strong) RNNTopTabOptions* topTab;
+@property (nonatomic, strong) RNNSideMenuOptions* sideMenu;
 
 @property (nonatomic, strong) NSNumber* statusBarHidden;
 @property (nonatomic, strong) NSNumber* screenBackgroundColor;
 @property (nonatomic, strong) NSMutableDictionary* originalTopBarImages;
 @property (nonatomic, strong) NSString* backButtonTransition;
 @property (nonatomic, strong) id orientation;
-@property (nonatomic, strong) NSArray* leftButtons;
-@property (nonatomic, strong) NSArray* rightButtons;
 @property (nonatomic, strong) NSNumber* statusBarBlur;
 @property (nonatomic, strong) NSNumber* statusBarHideWithTopBar;
 @property (nonatomic, strong) NSNumber* popGesture;
-@property (nonatomic, strong) RNNTopBarOptions* topBar;
-@property (nonatomic, strong) RNNTabBarOptions* bottomTabs;
-@property (nonatomic, strong) RNNSideMenuOptions* sideMenu;
 @property (nonatomic, strong) UIImage* backgroundImage;
 @property (nonatomic, strong) UIImage* rootBackgroundImage;
-@property (nonatomic, strong) RNNTabItemOptions* tabItem;
 
 
 - (UIInterfaceOrientationMask)supportedOrientations;
 
--(instancetype)init;
--(instancetype)initWithDict:(NSDictionary *)navigationOptions;
-
--(void)applyOn:(UIViewController*)viewController;
--(void)mergeWith:(NSDictionary*)otherOptions;
--(void)storeOriginalTopBarImages:(UIViewController*)viewController;
-
-- (void)applyTabBarItemOptions:(UIViewController*)viewController;
 
 @end

lib/ios/RNNNavigationOptions.m

 #import "RNNTabBarController.h"
 #import "RNNTopBarOptions.h"
 #import "RNNSideMenuController.h"
+#import "RNNRootViewController.h"
+#import "RNNNavigationButtons.h"
 
 const NSInteger BLUR_STATUS_TAG = 78264801;
 const NSInteger BLUR_TOPBAR_TAG = 78264802;
 
 @implementation RNNNavigationOptions
 
-
-
 -(instancetype)init {
 	return [self initWithDict:@{}];
 }
 	self.screenBackgroundColor = [navigationOptions objectForKey:@"screenBackgroundColor"];
 	self.backButtonTransition = [navigationOptions objectForKey:@"backButtonTransition"];
 	self.orientation = [navigationOptions objectForKey:@"orientation"];
-	self.leftButtons = [navigationOptions objectForKey:@"leftButtons"];
-	self.rightButtons = [navigationOptions objectForKey:@"rightButtons"];
 	self.topBar = [[RNNTopBarOptions alloc] initWithDict:[navigationOptions objectForKey:@"topBar"]];
-	self.bottomTabs = [[RNNTabBarOptions alloc] initWithDict:[navigationOptions objectForKey:@"bottomTabs"]];
+	self.topTab = [[RNNTopTabOptions alloc] initWithDict:[navigationOptions objectForKey:@"topTab"]];
+	self.bottomTabs = [[RNNBottomTabsOptions alloc] initWithDict:[navigationOptions objectForKey:@"bottomTabs"]];
 	self.sideMenu = [[RNNSideMenuOptions alloc] initWithDict:[navigationOptions objectForKey:@"sideMenu"]];
 	self.backgroundImage = [RCTConvert UIImage:[navigationOptions objectForKey:@"backgroundImage"]];
 	self.rootBackgroundImage = [RCTConvert UIImage:[navigationOptions objectForKey:@"rootBackgroundImage"]];
-	self.tabItem = [[RNNTabItemOptions alloc] initWithDict:[navigationOptions objectForKey:@"bottomTab"]];
+	self.bottomTab = [[RNNBottomTabOptions alloc] initWithDict:[navigationOptions objectForKey:@"bottomTab"]];
     
 	return self;
 }
 
 -(void)mergeWith:(NSDictionary *)otherOptions {
 	for (id key in otherOptions) {
-		if ([key isEqualToString:@"topBar"]) {
-			[self.topBar mergeWith:[otherOptions objectForKey:key]];
-		} else if ([key isEqualToString:@"bottomTabs"]) {
-			[self.bottomTabs mergeWith:[otherOptions objectForKey:key]];
-		} else if ([key isEqualToString:@"sideMenu"]) {
-			[self.sideMenu mergeWith:[otherOptions objectForKey:@"sideMenu"]];
-		} else if ([key isEqualToString:@"bottomTab"]) {
-			[self.tabItem mergeWith:[otherOptions objectForKey:key]];
+		if ([[self valueForKey:key] isKindOfClass:[RNNOptions class]]) {
+			RNNOptions* options = [self valueForKey:key];
+			[options mergeWith:[otherOptions objectForKey:key]];
 		} else {
 			[self setValue:[otherOptions objectForKey:key] forKey:key];
 		}
 }
 
 -(void)applyOn:(UIViewController*)viewController {
-	if (self.topBar) {
-		if (self.topBar.backgroundColor) {
-			UIColor* backgroundColor = [RCTConvert UIColor:self.topBar.backgroundColor];
-			viewController.navigationController.navigationBar.barTintColor = backgroundColor;
-		} else {
-			viewController.navigationController.navigationBar.barTintColor = nil;
-		}
-		
-		if (self.topBar.title) {
-			viewController.navigationItem.title = self.topBar.title;
-		}
-		
-		if (@available(iOS 11.0, *)) {
-			if (self.topBar.largeTitle){
-				if ([self.topBar.largeTitle boolValue]) {
-					viewController.navigationController.navigationBar.prefersLargeTitles = YES;
-					viewController.navigationItem.largeTitleDisplayMode = UINavigationItemLargeTitleDisplayModeAlways;
-				} else {
-					viewController.navigationItem.largeTitleDisplayMode = UINavigationItemLargeTitleDisplayModeNever;
-				}
-			} else {
-				viewController.navigationController.navigationBar.prefersLargeTitles = NO;
-				viewController.navigationItem.largeTitleDisplayMode = UINavigationItemLargeTitleDisplayModeNever;
-			}
-		}
-		
-		
-		if (self.topBar.textFontFamily || self.topBar.textFontSize || self.topBar.textColor) {
-			NSMutableDictionary* navigationBarTitleTextAttributes = [NSMutableDictionary new];
-			if (self.topBar.textColor) {
-				navigationBarTitleTextAttributes[NSForegroundColorAttributeName] = [RCTConvert UIColor:[self.topBar valueForKey:@"textColor"]];
-			}
-			if (self.topBar.textFontFamily){
-				if(self.topBar.textFontSize) {
-					navigationBarTitleTextAttributes[NSFontAttributeName] = [UIFont fontWithName:self.topBar.textFontFamily size:[self.topBar.textFontSize floatValue]];
-				} else {
-					navigationBarTitleTextAttributes[NSFontAttributeName] = [UIFont fontWithName:self.topBar.textFontFamily size:20];
-				}
-			} else if (self.topBar.textFontSize) {
-				navigationBarTitleTextAttributes[NSFontAttributeName] = [UIFont systemFontOfSize:[self.topBar.textFontSize floatValue]];
-			}
-			viewController.navigationController.navigationBar.titleTextAttributes = navigationBarTitleTextAttributes;
-			if (@available(iOS 11.0, *)){
-				viewController.navigationController.navigationBar.largeTitleTextAttributes = navigationBarTitleTextAttributes;
-			}
-			
-		}
-		
-		
-		if (self.topBar.hidden){
-			[viewController.navigationController setNavigationBarHidden:[self.topBar.hidden boolValue] animated:[self.topBar.animateHide boolValue]];
-		}
-		
-		if (self.topBar.hideOnScroll) {
-			viewController.navigationController.hidesBarsOnSwipe = [self.topBar.hideOnScroll boolValue];
-		}
-		
-		if (self.topBar.buttonColor) {
-			UIColor* buttonColor = [RCTConvert UIColor:self.topBar.buttonColor];
-			viewController.navigationController.navigationBar.tintColor = buttonColor;
-		} else {
-			viewController.navigationController.navigationBar.tintColor = nil;
-		}
-		
-		if ([self.topBar.blur boolValue]) {
-			if (![viewController.navigationController.navigationBar viewWithTag:BLUR_TOPBAR_TAG]) {
-				
-				[viewController.navigationController.navigationBar setBackgroundImage:[UIImage new] forBarMetrics:UIBarMetricsDefault];
-				viewController.navigationController.navigationBar.shadowImage = [UIImage new];
-				UIVisualEffectView *blur = [[UIVisualEffectView alloc] initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
-				CGRect statusBarFrame = [[UIApplication sharedApplication] statusBarFrame];
-				blur.frame = CGRectMake(0, -1 * statusBarFrame.size.height, viewController.navigationController.navigationBar.frame.size.width, viewController.navigationController.navigationBar.frame.size.height + statusBarFrame.size.height);
-				blur.userInteractionEnabled = NO;
-				blur.tag = BLUR_TOPBAR_TAG;
-				[viewController.navigationController.navigationBar insertSubview:blur atIndex:0];
-				[viewController.navigationController.navigationBar sendSubviewToBack:blur];
-			}
-		} else {
-			UIView *blur = [viewController.navigationController.navigationBar viewWithTag:BLUR_TOPBAR_TAG];
-			if (blur) {
-				[viewController.navigationController.navigationBar setBackgroundImage: nil forBarMetrics:UIBarMetricsDefault];
-				viewController.navigationController.navigationBar.shadowImage = nil;
-				[blur removeFromSuperview];
-			}
-		}
-		
-		void (^disableTopBarTransparent)() = ^void(){
-			UIView *transparentView = [viewController.navigationController.navigationBar viewWithTag:TOP_BAR_TRANSPARENT_TAG];
-			if (transparentView){
-				[transparentView removeFromSuperview];
-				[viewController.navigationController.navigationBar setBackgroundImage:self.originalTopBarImages[@"backgroundImage"] forBarMetrics:UIBarMetricsDefault];
-				viewController.navigationController.navigationBar.shadowImage = self.originalTopBarImages[@"shadowImage"];
-				self.originalTopBarImages = nil;
-			}
-		};
-	
-		if (self.topBar.transparent) {
-			if ([self.topBar.transparent boolValue]) {
-				if (![viewController.navigationController.navigationBar viewWithTag:TOP_BAR_TRANSPARENT_TAG]){
-					[self storeOriginalTopBarImages:viewController];
-					[viewController.navigationController.navigationBar setBackgroundImage:[UIImage new] forBarMetrics:UIBarMetricsDefault];
-					viewController.navigationController.navigationBar.shadowImage = [UIImage new];
-					UIView *transparentView = [[UIView alloc] initWithFrame:CGRectZero];
-					transparentView.tag = TOP_BAR_TRANSPARENT_TAG;
-					[viewController.navigationController.navigationBar insertSubview:transparentView atIndex:0];
-				}
-			} else {
-				disableTopBarTransparent();
-			}
-		} else {
-			disableTopBarTransparent();
-		}
-
-		if (self.topBar.translucent) {
-			viewController.navigationController.navigationBar.translucent = [self.topBar.translucent boolValue];
-		}
-
-		if (self.topBar.drawUnder) {
-			if ([self.topBar.drawUnder boolValue]) {
-				viewController.edgesForExtendedLayout |= UIRectEdgeTop;
-			} else {
-				viewController.edgesForExtendedLayout &= ~UIRectEdgeTop;
-			}
-		}
-		
-		if (self.topBar.noBorder) {
-			if ([self.topBar.noBorder boolValue]) {
-				viewController.navigationController.navigationBar
-				.shadowImage = [[UIImage alloc] init];
-			} else {
-				viewController.navigationController.navigationBar
-				.shadowImage = nil;
-			}
-		}
-		
-		if (self.topBar.testID) {
-			viewController.navigationController.navigationBar.accessibilityIdentifier = self.topBar.testID;
-		}
-	}
+	[self.topBar applyOn:viewController];
+	[self.bottomTabs applyOn:viewController];
+	[self.topTab applyOn:viewController];
+	[self.bottomTab applyOn:viewController];
+	[self.sideMenu applyOn:viewController];
 	
 	if (self.popGesture) {
 		viewController.navigationController.interactivePopGestureRecognizer.enabled = [self.popGesture boolValue];
 		viewController.view.backgroundColor = screenColor;
 	}
 	
-	if (self.bottomTabs) {
-		if (self.bottomTabs.currentTabIndex) {
-			[viewController.tabBarController setSelectedIndex:[self.bottomTabs.currentTabIndex unsignedIntegerValue]];
-		}
-		
-		if (self.bottomTabs.currentTabId) {
-			[(RNNTabBarController*)viewController.tabBarController setSelectedIndexByContainerID:self.bottomTabs.currentTabId];
-		}
-		
-		if (self.bottomTabs.hidden) {
-			[((RNNTabBarController *)viewController.tabBarController) setTabBarHidden:[self.bottomTabs.hidden boolValue] animated:[self.bottomTabs.animateHide boolValue]];
-		}
-		
-		if (self.bottomTabs.testID) {
-			viewController.tabBarController.tabBar.accessibilityIdentifier = self.bottomTabs.testID;
-		}
-		
-		if (self.bottomTabs.drawUnder) {
-			if ([self.bottomTabs.drawUnder boolValue]) {
-				viewController.edgesForExtendedLayout |= UIRectEdgeBottom;
-			} else {
-				viewController.edgesForExtendedLayout &= ~UIRectEdgeBottom;
-			}
-		}
-		
-		[self.bottomTabs resetOptions];
-	}
-	
 	if (self.statusBarBlur) {
 		UIView* curBlurView = [viewController.view viewWithTag:BLUR_STATUS_TAG];
 		if ([self.statusBarBlur boolValue]) {
 		}
 	}
 	
-	RNNSideMenuController* sideMenuController = (RNNSideMenuController*)UIApplication.sharedApplication.delegate.window.rootViewController;
-	if ([sideMenuController isKindOfClass:[RNNSideMenuController class]]) {
-		if (self.sideMenu.leftSideVisible) {
-			if (self.sideMenu.leftSideVisible.boolValue) {
-				[sideMenuController showSideMenu:MMDrawerSideLeft animated:YES];
-			} else {
-				[sideMenuController hideSideMenu:MMDrawerSideLeft animated:YES];
-			}
-		}
-		
-		if (self.sideMenu.rightSideVisible) {
-			if (self.sideMenu.rightSideVisible.boolValue) {
-				[sideMenuController showSideMenu:MMDrawerSideRight animated:YES];
-			} else {
-				[sideMenuController hideSideMenu:MMDrawerSideRight animated:YES];
-			}
-		}
-		
-		[self.sideMenu resetOptions];
-	}
-	
 	if (self.backgroundImage) {
 		UIImageView* backgroundImageView = (viewController.view.subviews.count > 0) ? viewController.view.subviews[0] : nil;
 		if (![backgroundImageView isKindOfClass:[UIImageView class]]) {
 		backgroundImageView.image = self.rootBackgroundImage;
 		[backgroundImageView setContentMode:UIViewContentModeScaleAspectFill];
 	}
-	
-	[self applyTabBarItemOptions:viewController];
-}
-
-- (void)applyTabBarItemOptions:(UIViewController*)viewController {
-	if (self.tabItem) {
-		if (self.tabItem.title || self.tabItem.icon) {
-			UITabBarItem* tabItem = [[UITabBarItem alloc] initWithTitle:self.tabItem.title image:[RCTConvert UIImage:self.tabItem.icon] tag:self.tabItem.tag];
-			tabItem.accessibilityIdentifier = self.tabItem.testID;
-			[viewController.navigationController setTabBarItem:tabItem];
-		}
-		
-		if (self.tabItem.badge) {
-			NSString *badge = [RCTConvert NSString:self.tabItem.badge];
-			if (viewController.navigationController) {
-				viewController.navigationController.tabBarItem.badgeValue = badge;
-			} else {
-				viewController.tabBarItem.badgeValue = badge;
-			}
-		}
-		
-		if (self.tabItem.visible) {
-			[viewController.tabBarController setSelectedIndex:[viewController.tabBarController.viewControllers indexOfObject:viewController]];
-		}
-		
-		[self.tabItem resetOptions];
-	}
 }
 
 - (UIInterfaceOrientationMask)supportedOrientations {
 	return supportedOrientationsMask;
 }
 
--(void)storeOriginalTopBarImages:(UIViewController*)viewController {
-	NSMutableDictionary *originalTopBarImages = [@{} mutableCopy];
-	UIImage *bgImage = [viewController.navigationController.navigationBar backgroundImageForBarMetrics:UIBarMetricsDefault];
-	if (bgImage != nil) {
-		originalTopBarImages[@"backgroundImage"] = bgImage;
-	}
-	UIImage *shadowImage = viewController.navigationController.navigationBar.shadowImage;
-	if (shadowImage != nil) {
-		originalTopBarImages[@"shadowImage"] = shadowImage;
-	}
-	self.originalTopBarImages = originalTopBarImages;
-}
-
-
 @end

lib/ios/RNNNavigationStackManager.h

 @interface RNNNavigationStackManager : NSObject
 
 @property (nonatomic, strong) UIViewController* fromVC;
-@property (nonatomic, strong) RNNRootViewController* toVC;
+@property (nonatomic, strong) UIViewController<RNNRootViewProtocol>* toVC;
 @property (nonatomic) int loadCount;
 -(instancetype)initWithStore:(RNNStore*)store;
 
 
--(void)push:(UIViewController*)newTop onTop:(NSString*)containerId completion:(RNNTransitionCompletionBlock)completion;
+-(void)push:(UIViewController<RNNRootViewProtocol>*)newTop onTop:(NSString*)containerId completion:(RNNTransitionCompletionBlock)completion;
 -(void)pop:(NSString*)containerId withAnimationData:(NSDictionary*)animationData;
 -(void)popTo:(NSString*)containerId;
 -(void)popToRoot:(NSString*)containerId;

lib/ios/RNNNavigationStackManager.m

 	return self;
 }
 
--(void)push:(UIViewController *)newTop onTop:(NSString *)containerId completion:(RNNTransitionCompletionBlock)completion {
+-(void)push:(UIViewController<RNNRootViewProtocol> *)newTop onTop:(NSString *)containerId completion:(RNNTransitionCompletionBlock)completion {
 	UIViewController *vc = [_store findContainerForId:containerId];
 	[self preparePush:newTop onTopVC:vc completion:completion];
 	[self waitForContentToAppearAndThen:@selector(pushAfterLoad:)];
 }
 
--(void)preparePush:(UIViewController *)newTop onTopVC:(UIViewController*)vc completion:(RNNTransitionCompletionBlock)completion {
-	self.toVC = (RNNRootViewController*)newTop;
+-(void)preparePush:(UIViewController<RNNRootViewProtocol> *)newTop onTopVC:(UIViewController*)vc completion:(RNNTransitionCompletionBlock)completion {
+	self.toVC = newTop;
 	self.fromVC = vc;
 	
-	if (self.toVC.isAnimated) {
-		RNNRootViewController* newTopRootView = (RNNRootViewController*)newTop;
-		vc.navigationController.delegate = newTopRootView;
+	if (self.toVC.isCustomTransitioned) {
+		vc.navigationController.delegate = newTop;
 	} else {
 		vc.navigationController.delegate = nil;
 		self.fromVC.navigationController.interactivePopGestureRecognizer.delegate = nil;

lib/ios/RNNOptions.h

+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <React/RCTConvert.h>
+@protocol RNNOptionsProtocol <NSObject>
+
+@optional
+-(void)resetOptions;
+-(void)applyOn:(UIViewController*)viewController;
+
+@end
+
+@interface RNNOptions : NSObject <RNNOptionsProtocol>
+
+-(instancetype)initWithDict:(NSDictionary*)dict;
+-(void)mergeWith:(NSDictionary*)otherOptions;
+
+@end

lib/ios/RNNOptions.m

+
+#import "RNNOptions.h"
+
+@implementation RNNOptions
+
+-(instancetype)initWithDict:(NSDictionary *)dict {
+	self = [super init];
+	[self mergeWith:dict];
+	return self;
+}
+
+-(void)mergeWith:(NSDictionary *)otherOptions {
+	for (id key in otherOptions) {
+		[self setValue:[otherOptions objectForKey:key] forKey:key];
+	}
+}
+
+@end

lib/ios/RNNRootViewController.h

 #import "RNNEventEmitter.h"
 #import "RNNNavigationOptions.h"
 #import "RNNAnimator.h"
+#import "RNNTopTabsViewController.h"
+#import "RNNRootViewProtocol.h"
+
+@interface RNNRootViewController : UIViewController	<RNNRootViewProtocol>
 
-@interface RNNRootViewController : UIViewController	<UINavigationControllerDelegate>
 @property (nonatomic, strong) RNNNavigationOptions* navigationOptions;
 @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
 		   animator:(RNNAnimator*)animator;
 
 
--(void)applyNavigationButtons;
--(BOOL)isAnimated;
 -(void)applyTabBarItem;
+-(void)applyTopTabsOptions;
+
+-(BOOL)isCustomTransitioned;
 
 @end

lib/ios/RNNRootViewController.m

 #import "RNNRootViewController.h"
 #import <React/RCTConvert.h>
 #import "RNNAnimator.h"
-#import "RNNNavigationButtons.h"
 
 @interface RNNRootViewController()
 @property (nonatomic, strong) NSString* containerName;
 @property (nonatomic) BOOL _statusBarHidden;
-@property (nonatomic, strong) RNNNavigationButtons* navigationButtons;
 
 @end
 
 											   object:nil];
 	self.navigationController.modalPresentationStyle = UIModalPresentationCustom;
 	self.navigationController.delegate = self;
-	self.navigationButtons = [[RNNNavigationButtons alloc] initWithViewController:self];
+
 	return self;
 }
 	
 -(void)viewWillAppear:(BOOL)animated{
 	[super viewWillAppear:animated];
 	[self.navigationOptions applyOn:self];
-	[self applyNavigationButtons];
 }
 
 - (void)viewDidLoad {
 	[super viewDidLoad];
 }
 
--(BOOL)isAnimated {
+-(BOOL)isCustomTransitioned {
 	return self.animator;
 }
 
 
 }
 
-
-
--(void)applyNavigationButtons{
-	[self.navigationButtons applyLeftButtons:self.navigationOptions.leftButtons rightButtons:self.navigationOptions.rightButtons];
+-(void)applyTabBarItem {
+	[self.navigationOptions.bottomTab applyOn:self];
 }
 
--(void)applyTabBarItem {
-	[self.navigationOptions applyTabBarItemOptions:self];
+-(void)applyTopTabsOptions {
+	[self.navigationOptions.topTab applyOn:self];
 }
 
 /**

lib/ios/RNNRootViewProtocol.h

+#import "RNNNavigationOptions.h"
+
+@protocol RNNRootViewProtocol <NSObject, UINavigationControllerDelegate>
+
+@required
+
+- (BOOL)isCustomTransitioned;
+
+@end
+
+

lib/ios/RNNSegmentedControl.h

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

lib/ios/RNNSegmentedControl.m

+#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/RNNSideMenuChildVC.h

 //
 
 #import <UIKit/UIKit.h>
+#import "RNNRootViewProtocol.h"
 
 typedef NS_ENUM(NSInteger, RNNSideMenuChildType) {
 	RNNSideMenuChildTypeCenter,
 };
 
 
-@interface RNNSideMenuChildVC : UIViewController
+@interface RNNSideMenuChildVC : UIViewController <RNNRootViewProtocol>
 
 @property (readonly) RNNSideMenuChildType type;
 @property (readonly) UIViewController *child;

lib/ios/RNNSideMenuChildVC.m

 	return self;
 }
 
+- (BOOL)isCustomTransitioned {
+	return NO;
+}
+
 @end

lib/ios/RNNSideMenuController.h

 #import <UIKit/UIKit.h>
 #import "RNNSideMenuChildVC.h"
 #import "MMDrawerController.h"
+#import "RNNRootViewProtocol.h"
 
-@interface RNNSideMenuController : UIViewController
+@interface RNNSideMenuController : UIViewController <RNNRootViewProtocol>
 
 @property (readonly) RNNSideMenuChildVC *center;
 @property (readonly) RNNSideMenuChildVC *left;

lib/ios/RNNSideMenuController.m

 	}
 }
 
+- (BOOL)isCustomTransitioned {
+	return NO;
+}
+
 @end

lib/ios/RNNSideMenuOptions.h

-#import <Foundation/Foundation.h>
+#import "RNNOptions.h"
 
-@interface RNNSideMenuOptions : NSObject
+@interface RNNSideMenuOptions : RNNOptions
 
 @property (nonatomic, strong) NSNumber* leftSideVisible;
 @property (nonatomic, strong) NSNumber* rightSideVisible;
 
--(instancetype)init;
--(instancetype)initWithDict:(NSDictionary *)sideMenuOptions;
--(void)mergeWith:(NSDictionary*)otherOptions;
-
--(void)resetOptions;
-
 @end

lib/ios/RNNSideMenuOptions.m

 #import "RNNSideMenuOptions.h"
+#import "RNNSideMenuController.h"
 
 @implementation RNNSideMenuOptions
 
--(instancetype)init {
-	return [self initWithDict:@{}];
-}
-
--(instancetype)initWithDict:(NSDictionary *)sideMenuOptions {
-	self = [super init];
-	
-	[self mergeWith:sideMenuOptions];
-	
-	return self;
+- (void)applyOn:(UIViewController *)viewController {
+	RNNSideMenuController* sideMenuController = (RNNSideMenuController*)UIApplication.sharedApplication.delegate.window.rootViewController;
+	if ([sideMenuController isKindOfClass:[RNNSideMenuController class]]) {
+		if (self.leftSideVisible) {
+			if (self.leftSideVisible.boolValue) {
+				[sideMenuController showSideMenu:MMDrawerSideLeft animated:YES];
+			} else {
+				[sideMenuController hideSideMenu:MMDrawerSideLeft animated:YES];
+			}
+		}
+		
+		if (self.rightSideVisible) {
+			if (self.rightSideVisible.boolValue) {
+				[sideMenuController showSideMenu:MMDrawerSideRight animated:YES];
+			} else {
+				[sideMenuController hideSideMenu:MMDrawerSideRight animated:YES];
+			}
+		}
+		
+		[self resetOptions];
+	}
 }
 
 -(void)mergeWith:(NSDictionary *)otherOptions {

lib/ios/RNNTabBarController.h

 
 #import <UIKit/UIKit.h>
+#import "RNNRootViewProtocol.h"
 
-@interface RNNTabBarController : UITabBarController
+@interface RNNTabBarController : UITabBarController <RNNRootViewProtocol>
 
 - (void)setTabBarHidden:(BOOL)hidden animated:(BOOL)animated;
 - (void)setSelectedIndexByContainerID:(NSString *)containerID;

lib/ios/RNNTabBarController.m

 	}
 }
 
+- (BOOL)isCustomTransitioned {
+	return NO;
+}
+
 @end

lib/ios/RNNTabBarOptions.m

-#import "RNNTabBarOptions.h"
-
-@implementation RNNTabBarOptions
-
--(instancetype)init {
-	return [self initWithDict:@{}];
-}
-
--(instancetype)initWithDict:(NSDictionary *)tabBarOptions {
-	self = [super init];
-	
-	self.hidden = [tabBarOptions valueForKey:@"hidden"];
-	self.animateHide = [tabBarOptions valueForKey:@"animateHide"];
-	self.currentTabIndex = [tabBarOptions valueForKey:@"currentTabIndex"];
-	self.testID = [tabBarOptions valueForKey:@"testID"];
-	self.currentTabId = [tabBarOptions valueForKey:@"currentTabId"];
-	self.drawUnder = [tabBarOptions valueForKey:@"drawUnder"];
-	
-	return self;
-}
-
-- (void)resetOptions {
-	self.currentTabId = nil;
-	self.currentTabIndex = nil;
-}
-
--(void)mergeWith:(NSDictionary *)otherOptions {
-	for (id key in otherOptions) {
-		[self setValue:[otherOptions objectForKey:key] forKey:key];
-	}
-}
-@end

lib/ios/RNNTabItemOptions.m

-#import "RNNTabItemOptions.h"
-
-@implementation RNNTabItemOptions
-
--(instancetype)initWithDict:(NSDictionary *)tabItemDict {
-	self = [super init];
-	
-	self.title = tabItemDict[@"title"];
-	self.tag = [tabItemDict[@"tag"] integerValue];
-	self.badge = tabItemDict[@"badge"];
-	self.testID = tabItemDict[@"testID"];
-	self.visible = tabItemDict[@"visible"];
-	self.icon = tabItemDict[@"icon"];
-	
-	return self;
-}
-
--(void)mergeWith:(NSDictionary *)otherOptions {
-	for (id key in otherOptions) {
-		[self setValue:[otherOptions objectForKey:key] forKey:key];
-	}
-}
-
--(void)resetOptions {
-	self.title = nil;
-	self.badge = nil;
-	self.visible = nil;
-	self.icon = nil;
-	self.testID = nil;
-}
-
-@end

lib/ios/RNNTopBarOptions.h

-#import <Foundation/Foundation.h>
+#import "RNNOptions.h"
 
-extern const NSInteger BLUR_TOPBAR_TAG;
-
-@interface RNNTopBarOptions : NSObject
+@interface RNNTopBarOptions : RNNOptions
 
+@property (nonatomic, strong) NSArray* leftButtons;
+@property (nonatomic, strong) NSArray* rightButtons;
 @property (nonatomic, strong) NSNumber* backgroundColor;
 @property (nonatomic, strong) NSNumber* textColor;
 @property (nonatomic, strong) NSString* title;
 @property (nonatomic, strong) NSNumber* largeTitle;
 @property (nonatomic, strong) NSString* testID;
 
--(instancetype)init;
--(instancetype)initWithDict:(NSDictionary *)topBarOptions;
--(void)mergeWith:(NSDictionary*)otherOptions;
-
 @end

lib/ios/RNNTopBarOptions.m

 #import "RNNTopBarOptions.h"
+#import "RNNNavigationButtons.h"
 
-@implementation RNNTopBarOptions
+extern const NSInteger BLUR_TOPBAR_TAG;
 
--(instancetype)init {
-	return [self initWithDict:@{}];
-}
+@interface RNNTopBarOptions ()
+
+@property (nonatomic, strong) NSMutableDictionary* originalTopBarImages;
+@property (nonatomic, strong) RNNNavigationButtons* navigationButtons;
+
+@end
 
--(instancetype)initWithDict:(NSDictionary *)topBarOptions {
-	self = [super init];
-	
-	self.title = [topBarOptions valueForKey:@"title"];
-	self.backgroundColor = [topBarOptions valueForKey:@"backgroundColor"];
-	self.textColor = [topBarOptions valueForKey:@"textColor"];
-	self.textFontFamily = [topBarOptions valueForKey:@"textFontFamily"];
-	self.textFontSize = [topBarOptions valueForKey:@"textFontSize"];
-	self.hidden = [topBarOptions valueForKey:@"hidden"];
-	self.hideOnScroll = [topBarOptions valueForKey:@"hideOnScroll"];
-	self.buttonColor = [topBarOptions valueForKey:@"buttonColor"];
-	self.blur = [topBarOptions valueForKey:@"blur"];
-	self.translucent = [topBarOptions valueForKey:@"translucent"];
-	self.transparent = [topBarOptions valueForKey:@"transparent"];
-	self.noBorder = [topBarOptions valueForKey:@"noBorder"];
-	self.animateHide = [topBarOptions valueForKey:@"animateHide"];
-	self.largeTitle = [topBarOptions valueForKey:@"largeTitle"];
-	self.testID = [topBarOptions valueForKey:@"testID"];
-	self.drawUnder = [topBarOptions valueForKey:@"drawUnder"];
-	
-	return self;
+@implementation RNNTopBarOptions
+
+- (void)applyOn:(UIViewController*)viewController {
+	if (self.backgroundColor) {
+		UIColor* backgroundColor = [RCTConvert UIColor:self.backgroundColor];
+		viewController.navigationController.navigationBar.barTintColor = backgroundColor;
+	} else {
+		viewController.navigationController.navigationBar.barTintColor = nil;
+	}
+	
+	if (self.title) {
+		viewController.navigationItem.title = self.title;
+	}
+	
+	if (@available(iOS 11.0, *)) {
+		if (self.largeTitle){
+			if ([self.largeTitle boolValue]) {
+				viewController.navigationController.navigationBar.prefersLargeTitles = YES;
+				viewController.navigationItem.largeTitleDisplayMode = UINavigationItemLargeTitleDisplayModeAlways;
+			} else {
+				viewController.navigationItem.largeTitleDisplayMode = UINavigationItemLargeTitleDisplayModeNever;
+			}
+		} else {
+			viewController.navigationController.navigationBar.prefersLargeTitles = NO;
+			viewController.navigationItem.largeTitleDisplayMode = UINavigationItemLargeTitleDisplayModeNever;
+		}
+	}
+	
+	
+	if (self.textFontFamily || self.textFontSize || self.textColor) {
+		NSMutableDictionary* navigationBarTitleTextAttributes = [NSMutableDictionary new];
+		if (self.textColor) {
+			navigationBarTitleTextAttributes[NSForegroundColorAttributeName] = [RCTConvert UIColor:[self valueForKey:@"textColor"]];
+		}
+		if (self.textFontFamily){
+			if(self.textFontSize) {
+				navigationBarTitleTextAttributes[NSFontAttributeName] = [UIFont fontWithName:self.textFontFamily size:[self.textFontSize floatValue]];
+			} else {
+				navigationBarTitleTextAttributes[NSFontAttributeName] = [UIFont fontWithName:self.textFontFamily size:20];
+			}
+		} else if (self.textFontSize) {
+			navigationBarTitleTextAttributes[NSFontAttributeName] = [UIFont systemFontOfSize:[self.textFontSize floatValue]];
+		}
+		viewController.navigationController.navigationBar.titleTextAttributes = navigationBarTitleTextAttributes;
+		if (@available(iOS 11.0, *)){
+			viewController.navigationController.navigationBar.largeTitleTextAttributes = navigationBarTitleTextAttributes;
+		}
+		
+	}
+	
+	
+	if (self.hidden){
+		[viewController.navigationController setNavigationBarHidden:[self.hidden boolValue] animated:[self.animateHide boolValue]];
+	}
+	
+	if (self.hideOnScroll) {
+		viewController.navigationController.hidesBarsOnSwipe = [self.hideOnScroll boolValue];
+	}
+	
+	if (self.buttonColor) {
+		UIColor* buttonColor = [RCTConvert UIColor:self.buttonColor];
+		viewController.navigationController.navigationBar.tintColor = buttonColor;
+	} else {
+		viewController.navigationController.navigationBar.tintColor = nil;
+	}
+	
+	if ([self.blur boolValue]) {
+		if (![viewController.navigationController.navigationBar viewWithTag:BLUR_TOPBAR_TAG]) {
+			
+			[viewController.navigationController.navigationBar setBackgroundImage:[UIImage new] forBarMetrics:UIBarMetricsDefault];
+			viewController.navigationController.navigationBar.shadowImage = [UIImage new];
+			UIVisualEffectView *blur = [[UIVisualEffectView alloc] initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
+			CGRect statusBarFrame = [[UIApplication sharedApplication] statusBarFrame];
+			blur.frame = CGRectMake(0, -1 * statusBarFrame.size.height, viewController.navigationController.navigationBar.frame.size.width, viewController.navigationController.navigationBar.frame.size.height + statusBarFrame.size.height);
+			blur.userInteractionEnabled = NO;
+			blur.tag = BLUR_TOPBAR_TAG;
+			[viewController.navigationController.navigationBar insertSubview:blur atIndex:0];
+			[viewController.navigationController.navigationBar sendSubviewToBack:blur];
+		}
+	} else {
+		UIView *blur = [viewController.navigationController.navigationBar viewWithTag:BLUR_TOPBAR_TAG];
+		if (blur) {
+			[viewController.navigationController.navigationBar setBackgroundImage: nil forBarMetrics:UIBarMetricsDefault];
+			viewController.navigationController.navigationBar.shadowImage = nil;
+			[blur removeFromSuperview];
+		}
+	}
+	
+	void (^disableTopBarTransparent)() = ^void(){
+		UIView *transparentView = [viewController.navigationController.navigationBar viewWithTag:TOP_BAR_TRANSPARENT_TAG];
+		if (transparentView){
+			[transparentView removeFromSuperview];
+			[viewController.navigationController.navigationBar setBackgroundImage:self.originalTopBarImages[@"backgroundImage"] forBarMetrics:UIBarMetricsDefault];
+			viewController.navigationController.navigationBar.shadowImage = self.originalTopBarImages[@"shadowImage"];
+			self.originalTopBarImages = nil;
+		}
+	};
+	
+	if (self.transparent) {
+		if ([self.transparent boolValue]) {
+			if (![viewController.navigationController.navigationBar viewWithTag:TOP_BAR_TRANSPARENT_TAG]){
+				[self storeOriginalTopBarImages:viewController];
+				[viewController.navigationController.navigationBar setBackgroundImage:[UIImage new] forBarMetrics:UIBarMetricsDefault];
+				viewController.navigationController.navigationBar.shadowImage = [UIImage new];
+				UIView *transparentView = [[UIView alloc] initWithFrame:CGRectZero];
+				transparentView.tag = TOP_BAR_TRANSPARENT_TAG;
+				[viewController.navigationController.navigationBar insertSubview:transparentView atIndex:0];
+			}
+		} else {
+			disableTopBarTransparent();
+		}
+	} else {
+		disableTopBarTransparent();
+	}
+	
+	if (self.translucent) {
+		viewController.navigationController.navigationBar.translucent = [self.translucent boolValue];
+	}
+	
+	if (self.drawUnder) {
+		if ([self.drawUnder boolValue]) {
+			viewController.edgesForExtendedLayout |= UIRectEdgeTop;
+		} else {
+			viewController.edgesForExtendedLayout &= ~UIRectEdgeTop;
+		}
+	}
+	
+	if (self.noBorder) {
+		if ([self.noBorder boolValue]) {
+			viewController.navigationController.navigationBar
+			.shadowImage = [[UIImage alloc] init];
+		} else {
+			viewController.navigationController.navigationBar
+			.shadowImage = nil;
+		}
+	}
+	
+	if (self.testID) {
+		viewController.navigationController.navigationBar.accessibilityIdentifier = self.testID;
+	}
+	
+	if (self.rightButtons || self.leftButtons) {
+		_navigationButtons = [[RNNNavigationButtons alloc] initWithViewController:(RNNRootViewController*)viewController];
+		[_navigationButtons applyLeftButtons:self.leftButtons rightButtons:self.rightButtons];
+	}
 }
 
--(void)mergeWith:(NSDictionary *)otherOptions {
-	for (id key in otherOptions) {
-		[self setValue:[otherOptions objectForKey:key] forKey:key];
+-(void)storeOriginalTopBarImages:(UIViewController*)viewController {
+	NSMutableDictionary *originalTopBarImages = [@{} mutableCopy];
+	UIImage *bgImage = [viewController.navigationController.navigationBar backgroundImageForBarMetrics:UIBarMetricsDefault];
+	if (bgImage != nil) {
+		originalTopBarImages[@"backgroundImage"] = bgImage;
 	}
+	UIImage *shadowImage = viewController.navigationController.navigationBar.shadowImage;
+	if (shadowImage != nil) {
+		originalTopBarImages[@"shadowImage"] = shadowImage;
+	}
+	self.originalTopBarImages = originalTopBarImages;
 }
+
 @end
 
 

lib/ios/RNNTopTabOptions.h

+#import "RNNOptions.h"
+
+@interface RNNTopTabOptions : RNNOptions
+
+@property (nonatomic, strong) NSString* title;
+@property (nonatomic, strong) NSString* titleFontFamily;
+
+@end
+

lib/ios/RNNTopTabOptions.m

+#import "RNNTopTabOptions.h"
+#import "RNNRootViewController.h"
+
+@implementation RNNTopTabOptions
+
+- (void)applyOn:(RNNRootViewController*)viewController {
+	if (self.title) {
+		[viewController.topTabsViewController viewController:viewController changedTitle:self.title];
+	}
+}
+
+-(void)mergeWith:(NSDictionary *)otherOptions {
+	for (id key in otherOptions) {
+		[self setValue:[otherOptions objectForKey:key] forKey:key];
+	}
+}
+@end
+

lib/ios/RNNTopTabsOptions.h

+#import "RNNOptions.h"
+
+@interface RNNTopTabsOptions : RNNOptions
+
+@property (nonatomic, strong) NSNumber* backgroundColor;
+
+@end

lib/ios/RNNTopTabsOptions.m

+#import "RNNTopTabsOptions.h"
+#import "RNNTopTabsViewController.h"
+
+@implementation RNNTopTabsOptions
+
+- (void)applyOn:(RNNTopTabsViewController *)viewController {
+
+}
+
+@end

lib/ios/RNNTopTabsViewController.h

+#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

+#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)isCustomTransitioned {
+	return NO;
+}
+
+@end

lib/ios/ReactNativeNavigation.h

-
 #import <Foundation/Foundation.h>
-#import <UIKit/UIKit.h>
 
 @interface ReactNativeNavigation : NSObject
 

lib/ios/ReactNativeNavigation.m

-
 #import "ReactNativeNavigation.h"
 
+#import <UIKit/UIKit.h>
 #import <React/RCTBridge.h>
 #import <React/RCTUIManager.h>
 
-#import "RNNEventEmitter.h"
+#import "RNNBridgeManager.h"
 #import "RNNSplashScreen.h"
-#import "RNNBridgeModule.h"
-#import "RNNRootViewCreator.h"
-#import "RNNReactRootViewCreator.h"
 
-@interface ReactNativeNavigation() <RCTBridgeDelegate>
+@interface ReactNativeNavigation()
+
+@property (nonatomic, strong) RNNBridgeManager *bridgeManager;
 
 @end
 
-@implementation ReactNativeNavigation {
-	NSURL* _jsCodeLocation;
-	NSDictionary* _launchOptions;
-	RCTBridge* _bridge;
-	
-	RNNStore* _store;
-	
-	RNNCommandsHandler* _commandsHandler;
-}
+@implementation ReactNativeNavigation
 
 # pragma mark - public API
 
 
 # pragma mark - instance
 
-+(instancetype) sharedInstance {
++ (instancetype) sharedInstance {
 	static ReactNativeNavigation *instance = nil;
 	static dispatch_once_t onceToken = 0;
 	dispatch_once(&onceToken,^{
 }
 
 -(void)bootstrap:(NSURL *)jsCodeLocation launchOptions:(NSDictionary *)launchOptions {
-	_jsCodeLocation = jsCodeLocation;
-	_launchOptions = launchOptions;
-	_store = [RNNStore new];
-	
+	self.bridgeManager = [[RNNBridgeManager alloc] initWithJsCodeLocation:jsCodeLocation launchOptions:launchOptions];
 	[RNNSplashScreen show];
-	
-	[self registerForJsEvents];
-	
-	[self createBridgeLoadJsAndThenInitDependencyGraph];
-}
-
-# pragma mark - RCTBridgeDelegate
-
--(NSURL *)sourceURLForBridge:(RCTBridge *)bridge {
-	return _jsCodeLocation;
-}
-
-/**
- * here we initialize all of our dependency graph
- */
--(NSArray<id<RCTBridgeModule>> *)extraModulesForBridge:(RCTBridge *)bridge {
-	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];
-	RNNBridgeModule *bridgeModule = [[RNNBridgeModule alloc] initWithCommandsHandler:_commandsHandler];
-	
-	return @[bridgeModule,eventEmitter];
-}
-
-# pragma mark - js events
-
--(void)onJavaScriptWillLoad {
-	[_store clean];
-}
-
--(void)onJavaScriptLoaded {
-	[_store setReadyToReceiveCommands:true];
-	[[_bridge moduleForClass:[RNNEventEmitter class]] sendOnAppLaunched];
-}
-
--(void)onBridgeWillReload {
-	UIApplication.sharedApplication.delegate.window.rootViewController =  nil;
-}
-
-# pragma mark - private
-
--(void)createBridgeLoadJsAndThenInitDependencyGraph {
-	_bridge = [[RCTBridge alloc] initWithDelegate:self launchOptions:_launchOptions];
-}
-
--(void)registerForJsEvents {
-	[[NSNotificationCenter defaultCenter] addObserver:self
-											 selector:@selector(onJavaScriptLoaded)
-												 name:RCTJavaScriptDidLoadNotification
-											   object:nil];
-	[[NSNotificationCenter defaultCenter] addObserver:self
-											 selector:@selector(onJavaScriptWillLoad)
-												 name:RCTJavaScriptWillStartLoadingNotification
-											   object:nil];
-	[[NSNotificationCenter defaultCenter] addObserver:self
-											 selector:@selector(onBridgeWillReload)
-												 name:RCTBridgeWillReloadNotification
-											   object:nil];
 }
 
 @end

lib/ios/ReactNativeNavigation.xcodeproj/project.pbxproj

 		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 */; };
+		2DCD9195200014A900EDC75D /* RNNBridgeManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 2DCD9193200014A900EDC75D /* RNNBridgeManager.h */; };
+		2DCD9196200014A900EDC75D /* RNNBridgeManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 2DCD9194200014A900EDC75D /* RNNBridgeManager.m */; };
+		504AFE641FFE53070076E904 /* RNNOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 504AFE621FFE53070076E904 /* RNNOptions.h */; };
+		504AFE651FFE53070076E904 /* RNNOptions.m in Sources */ = {isa = PBXBuildFile; fileRef = 504AFE631FFE53070076E904 /* RNNOptions.m */; };
+		504AFE741FFFF0540076E904 /* RNNTopTabsOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 504AFE721FFFF0540076E904 /* RNNTopTabsOptions.h */; };
+		504AFE751FFFF0540076E904 /* RNNTopTabsOptions.m in Sources */ = {isa = PBXBuildFile; fileRef = 504AFE731FFFF0540076E904 /* RNNTopTabsOptions.m */; };
+		504AFE761FFFF1E00076E904 /* RNNNavigationOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = E83BAD691F27362500A9F3DD /* RNNNavigationOptions.h */; };
+		504AFE771FFFF1E20076E904 /* RNNTopBarOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = A7626BFE1FC2FB6700492FB8 /* RNNTopBarOptions.h */; };
+		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 */; };
-		50EB93411FE14A3E00BD8EEE /* RNNTabItemOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 50EB933F1FE14A3E00BD8EEE /* RNNTabItemOptions.h */; };
-		50EB93421FE14A3E00BD8EEE /* RNNTabItemOptions.m in Sources */ = {isa = PBXBuildFile; fileRef = 50EB93401FE14A3E00BD8EEE /* RNNTabItemOptions.m */; };
+		50EB93421FE14A3E00BD8EEE /* RNNBottomTabOptions.m in Sources */ = {isa = PBXBuildFile; fileRef = 50EB93401FE14A3E00BD8EEE /* RNNBottomTabOptions.m */; };
 		50F5DFC11F407A8C001A00BC /* RNNTabBarController.h in Headers */ = {isa = PBXBuildFile; fileRef = 50F5DFBF1F407A8C001A00BC /* RNNTabBarController.h */; };
 		50F5DFC21F407A8C001A00BC /* RNNTabBarController.m in Sources */ = {isa = PBXBuildFile; fileRef = 50F5DFC01F407A8C001A00BC /* RNNTabBarController.m */; };
 		50F5DFC51F407AA0001A00BC /* RNNNavigationController.h in Headers */ = {isa = PBXBuildFile; fileRef = 50F5DFC31F407AA0001A00BC /* RNNNavigationController.h */; };
 		7BEF0D1C1E43771B003E96B0 /* RNNLayoutNode.h in Headers */ = {isa = PBXBuildFile; fileRef = 7BEF0D1A1E43771B003E96B0 /* RNNLayoutNode.h */; };
 		7BEF0D1D1E43771B003E96B0 /* RNNLayoutNode.m in Sources */ = {isa = PBXBuildFile; fileRef = 7BEF0D1B1E43771B003E96B0 /* RNNLayoutNode.m */; };
 		A7626BFD1FC2FB2C00492FB8 /* RNNTopBarOptions.m in Sources */ = {isa = PBXBuildFile; fileRef = A7626BFC1FC2FB2C00492FB8 /* RNNTopBarOptions.m */; };
-		A7626C011FC5796200492FB8 /* RNNTabBarOptions.m in Sources */ = {isa = PBXBuildFile; fileRef = A7626C001FC5796200492FB8 /* RNNTabBarOptions.m */; };
+		A7626C011FC5796200492FB8 /* RNNBottomTabsOptions.m in Sources */ = {isa = PBXBuildFile; fileRef = A7626C001FC5796200492FB8 /* RNNBottomTabsOptions.m */; };
 		E8367B801F7A8A4700675C05 /* VICMAImageView.h in Headers */ = {isa = PBXBuildFile; fileRef = E8367B7E1F7A8A4700675C05 /* VICMAImageView.h */; };
 		E8367B811F7A8A4700675C05 /* VICMAImageView.m in Sources */ = {isa = PBXBuildFile; fileRef = E8367B7F1F7A8A4700675C05 /* VICMAImageView.m */; };
 		E83BAD681F2734B500A9F3DD /* RNNNavigationOptionsTest.m in Sources */ = {isa = PBXBuildFile; fileRef = E83BAD671F2734B500A9F3DD /* RNNNavigationOptionsTest.m */; };
 		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>"; };
+		2DCD9193200014A900EDC75D /* RNNBridgeManager.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNBridgeManager.h; sourceTree = "<group>"; };
+		2DCD9194200014A900EDC75D /* RNNBridgeManager.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNBridgeManager.m; sourceTree = "<group>"; };
+		504AFE621FFE53070076E904 /* RNNOptions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNOptions.h; sourceTree = "<group>"; };
+		504AFE631FFE53070076E904 /* RNNOptions.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNOptions.m; sourceTree = "<group>"; };
+		504AFE721FFFF0540076E904 /* RNNTopTabsOptions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNTopTabsOptions.h; sourceTree = "<group>"; };
+		504AFE731FFFF0540076E904 /* RNNTopTabsOptions.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNTopTabsOptions.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>"; };
-		50EB933F1FE14A3E00BD8EEE /* RNNTabItemOptions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNTabItemOptions.h; sourceTree = "<group>"; };
-		50EB93401FE14A3E00BD8EEE /* RNNTabItemOptions.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNTabItemOptions.m; sourceTree = "<group>"; };
+		50EB933F1FE14A3E00BD8EEE /* RNNBottomTabOptions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNBottomTabOptions.h; sourceTree = "<group>"; };
+		50EB93401FE14A3E00BD8EEE /* RNNBottomTabOptions.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNBottomTabOptions.m; sourceTree = "<group>"; };
 		50F5DFBF1F407A8C001A00BC /* RNNTabBarController.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNTabBarController.h; sourceTree = "<group>"; };
 		50F5DFC01F407A8C001A00BC /* RNNTabBarController.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNTabBarController.m; sourceTree = "<group>"; };
 		50F5DFC31F407AA0001A00BC /* RNNNavigationController.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNNavigationController.h; sourceTree = "<group>"; };
 		7BEF0D1B1E43771B003E96B0 /* RNNLayoutNode.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RNNLayoutNode.m; sourceTree = "<group>"; };
 		A7626BFC1FC2FB2C00492FB8 /* RNNTopBarOptions.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNTopBarOptions.m; sourceTree = "<group>"; };
 		A7626BFE1FC2FB6700492FB8 /* RNNTopBarOptions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNTopBarOptions.h; sourceTree = "<group>"; };
-		A7626BFF1FC578AB00492FB8 /* RNNTabBarOptions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNTabBarOptions.h; sourceTree = "<group>"; };
-		A7626C001FC5796200492FB8 /* RNNTabBarOptions.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNTabBarOptions.m; sourceTree = "<group>"; };
+		A7626BFF1FC578AB00492FB8 /* RNNBottomTabsOptions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNBottomTabsOptions.h; sourceTree = "<group>"; };
+		A7626C001FC5796200492FB8 /* RNNBottomTabsOptions.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNBottomTabsOptions.m; sourceTree = "<group>"; };
 		D8AFADBD1BEE6F3F00A4592D /* libReactNativeNavigation.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libReactNativeNavigation.a; sourceTree = BUILT_PRODUCTS_DIR; };
 		E8367B7E1F7A8A4700675C05 /* VICMAImageView.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = VICMAImageView.h; sourceTree = "<group>"; };
 		E8367B7F1F7A8A4700675C05 /* VICMAImageView.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = VICMAImageView.m; sourceTree = "<group>"; };
 			path = Animations;
 			sourceTree = "<group>";
 		};
+		504AFE611FFE52EF0076E904 /* Options */ = {
+			isa = PBXGroup;
+			children = (
+				504AFE621FFE53070076E904 /* RNNOptions.h */,
+				504AFE631FFE53070076E904 /* RNNOptions.m */,
+				E83BAD691F27362500A9F3DD /* RNNNavigationOptions.h */,
+				E83BAD6A1F27363A00A9F3DD /* RNNNavigationOptions.m */,
+				A7626BFE1FC2FB6700492FB8 /* RNNTopBarOptions.h */,
+				A7626BFC1FC2FB2C00492FB8 /* RNNTopBarOptions.m */,
+				A7626BFF1FC578AB00492FB8 /* RNNBottomTabsOptions.h */,
+				A7626C001FC5796200492FB8 /* RNNBottomTabsOptions.m */,
+				50EB933F1FE14A3E00BD8EEE /* RNNBottomTabOptions.h */,
+				50EB93401FE14A3E00BD8EEE /* RNNBottomTabOptions.m */,
+				507F43C71FF4F9CC00D9425B /* RNNTopTabOptions.h */,
+				507F43C81FF4F9CC00D9425B /* RNNTopTabOptions.m */,
+				504AFE721FFFF0540076E904 /* RNNTopTabsOptions.h */,
+				504AFE731FFFF0540076E904 /* RNNTopTabsOptions.m */,
+				50CB3B671FDE911400AA153B /* RNNSideMenuOptions.h */,
+				50CB3B681FDE911400AA153B /* RNNSideMenuOptions.m */,
+			);
+			name = Options;
+			sourceTree = "<group>";
+		};
+		507F43F11FF4FCD800D9425B /* HMSegmentControl */ = {
+			isa = PBXGroup;
+			children = (
+				507F43F21FF4FCFE00D9425B /* HMSegmentedControl.h */,
+				507F43F31FF4FCFE00D9425B /* HMSegmentedControl.m */,
+			);
+			name = HMSegmentControl;
+			sourceTree = "<group>";
+		};
 		7B1E4C4B1E2D173700C3A525 /* Controllers */ = {
 			isa = PBXGroup;
 			children = (
 				E8AEDB471F584175000F5A6A /* Components */,
 				E8AEDB461F58414D000F5A6A /* Animations */,
+				504AFE611FFE52EF0076E904 /* Options */,
 				261F0E621E6EC94900989DE2 /* RNNModalManager.h */,
 				261F0E631E6EC94900989DE2 /* RNNModalManager.m */,
 				261F0E681E6F028A00989DE2 /* RNNNavigationStackManager.h */,
 				7BC9346D1E26886E00EFA125 /* RNNControllerFactory.m */,
 				263905E41E4CAC950023D7D3 /* RNNSideMenuChildVC.h */,
 				263905E51E4CAC950023D7D3 /* RNNSideMenuChildVC.m */,
-				E83BAD691F27362500A9F3DD /* RNNNavigationOptions.h */,
-				E83BAD6A1F27363A00A9F3DD /* RNNNavigationOptions.m */,
 				21B85E5E1F44482A00B314B5 /* RNNNavigationButtons.h */,
 				21B85E5C1F44480200B314B5 /* RNNNavigationButtons.m */,
 				214545261F4DC164006E8DA1 /* RNNUIBarButtonItem.h */,
 				214545241F4DC125006E8DA1 /* RNNUIBarButtonItem.m */,
-				50EB933F1FE14A3E00BD8EEE /* RNNTabItemOptions.h */,
-				50EB93401FE14A3E00BD8EEE /* RNNTabItemOptions.m */,
-				A7626BFE1FC2FB6700492FB8 /* RNNTopBarOptions.h */,
-				A7626BFC1FC2FB2C00492FB8 /* RNNTopBarOptions.m */,
-				A7626BFF1FC578AB00492FB8 /* RNNTabBarOptions.h */,
-				A7626C001FC5796200492FB8 /* RNNTabBarOptions.m */,
-				50CB3B671FDE911400AA153B /* RNNSideMenuOptions.h */,
-				50CB3B681FDE911400AA153B /* RNNSideMenuOptions.m */,
+				507F43C31FF4F17C00D9425B /* RNNTopTabsViewController.h */,
+				507F43C41FF4F17C00D9425B /* RNNTopTabsViewController.m */,
+				507F43F61FF525B500D9425B /* RNNSegmentedControl.h */,
+				507F43F71FF525B500D9425B /* RNNSegmentedControl.m */,
+				507F441F1FFA8A8800D9425B /* RNNRootViewProtocol.h */,
 			);
 			name = Controllers;
 			sourceTree = "<group>";
 				214545271F4DC7ED006E8DA1 /* Helpers */,
 				7BA500731E2544B9001B9E1B /* ReactNativeNavigation.h */,
 				7BA500741E2544B9001B9E1B /* ReactNativeNavigation.m */,
+				2DCD9193200014A900EDC75D /* RNNBridgeManager.h */,
+				2DCD9194200014A900EDC75D /* RNNBridgeManager.m */,
 				268692801E5054F800E2C612 /* RNNStore.h */,
 				268692811E5054F800E2C612 /* RNNStore.m */,
 				7B4928061E70415400555040 /* RNNCommandsHandler.h */,
 				7BD721F31E2D3AA100724059 /* Bridge */,
 				7B1E4C4B1E2D173700C3A525 /* Controllers */,
 				263905881E4C6F440023D7D3 /* RNNSideMenu */,
+				507F43F11FF4FCD800D9425B /* HMSegmentControl */,
 				7B49FEBC1E95090800DEB3EA /* ReactNativeNavigationTests */,
 				D8AFADBE1BEE6F3F00A4592D /* Products */,
 				7B49FED01E950A7A00DEB3EA /* Frameworks */,
 			buildActionMask = 2147483647;
 			files = (
 				261F0E6A1E6F028A00989DE2 /* RNNNavigationStackManager.h in Headers */,
+				504AFE761FFFF1E00076E904 /* RNNNavigationOptions.h in Headers */,
+				504AFE771FFFF1E20076E904 /* RNNTopBarOptions.h in Headers */,
 				26916C981E4B9E7700D13680 /* RNNReactRootViewCreator.h in Headers */,
 				263905B01E4C6F440023D7D3 /* MMDrawerController+Subclass.h in Headers */,
 				E8AEDB4A1F5C0BAF000F5A6A /* RNNInteractivePopAnimator.h in Headers */,
 				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 */,
 				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 */,
 				268692821E5054F800E2C612 /* RNNStore.h in Headers */,
 				E8AEDB3C1F55A1C2000F5A6A /* RNNElementView.h in Headers */,
 				E8E518321F83B3E0000467AC /* RNNUtils.h in Headers */,
+				507F44201FFA8A8800D9425B /* RNNRootViewProtocol.h in Headers */,
 				263905CA1E4C6F440023D7D3 /* SidebarLuvocracyAnimation.h in Headers */,
 				263905B11E4C6F440023D7D3 /* MMDrawerController.h in Headers */,
-				50EB93411FE14A3E00BD8EEE /* RNNTabItemOptions.h in Headers */,
+				504AFE641FFE53070076E904 /* RNNOptions.h in Headers */,
 				263905B91E4C6F440023D7D3 /* RCCDrawerController.h in Headers */,
 				263905B31E4C6F440023D7D3 /* MMDrawerVisualState.h in Headers */,
 				E8A5CD621F49114F00E89D0D /* RNNElement.h in Headers */,
+				504AFE741FFFF0540076E904 /* RNNTopTabsOptions.h in Headers */,
 				E8E5182E1F83A48B000467AC /* RNNTransitionStateHolder.h in Headers */,
+				2DCD9195200014A900EDC75D /* RNNBridgeManager.h in Headers */,
 				7B1126A91E2D2B6C00F9B03B /* RNNControllerFactory.h in Headers */,
 				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;
 		};
 				7BBFE5441E25330E002A6182 /* RNNBridgeModule.m in Sources */,
 				261F0E651E6EC94900989DE2 /* RNNModalManager.m in Sources */,
 				E8A5CD631F49114F00E89D0D /* RNNElement.m in Sources */,
+				504AFE751FFFF0540076E904 /* RNNTopTabsOptions.m in Sources */,
 				7BEF0D1D1E43771B003E96B0 /* RNNLayoutNode.m in Sources */,
 				7BA500781E254908001B9E1B /* RNNSplashScreen.m in Sources */,
+				504AFE651FFE53070076E904 /* RNNOptions.m in Sources */,
 				263905BA1E4C6F440023D7D3 /* RCCDrawerController.m in Sources */,
 				50F5DFC21F407A8C001A00BC /* RNNTabBarController.m in Sources */,
 				263905BC1E4C6F440023D7D3 /* RCCDrawerHelper.m in Sources */,
 				2145452A1F4DC85F006E8DA1 /* RCTHelpers.m in Sources */,
+				2DCD9196200014A900EDC75D /* RNNBridgeManager.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 */,
-				50EB93421FE14A3E00BD8EEE /* RNNTabItemOptions.m in Sources */,
+				507F43F51FF4FCFE00D9425B /* HMSegmentedControl.m in Sources */,
+				507F43C61FF4F17C00D9425B /* RNNTopTabsViewController.m in Sources */,
+				50EB93421FE14A3E00BD8EEE /* RNNBottomTabOptions.m in Sources */,
 				E8367B811F7A8A4700675C05 /* VICMAImageView.m in Sources */,
-				A7626C011FC5796200492FB8 /* RNNTabBarOptions.m in Sources */,
+				A7626C011FC5796200492FB8 /* RNNBottomTabsOptions.m in Sources */,
 				263905AF1E4C6F440023D7D3 /* MMDrawerBarButtonItem.m in Sources */,
 				E8AEDB4B1F5C0BAF000F5A6A /* RNNInteractivePopAnimator.m in Sources */,
 				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

 
 @property (nonatomic, strong) RNNStore* store;
 @property (nonatomic, strong) RNNCommandsHandler* uut;
-@property (nonatomic, strong) RCTBridge* bridge;
 
 @end
 
 	[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];
 }
 
 
 -(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

 	[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 {

lib/ios/ReactNativeNavigationTests/RNNNavigationOptionsTest.m

 	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:@{@"topBar": @{@"backgroundColor" : @(0xff0000ff)}}];
 	XCTAssertTrue(options.topBar.backgroundColor);
 }
--(void)testReturnsNilWhenStyleDoesNotExist{
-	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:@{@"topBar": @{@"someColor" : @(0xff0000ff)}}];
-	XCTAssertNil(options.topBar.backgroundColor);
+-(void)testThrowsWhenStyleDoesNotExist{
+	XCTAssertThrows([[RNNNavigationOptions alloc] initWithDict:@{@"topBar": @{@"someColor" : @(0xff0000ff)}}]);
 }
 
 -(void)testChangeRNNNavigationOptionsDynamically{
 	NSDictionary* dynamicOptions = @{@"topBar": @{@"titleeeee" : @"hello"}};
 	XCTAssertThrows([options mergeWith:dynamicOptions]);
 }
+
 @end

lib/ios/ReactNativeNavigationTests/RNNRootViewControllerTest.m

 
 -(void)testTabBadge {
 	NSString* tabBadgeInput = @"5";
-	self.options.tabItem.badge = tabBadgeInput;
+	self.options.bottomTab.badge = tabBadgeInput;
 	__unused RNNTabBarController* vc = [[RNNTabBarController alloc] init];
 	NSMutableArray* controllers = [NSMutableArray new];
 	UITabBarItem* item = [[UITabBarItem alloc] initWithTitle:@"A Tab" image:nil tag:1];
 }
 
 -(void)testRightButtonsWithTitle_withoutStyle {
-	self.options.rightButtons = @[@{@"id": @"testId", @"title": @"test"}];
+	self.options.topBar.rightButtons = @[@{@"id": @"testId", @"title": @"test"}];
 	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
 	[self.uut viewWillAppear:false];
 	
 -(void)testRightButtonsWithTitle_withStyle {
 	NSNumber* inputColor = @(0xFFFF0000);
 	
-	self.options.rightButtons = @[@{@"id": @"testId", @"title": @"test", @"disabled": @true, @"buttonColor": inputColor, @"buttonFontSize": @22, @"buttonFontWeight": @"800"}];
+	self.options.topBar.rightButtons = @[@{@"id": @"testId", @"title": @"test", @"disabled": @true, @"buttonColor": inputColor, @"buttonFontSize": @22, @"buttonFontWeight": @"800"}];
 	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
 	[self.uut viewWillAppear:false];
 	
 
 
 -(void)testLeftButtonsWithTitle_withoutStyle {
-	self.options.leftButtons = @[@{@"id": @"testId", @"title": @"test"}];
+	self.options.topBar.leftButtons = @[@{@"id": @"testId", @"title": @"test"}];
 	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
 	[self.uut viewWillAppear:false];
 	
 -(void)testLeftButtonsWithTitle_withStyle {
 	NSNumber* inputColor = @(0xFFFF0000);
 	
-	self.options.leftButtons = @[@{@"id": @"testId", @"title": @"test", @"disabled": @true, @"buttonColor": inputColor, @"buttonFontSize": @22, @"buttonFontWeight": @"800"}];
+	self.options.topBar.leftButtons = @[@{@"id": @"testId", @"title": @"test", @"disabled": @true, @"buttonColor": inputColor, @"buttonFontSize": @22, @"buttonFontWeight": @"800"}];
 	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
 	[self.uut viewWillAppear:false];
 	

lib/src/params/containers/Container.js

    * @property {string} name The container's registered name
    * @property {Container[]} [topTabs]
    * @property {object} [passProps] props
+   * @property {object} [customTransition]
    * @property {Options} options
    */
   constructor(params) {
       this.topTabs = params.topTabs;
     }
     this.passProps = params.passProps;
+    this.customTransition = params.customTransition;
     this.options = params.options && new Options(params.options);
   }
 }

lib/src/params/options/Options.js

 const TopBar = require('./TopBar');
 const BottomTabs = require('./BottomTabs');
-const Button = require('./Button');
 const BottomTab = require('./BottomTab');
 const TopTabs = require('./TopTabs');
 
    * @property {options:BottomTab} [bottomTab]
    * @property {string} [orientation]
    * @property {options:TopTabs} [topTabs]
-   * @property {options:Button[]} [rightButtons]
-   * @property {options:Button[]} [leftButtons]
    */
   constructor(options) {
     this.topBar = options.topBar && new TopBar(options.topBar);
     this.bottomTabs = options.bottomTabs && new BottomTabs(options.bottomTabs);
     this.bottomTab = options.bottomTab && new BottomTab(options.bottomTab);
     this.orientation = options.orientation;
-    this.rightButtons = options.rightButtons && options.rightButtons.map((button) => new Button(button));
-    this.leftButtons = options.leftButtons && options.leftButtons.map((button) => new Button(button));
     this.sideMenu = options.sideMenu;
     this.backgroundImage = options.backgroundImage;
     this.rootBackgroundImage = options.rootBackgroundImage;

lib/src/params/options/Options.test.js

 const TAB_BAR = {};
 const TOP_BAR = {};
 const TAB_ITEM = {};
-const RIGHT_BUTTONS = [
-  {
-    id: 'myBtn',
-    testID: 'BTN',
-    title: 'My Button',
-    buttonColor: 'red'
-  }
-];
-const LEFT_BUTTONS = [
-  {
-    id: 'myBtn',
-    testID: 'BTN',
-    title: 'My Button',
-    buttonColor: 'red'
-  }
-];
 const TOP_TABS = {
   selectedTabColor: 'blue',
   unselectedTabColor: 'red'
   bottomTabs: TAB_BAR,
   bottomTab: TAB_ITEM,
   orientation: 'portrait',
-  rightButtons: RIGHT_BUTTONS,
-  leftButtons: LEFT_BUTTONS,
   topTabs: TOP_TABS
 };
 
     expect(uut.topBar).toBeInstanceOf(TopBar);
     expect(uut.bottomTab).toBeInstanceOf(BottomTab);
     expect(uut.orientation).toEqual('portrait');
-    expect(uut.rightButtons).toEqual(RIGHT_BUTTONS);
-    expect(uut.leftButtons).toEqual(LEFT_BUTTONS);
     expect(uut.topTabs).toBeInstanceOf(TopTabs);
   });
 });

lib/src/params/options/TopBar.js

+const Button = require('./Button');
+
 class TopBar {
   /**
    * @property {string} [title]
    * @property {boolean} [noBorder]
    * @property {boolean} [largeTitle]
    * @property {boolean} [drawUnder]
+   * @property {options:Button[]} [rightButtons]
+   * @property {options:Button[]} [leftButtons]
    */
   constructor(options) {
     this.title = options.title;
     this.largeTitle = options.largeTitle;
     this.testID = options.testID;
     this.drawUnder = options.drawUnder;
+    this.rightButtons = options.rightButtons && options.rightButtons.map((button) => new Button(button));
+    this.leftButtons = options.leftButtons && options.leftButtons.map((button) => new Button(button));
   }
 }
 

lib/src/params/options/TopBar.test.js

 const TopBar = require('./TopBar');
+const Button = require('./Button');
+
+const RIGHT_BUTTONS = [
+  {
+    id: 'myBtn',
+    testID: 'BTN',
+    title: 'My Button',
+    buttonColor: 'red'
+  }
+];
+const LEFT_BUTTONS = [
+  {
+    id: 'myBtn',
+    testID: 'BTN',
+    title: 'My Button',
+    buttonColor: 'red'
+  }
+];
 
 const TOP_BAR = {
   title: 'something',
   hidden: true,
   animateHide: true,
   hideOnScroll: true,
-  transparent: true
+  transparent: true,
+  rightButtons: RIGHT_BUTTONS,
+  leftButtons: LEFT_BUTTONS
 };
 
 describe('TopBar', () => {
     expect(uut.animateHide).toEqual(true);
     expect(uut.hideOnScroll).toEqual(true);
     expect(uut.transparent).toEqual(true);
+    expect(uut.leftButtons[0]).toBeInstanceOf(Button);
   });
 });

playground/src/containers/OptionsScreen.js

         hidden: false,
         textFontSize: 16,
         textFontFamily: 'HelveticaNeue-Italic',
-        testID: testIDs.TOP_BAR_ELEMENT
-      },
-      rightButtons: [{
-        id: BUTTON_ONE,
-        testID: BUTTON_ONE,
-        title: 'One',
-        buttonFontSize: 28,
-        buttonColor: 'red'
-      }],
-      leftButtons: [{
-        id: BUTTON_LEFT,
-        testID: BUTTON_LEFT,
-        icon: require('../../img/navicon_add.png'),
-        title: 'Left',
-        buttonColor: 'purple'
-      }]
+        testID: testIDs.TOP_BAR_ELEMENT,
+        rightButtons: [{
+          id: BUTTON_ONE,
+          testID: BUTTON_ONE,
+          title: 'One',
+          buttonFontSize: 28,
+          buttonColor: 'red'
+        }],
+        leftButtons: [{
+          id: BUTTON_LEFT,
+          testID: BUTTON_LEFT,
+          icon: require('../../img/navicon_add.png'),
+          title: 'Left',
+          buttonColor: 'purple'
+        }]
+      }
     };
   }
 
   onNavigationButtonPressed(id) {
     if (id === BUTTON_ONE) {
       Navigation.setOptions(this.props.containerId, {
-        rightButtons: [{
-          id: BUTTON_TWO,
-          testID: BUTTON_TWO,
-          title: 'Two',
-          icon: require('../../img/navicon_add.png'),
-          disableIconTint: true,
-          // disabled: true,
-          showAsAction: 'ifRoom',
-          buttonColor: 'green',
-          buttonFontSize: 28,
-          buttonFontWeight: '800'
-        }],
-        leftButtons: []
+        topBar: {
+          rightButtons: [{
+            id: BUTTON_TWO,
+            testID: BUTTON_TWO,
+            title: 'Two',
+            icon: require('../../img/navicon_add.png'),
+            disableIconTint: true,
+            // disabled: true,
+            showAsAction: 'ifRoom',
+            buttonColor: 'green',
+            buttonFontSize: 28,
+            buttonFontWeight: '800'
+          }],
+          leftButtons: []
+        }
       });
     } else if (id === BUTTON_TWO) {
       Navigation.setOptions(this.props.containerId, {
-        rightButtons: [{
-          id: BUTTON_ONE,
-          testID: BUTTON_ONE,
-          title: 'One',
-          buttonColor: 'red'
-        }],
-        leftButtons: [{
-          id: BUTTON_LEFT,
-          testID: BUTTON_LEFT,
-          icon: require('../../img/navicon_add.png'),
-          title: 'Left',
-          buttonColor: 'purple'
-        }]
+        topBar: {
+          rightButtons: [{
+            id: BUTTON_ONE,
+            testID: BUTTON_ONE,
+            title: 'One',
+            buttonColor: 'red'
+          }],
+          leftButtons: [{
+            id: BUTTON_LEFT,
+            testID: BUTTON_LEFT,
+            icon: require('../../img/navicon_add.png'),
+            title: 'Left',
+            buttonColor: 'purple'
+          }]
+        }
       });
     } else if (id === BUTTON_LEFT) {
       Navigation.pop(this.props.containerId);

playground/src/containers/WelcomeScreen.js

           options: {
             topTab: {
               title: 'Tab 2',
-              titleFontFamily: 'Dosis-Regular'
+              titleFontFamily: 'HelveticaNeue-Italic'
             }
           }
         },