Options resolving refactor (#4105)

* bind viewController to presenters using bindViewController

* Merge options to the specific provided layout

* Moved custom titleView creation to RNNRootViewController

* Moved default options to presenters, moved options applying to presenters, resolved options in RNNOptionsResolver

* Fixes merge options

* Fixes topBar transition on pop

* Prevent titleView creation when react titleView exists

* Fixed unit tests

* Options refactor WIP

* Detach applied options from DTO - WIP

* Added option types and option parsers

* Unit test passes

* Added presenters for each parent type

* Fixes unit tests

* Rename StringParam to Text, changed bottomTabs.drawBehind and topBar.drawBehind default to false

* set layout.backgroundColor default to white

* Added unit tests for RNNViewControllerPresenter

* Set layout.backgroundColor default nil

* Fixes buttons color missing options

* Fix unit test

* fix button color parsing

* Moved default options to presenters

* default options fixes

* Fixes e2e

* Fixes unit tests

* Resolve child options on childWillAppear

* Recrusively setDefaultOptions on rootViewController tree

* Fixes default values

* Fixes tests

lib/ios/Bool.h

+#import "Param.h"
+
+@interface Bool : Param
+
+- (BOOL)get;
+
+- (NSNumber *)getValue;
+
+- (BOOL)getWithDefaultValue:(BOOL)value;
+
+@end

lib/ios/Bool.m

+#import "Bool.h"
+
+@interface Bool()
+
+@property (nonatomic, retain) NSNumber* value;
+
+@end
+
+@implementation Bool
+
+- (BOOL)get {
+	return [self.value boolValue];
+}
+
+- (NSNumber *)getValue {
+	return self.value;
+}
+
+- (BOOL)getWithDefaultValue:(BOOL)defaultValue {
+	if (self.value) {
+		return [self.value boolValue];
+	} else {
+		return defaultValue;
+	}
+}
+
+@end

lib/ios/BoolParser.h

+#import <Foundation/Foundation.h>
+#import "Bool.h"
+
+@interface BoolParser : NSObject
+
++ (Bool *)parse:(NSDictionary *)json key:(NSString *)key;
+
+@end

lib/ios/BoolParser.m

+#import "BoolParser.h"
+#import "NullBool.h"
+
+@implementation BoolParser
+
++ (Bool *)parse:(NSDictionary *)json key:(NSString *)key {
+	return json[key] ? [[Bool alloc] initWithValue:json[key]] : [NullBool new];
+}
+
+@end

lib/ios/Color.h

+#import "Param.h"
+#import <UIKit/UIKit.h>
+
+@interface Color : Param
+
+- (instancetype)initWithValue:(UIColor *)value;
+
+- (UIColor *)get;
+
+- (UIColor *)getWithDefaultValue:(id)defaultValue;
+
+@end

lib/ios/Color.m

+#import "Color.h"
+
+@interface Color()
+
+@property (nonatomic, retain) UIColor* value;
+
+@end
+
+@implementation Color
+
+- (instancetype)initWithValue:(UIColor *)value {
+	return [super initWithValue:value];
+}
+
+- (UIColor *)get {
+	return self.value;
+}
+
+- (UIColor *)getWithDefaultValue:(id)defaultValue {
+	return [super getWithDefaultValue:defaultValue];
+}
+
+@end

lib/ios/ColorParser.h

+#import <Foundation/Foundation.h>
+#import "Color.h"
+
+@interface ColorParser : NSObject
+
++ (Color *)parse:(NSDictionary *)json key:(NSString *)key;
+
+@end

lib/ios/ColorParser.m

+#import "ColorParser.h"
+#import "NullColor.h"
+#import <React/RCTConvert.h>
+
+@implementation ColorParser
+
++ (Color *)parse:(NSDictionary *)json key:(NSString *)key {
+	return json[key] ? [[Color alloc] initWithValue:[RCTConvert UIColor:json[key]]] : [NullColor new];
+}
+
+@end

lib/ios/Dictionary.h

+#import "Param.h"
+
+@interface Dictionary : Param
+
+@end

lib/ios/Dictionary.m

+#import "Dictionary.h"
+
+@interface Dictionary()
+
+@property (nonatomic, retain) NSDictionary* value;
+
+@end
+
+@implementation Dictionary
+
+@end

lib/ios/DictionaryParser.h

+#import <Foundation/Foundation.h>
+#import "Dictionary.h"
+
+@interface DictionaryParser : NSObject
+
++ (Dictionary *)parse:(NSDictionary *)json key:(NSString *)key;
+
+@end

lib/ios/DictionaryParser.m

+#import "DictionaryParser.h"
+#import "NullDictionary.h"
+
+@implementation DictionaryParser
+
++ (Dictionary *)parse:(NSDictionary *)json key:(NSString *)key {
+	return json[key] ? [[Dictionary alloc] initWithValue:json[key]] : [NullDictionary new];
+}
+
+@end

lib/ios/Double.h

+#import "Param.h"
+
+@interface Double : Param
+
+- (double)get;
+
+- (double)getWithDefaultValue:(double)defaultValue;
+
+@end

lib/ios/Double.m

+#import "Double.h"
+
+@interface Double()
+
+@property (nonatomic, retain) NSNumber* value;
+
+@end
+
+@implementation Double
+
+- (double)get {
+	return [[super get] doubleValue];
+}
+
+- (double)getWithDefaultValue:(double)defaultValue {
+	if (self.value) {
+		return [self.value doubleValue];
+	} else if (defaultValue) {
+		return defaultValue;
+	}
+	
+	return 0;
+}
+
+@end

lib/ios/DoubleParser.h

+#import <Foundation/Foundation.h>
+#import "Double.h"
+
+@interface DoubleParser : NSObject
+
++ (Double *)parse:(NSDictionary *)json key:(NSString *)key;
+
+@end

lib/ios/DoubleParser.m

+#import "DoubleParser.h"
+#import "NullDouble.h"
+
+@implementation DoubleParser
+
++ (Double *)parse:(NSDictionary *)json key:(NSString *)key {
+	return json[key] ? [[Double alloc] initWithValue:json[key]] : [NullDouble new];
+}
+
+@end

lib/ios/Image.h

+#import "Param.h"
+#import <UIKit/UIKit.h>
+
+@interface Image : Param
+
+- (UIImage *)get;
+
+- (UIImage *)getWithDefaultValue:(UIImage *)defaultValue;
+
+@end

lib/ios/Image.m

+#import "Image.h"
+
+@interface Image()
+
+@property (nonatomic, retain) UIImage* value;
+
+@end
+
+@implementation Image
+
+- (UIImage *)get {
+	return self.value;
+}
+
+- (UIImage *)getWithDefaultValue:(UIImage *)defaultValue {
+	return [super getWithDefaultValue:defaultValue];
+}
+
+@end

lib/ios/ImageParser.h

+#import <Foundation/Foundation.h>
+#import "Image.h"
+
+@interface ImageParser : NSObject
+
++ (Image *)parse:(NSDictionary *)json key:(NSString *)key;
+
+@end

lib/ios/ImageParser.m

+#import "ImageParser.h"
+#import "NullImage.h"
+#import <React/RCTConvert.h>
+
+@implementation ImageParser
+
++ (Image *)parse:(NSDictionary *)json key:(NSString *)key {
+	return json[key] ? [[Image alloc] initWithValue:[RCTConvert UIImage:json[key]]] : [NullImage new];
+}
+
+@end

lib/ios/IntNumber.h

+#import "Param.h"
+
+@interface IntNumber : Param
+
+- (NSUInteger)get;
+
+- (NSUInteger)getWithDefaultValue:(NSUInteger)defaultValue;
+
+@end

lib/ios/IntNumber.m

+#import "IntNumber.h"
+
+@interface IntNumber()
+
+@property (nonatomic, retain) NSNumber* value;
+
+@end
+
+@implementation IntNumber
+
+- (NSUInteger)get {
+	return [[super get] unsignedIntegerValue];
+}
+
+- (NSUInteger)getWithDefaultValue:(NSUInteger)defaultValue {
+	if (self.value) {
+		return [self.value unsignedIntegerValue];
+	} else if (defaultValue) {
+		return defaultValue;
+	}
+	
+	return 0;
+}
+
+@end

lib/ios/IntNumberParser.h

+#import <Foundation/Foundation.h>
+#import "IntNumber.h"
+
+@interface IntNumberParser : NSObject
+
++ (IntNumber *)parse:(NSDictionary *)json key:(NSString *)key;
+
+@end

lib/ios/IntNumberParser.m

+#import "IntNumberParser.h"
+#import "NullIntNumber.h"
+
+@implementation IntNumberParser
+
++ (IntNumber *)parse:(NSDictionary *)json key:(NSString *)key {
+	return json[key] ? [[IntNumber alloc] initWithValue:json[key]] : [NullIntNumber new];
+}
+
+@end

lib/ios/NullBool.h

+#import "Bool.h"
+
+@interface NullBool : Bool
+
+@end

lib/ios/NullBool.m

+#import "NullBool.h"
+
+@implementation NullBool
+
+- (instancetype)init {
+	self = [super initWithValue:nil];
+	
+	return self;
+}
+
+@end

lib/ios/NullColor.h

+#import "Color.h"
+
+@interface NullColor : Color
+
+@end

lib/ios/NullColor.m

+#import "NullColor.h"
+
+@implementation NullColor
+
+- (instancetype)init {
+	self = [super initWithValue:nil];
+	return self;
+}
+
+@end

lib/ios/NullDictionary.h

+#import "Dictionary.h"
+
+@interface NullDictionary : Dictionary
+
+@end

lib/ios/NullDictionary.m

+#import "NullDictionary.h"
+
+@implementation NullDictionary
+
+- (instancetype)init {
+	self = [super initWithValue:nil];
+	return self;
+}
+
+@end

lib/ios/NullDouble.h

+#import "Double.h"
+
+@interface NullDouble : Double
+
+@end

lib/ios/NullDouble.m

+#import "NullDouble.h"
+
+@implementation NullDouble
+
+- (instancetype)init {
+	self = [super initWithValue:nil];
+	
+	return self;
+}
+
+@end

lib/ios/NullImage.h

+#import "Image.h"
+
+@interface NullImage : Image
+
+@end

lib/ios/NullImage.m

+#import "NullImage.h"
+
+@implementation NullImage
+
+- (instancetype)init {
+	self = [super initWithValue:nil];
+	
+	return self;
+}
+
+@end

lib/ios/NullIntNumber.h

+#import "IntNumber.h"
+
+@interface NullIntNumber : IntNumber
+
+@end

lib/ios/NullIntNumber.m

+#import "NullIntNumber.h"
+
+@implementation NullIntNumber
+
+- (instancetype)init {
+	self = [super initWithValue:nil];
+	
+	return self;
+}
+
+
+@end

lib/ios/NullNumber.h

+#import "Number.h"
+
+@interface NullNumber : Number
+
+@end

lib/ios/NullNumber.m

+#import "NullNumber.h"
+
+@implementation NullNumber
+
+- (instancetype)init {
+	self = [super initWithValue:nil];
+	return self;
+}
+
+@end

lib/ios/NullText.h

+#import "Text.h"
+
+@interface NullText : Text
+
+@end

lib/ios/NullText.m

+#import "NullText.h"
+
+@implementation NullText
+
+- (instancetype)init {
+	self = [super initWithValue:nil];
+	return self;
+}
+
+@end

lib/ios/Number.h

+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import "Param.h"
+
+@interface Number : Param
+
+- (NSNumber *)get;
+
+- (NSNumber *)getWithDefaultValue:(NSNumber *)defaultValue;
+
+@end

lib/ios/Number.m

+#import "Number.h"
+
+@interface Number()
+
+@property (nonatomic, retain) NSNumber* value;
+
+@end
+
+@implementation Number
+
+- (NSNumber *)get {
+	return [super get];
+}
+
+- (NSNumber *)getWithDefaultValue:(NSNumber *)defaultValue {
+	return [super getWithDefaultValue:defaultValue];
+}
+
+@end

lib/ios/NumberParser.h

+#import <Foundation/Foundation.h>
+#import "Number.h"
+
+@interface NumberParser : NSObject
+
++ (Number *)parse:(NSDictionary *)json key:(NSString *)key;
+
+@end

lib/ios/NumberParser.m

+#import "NumberParser.h"
+#import "NullNumber.h"
+
+@implementation NumberParser
+
++ (Number *)parse:(NSDictionary *)json key:(NSString *)key {
+	return json[key] ? [[Number alloc] initWithValue:json[key]] : [NullNumber new];
+}
+
+@end

lib/ios/Param.h

+#import <Foundation/Foundation.h>
+
+@interface Param : NSObject
+
+- (instancetype)initWithValue:(id)value;
+
+- (id)get;
+
+- (id)getWithDefaultValue:(id)defaultValue;
+
+- (BOOL)hasValue;
+
+- (void)consume;
+
+@end

lib/ios/Param.m

+#import "Param.h"
+
+@interface Param()
+
+@property (nonatomic, retain) id value;
+@property (nonatomic) BOOL consumed;
+
+@end
+
+@implementation Param
+
+- (instancetype)initWithValue:(id)value {
+	self = [super init];
+	
+	self.value = value;
+	
+	return self;
+}
+
+- (id)get {
+	if (!self.value) {
+		@throw [NSException exceptionWithName:@"Param get" reason:@"value does not exists" userInfo:nil];
+	}
+	
+	return self.value;
+}
+
+- (id)getWithDefaultValue:(id)defaultValue {
+	if (self.value) {
+		return self.value;
+	} else if (defaultValue) {
+		return defaultValue;
+	}
+	
+	return nil;
+}
+
+- (void)consume {
+	self.consumed = true;
+}
+
+- (BOOL)hasValue {
+	return self.value && !self.consumed;
+}
+
+@end

lib/ios/RNNAnimationOptions.m

 @implementation RNNAnimationOptions
 
 - (instancetype)initWithDict:(NSDictionary *)dict {
-	return [super initWithDict:dict];
+	self = [super init];
+	
+	self.animations = dict[@"animations"];
+	self.duration = dict[@"duration"];
+	self.springDamping = dict[@"springDamping"];
+	self.springVelocity = dict[@"springVelocity"];
+	
+	return self;
 }
 
 - (NSNumber *)duration {

lib/ios/RNNBackButtonOptions.h

 
 @interface RNNBackButtonOptions : RNNOptions
 
-@property (nonatomic, strong) NSDictionary* icon;
-@property (nonatomic, strong) NSNumber* visible;
-@property (nonatomic, strong) NSString* title;
-@property (nonatomic, strong) NSString* transition;
-@property (nonatomic, strong) NSNumber* showTitle;
-@property (nonatomic, strong) NSNumber* color;
+@property (nonatomic, strong) Image* icon;
+@property (nonatomic, strong) Text* title;
+@property (nonatomic, strong) Text* transition;
+@property (nonatomic, strong) Color* color;
+@property (nonatomic, strong) Bool* showTitle;
+@property (nonatomic, strong) Bool* visible;
 
 @end

lib/ios/RNNBackButtonOptions.m

 #import "RNNBackButtonOptions.h"
-#import "UIImage+tint.h"
 
 @implementation RNNBackButtonOptions
 
-- (void)applyOn:(UIViewController *)viewController {
-	if (self.visible) {
-		viewController.navigationItem.hidesBackButton = ![self.visible boolValue];
-	}
+- (instancetype)initWithDict:(NSDictionary *)dict {
+	self = [super init];
 	
-	[self applyOnNavigationController:viewController.navigationController];
-}
-
-- (void)applyOnNavigationController:(UINavigationController *)navigationController {
-  UIBarButtonItem *backItem = [[UIBarButtonItem alloc] init];
-  	UIImage* tintedIcon = self.tintedIconIfAvailable;
-	if (tintedIcon) {
-		backItem.image = tintedIcon;
-		[navigationController.navigationBar setBackIndicatorImage:[UIImage new]];	
-		[navigationController.navigationBar setBackIndicatorTransitionMaskImage:[UIImage new]];
-	}
-  
-	if (self.color) {
-	  	backItem.tintColor = [RCTConvert UIColor:self.color];
-	}
-  
-	if (self.showTitle && ![self.showTitle boolValue]) {
-	  	self.title = @"";
-	}
-  
-  	[self setBackItem:backItem onNavigationController:navigationController];
-}
-
-- (void)setBackItem:(UIBarButtonItem *)backItem onNavigationController:(UINavigationController *)navigationController {
-	NSArray *viewControllers = navigationController.viewControllers;
-	UIViewController *lastViewControllerInStack = [viewControllers lastObject];
-	backItem.title = self.title ? self.title : lastViewControllerInStack.navigationItem.title;
-	lastViewControllerInStack.navigationItem.backBarButtonItem = backItem;
-}
-
-- (UIImage *)tintedIconIfAvailable {
-	if (self.icon) {
-		UIImage *image = [RCTConvert UIImage:self.icon];
-	  	return self.color
-	  		? [[image withTintColor:[RCTConvert UIColor:self.color]] imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal]
-	  		: image;
-	}
-  
-  	return nil;
+	self.icon = [ImageParser parse:dict key:@"icon"];
+	self.title = [TextParser parse:dict key:@"title"];
+	self.transition = [TextParser parse:dict key:@"transition"];
+	self.color = [ColorParser parse:dict key:@"color"];
+	self.showTitle = [BoolParser parse:dict key:@"showTitle"];
+	self.visible = [BoolParser parse:dict key:@"visible"];
+	
+	return self;
 }
 
 @end

lib/ios/RNNBackgroundOptions.h

 
 @interface RNNBackgroundOptions : RNNOptions
 
-@property (nonatomic, strong) NSNumber* color;
-@property (nonatomic, strong) NSNumber* translucent;
-@property (nonatomic, strong) NSNumber* blur;
+@property (nonatomic, strong) Color* color;
+@property (nonatomic, strong) Bool* translucent;
+@property (nonatomic, strong) Bool* blur;
+@property (nonatomic, strong) Bool* clipToBounds;
 @property (nonatomic, strong) RNNComponentOptions* component;
-@property (nonatomic, strong) NSNumber* clipToBounds; 
 
 @end

lib/ios/RNNBackgroundOptions.m

 #import "RNNBackgroundOptions.h"
 
-extern const NSInteger BLUR_TOPBAR_TAG;
-const NSInteger TOP_BAR_TRANSPARENT_TAG = 78264803;
-
-@interface RNNBackgroundOptions()
-
-@property (nonatomic, strong) NSMutableDictionary* originalTopBarImages;
-
-@end
 
 @implementation RNNBackgroundOptions
 
-- (void)applyOnNavigationController:(UINavigationController *)navigationController {
-	if (self.translucent) {
-		navigationController.navigationBar.translucent = [self.translucent boolValue];
-	} else {
-		navigationController.navigationBar.translucent = NO;
-	}
+- (instancetype)initWithDict:(NSDictionary *)dict {
+	self = [super init];
 	
-	if ([self.blur boolValue]) {
-		if (![navigationController.navigationBar viewWithTag:BLUR_TOPBAR_TAG]) {
-
-			[navigationController.navigationBar setBackgroundImage:[UIImage new] forBarMetrics:UIBarMetricsDefault];
-			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, navigationController.navigationBar.frame.size.width, navigationController.navigationBar.frame.size.height + statusBarFrame.size.height);
-			blur.userInteractionEnabled = NO;
-			blur.tag = BLUR_TOPBAR_TAG;
-			[navigationController.navigationBar insertSubview:blur atIndex:0];
-			[navigationController.navigationBar sendSubviewToBack:blur];
-		}
-	} else {
-		UIView *blur = [navigationController.navigationBar viewWithTag:BLUR_TOPBAR_TAG];
-		if (blur) {
-			[navigationController.navigationBar setBackgroundImage: nil forBarMetrics:UIBarMetricsDefault];
-			navigationController.navigationBar.shadowImage = nil;
-			[blur removeFromSuperview];
-		}
-	}
+	self.color = [ColorParser parse:dict key:@"color"];
+	self.translucent = [BoolParser parse:dict key:@"translucent"];
+	self.blur = [BoolParser parse:dict key:@"blur"];
+	self.clipToBounds = [BoolParser parse:dict key:@"clipToBounds"];
+	self.component = [[RNNComponentOptions alloc] initWithDict:dict[@"component"]];
 	
-	if (self.color && ![self.color isKindOfClass:[NSNull class]]) {
-		UIColor* backgroundColor = [RCTConvert UIColor:self.color];
-
-		CGFloat bgColorAlpha = CGColorGetAlpha(backgroundColor.CGColor);
-
-		if (bgColorAlpha == 0.0) {
-			if (![navigationController.navigationBar viewWithTag:TOP_BAR_TRANSPARENT_TAG]){
-				[self storeOriginalTopBarImages:navigationController];
-				UIView *transparentView = [[UIView alloc] initWithFrame:CGRectZero];
-				transparentView.backgroundColor = [UIColor clearColor];
-				transparentView.tag = TOP_BAR_TRANSPARENT_TAG;
-				[navigationController.navigationBar insertSubview:transparentView atIndex:0];
-			}
-			navigationController.navigationBar.translucent = YES;
-			[navigationController.navigationBar setBackgroundColor:[UIColor clearColor]];
-			navigationController.navigationBar.shadowImage = [UIImage new];
-			[navigationController.navigationBar setBackgroundImage:[UIImage new] forBarMetrics:UIBarMetricsDefault];
-		} else {
-			navigationController.navigationBar.barTintColor = backgroundColor;
-			UIView *transparentView = [navigationController.navigationBar viewWithTag:TOP_BAR_TRANSPARENT_TAG];
-			if (transparentView){
-				[transparentView removeFromSuperview];
-				[navigationController.navigationBar setBackgroundImage:self.originalTopBarImages[@"backgroundImage"] forBarMetrics:UIBarMetricsDefault];
-				navigationController.navigationBar.shadowImage = self.originalTopBarImages[@"shadowImage"];
-				self.originalTopBarImages = nil;
-			}
-		}
-	} else {
-		UIView *transparentView = [navigationController.navigationBar viewWithTag:TOP_BAR_TRANSPARENT_TAG];
-		if (transparentView){
-			[transparentView removeFromSuperview];
-			[navigationController.navigationBar setBackgroundImage:self.originalTopBarImages[@"backgroundImage"] forBarMetrics:UIBarMetricsDefault];
-			navigationController.navigationBar.shadowImage = self.originalTopBarImages[@"shadowImage"];
-			self.originalTopBarImages = nil;
-		}
-	}
-
-	if (self.clipToBounds) {
-		navigationController.navigationBar.clipsToBounds = [self.clipToBounds boolValue];
-	} else {
-		navigationController.navigationBar.clipsToBounds = NO;
-	}
-}
-
-- (void)storeOriginalTopBarImages:(UINavigationController *)navigationController {
-	NSMutableDictionary *originalTopBarImages = [@{} mutableCopy];
-	UIImage *bgImage = [navigationController.navigationBar backgroundImageForBarMetrics:UIBarMetricsDefault];
-	if (bgImage != nil) {
-		originalTopBarImages[@"backgroundImage"] = bgImage;
-	}
-	UIImage *shadowImage = navigationController.navigationBar.shadowImage;
-	if (shadowImage != nil) {
-		originalTopBarImages[@"shadowImage"] = shadowImage;
-	}
-	self.originalTopBarImages = originalTopBarImages;
+	return self;
 }
 
 @end

lib/ios/RNNBasePresenter.h

-#import <Foundation/Foundation.h>
 #import "RNNNavigationOptions.h"
 
 @interface RNNBasePresenter : NSObject
 
-- (void)present:(RNNNavigationOptions *)options onViewControllerDidLoad:(UIViewController *)viewController;
-- (void)present:(RNNNavigationOptions *)options onViewControllerWillAppear:(UIViewController *)viewController;
+@property (nonatomic, weak) id bindedViewController;
+
+@property (nonatomic, retain) RNNNavigationOptions* defaultOptions;
+
+- (void)bindViewController:(UIViewController *)bindedViewController;
+
+- (void)applyOptions:(RNNNavigationOptions *)initialOptions;
+
+- (void)applyOptionsOnWillMoveToParentViewController:(RNNNavigationOptions *)options;
+
+- (void)mergeOptions:(RNNNavigationOptions *)options;
+
+- (void)setDefaultOptions:(RNNNavigationOptions *)defaultOptions;
 
 @end

lib/ios/RNNBasePresenter.m

 #import "RNNBasePresenter.h"
+#import "RNNBottomTabPresenter.h"
+
+@interface RNNBasePresenter()
+
+@property (nonatomic, strong) RNNBottomTabPresenter* bottomTabPresenter;
+
+@end
 
 @implementation RNNBasePresenter
 
-- (void)present:(RNNNavigationOptions *)options onViewControllerWillAppear:(UIViewController *)viewController {
-	[options applyOn:viewController];
+- (instancetype)init {
+	self = [super init];
+	self.bottomTabPresenter = [[RNNBottomTabPresenter alloc] init];
+	return self;
+}
+
+- (void)bindViewController:(UIViewController *)bindedViewController {
+	_bindedViewController = bindedViewController;
+	[self.bottomTabPresenter bindViewController:bindedViewController];
+}
+
+- (void)applyOptionsOnWillMoveToParentViewController:(RNNNavigationOptions *)options {
+	[self.bottomTabPresenter applyOptions:options];
+}
+
+- (void)applyOptions:(RNNNavigationOptions *)initialOptions {
+	[self.bottomTabPresenter applyOptions:initialOptions];
+}
+
+- (void)mergeOptions:(RNNNavigationOptions *)options {
+	
 }
 
-- (void)present:(RNNNavigationOptions *)options onViewControllerDidLoad:(UIViewController *)viewController {
-	[options applyOn:viewController];
+- (void)setDefaultOptions:(RNNNavigationOptions *)defaultOptions {
+	_defaultOptions = defaultOptions;
+	[self.bottomTabPresenter setDefaultOptions:defaultOptions];
 }
 
 @end

lib/ios/RNNBottomTabOptions.h

 @interface RNNBottomTabOptions : RNNOptions
 
 @property (nonatomic) NSUInteger tag;
-@property (nonatomic, strong) NSString* text;
-@property (nonatomic, strong) NSString* badge;
-@property (nonatomic, strong) NSDictionary* badgeColor;
-@property (nonatomic, strong) NSString* testID;
-@property (nonatomic, strong) NSNumber* visible;
-@property (nonatomic, strong) NSDictionary* icon;
-@property (nonatomic, strong) NSDictionary* selectedIcon;
-@property (nonatomic, strong) NSDictionary* iconColor;
-@property (nonatomic, strong) NSDictionary* selectedIconColor;
-@property (nonatomic, strong) NSDictionary* textColor;
-@property (nonatomic, strong) NSDictionary* selectedTextColor;
-@property (nonatomic, strong) NSString* fontFamily;
-@property (nonatomic, strong) NSNumber* fontSize;
+@property (nonatomic, strong) Text* text;
+@property (nonatomic, strong) Text* badge;
+@property (nonatomic, strong) Text* fontFamily;
+@property (nonatomic, strong) Text* testID;
+@property (nonatomic, strong) Color* badgeColor;
+@property (nonatomic, strong) Image* icon;
+@property (nonatomic, strong) Image* selectedIcon;
+@property (nonatomic, strong) Color* iconColor;
+@property (nonatomic, strong) Color* selectedIconColor;
+@property (nonatomic, strong) Color* selectedTextColor;
+@property (nonatomic, strong) Dictionary* iconInsets;
+@property (nonatomic, strong) Color* textColor;
+@property (nonatomic, strong) Number* fontSize;
+@property (nonatomic, strong) Bool* visible;
 
-@property (nonatomic, strong) NSDictionary* iconInsets;
 
 @end

lib/ios/RNNBottomTabOptions.m

 #import "RNNBottomTabOptions.h"
 #import "UIImage+tint.h"
+#import "UITabBarController+RNNOptions.h"
+#import "UIViewController+RNNOptions.h"
+#import "RNNTabBarItemCreator.h"
 
 @implementation RNNBottomTabOptions
 
--(instancetype)initWithDict:(NSDictionary *)tabItemDict {
+- (instancetype)initWithDict:(NSDictionary *)dict {
 	self = [super init];
 	
-	[self mergeWith:tabItemDict];
-	self.tag = [tabItemDict[@"tag"] integerValue];
+	self.text = [TextParser parse:dict key:@"text"];
+	self.badge = [TextParser parse:dict key:@"badge"];
+	self.fontFamily = [TextParser parse:dict key:@"fontFamily"];
+	self.testID = [TextParser parse:dict key:@"testID"];
 	
-	return self;
-}
-
-- (void)applyOn:(UIViewController *)viewController {
-	UIViewController* topViewController = [self getTabControllerFirstChild:viewController];
-	if (self.text || self.icon || self.selectedIcon) {
-		UITabBarItem* tabItem = topViewController.tabBarItem;
-		
-		tabItem.selectedImage = [self getSelectedIconImage];
-		tabItem.image = [self getIconImage];
-		tabItem.title = self.text;
-		tabItem.tag = self.tag;
-		tabItem.accessibilityIdentifier = self.testID;
-		
-		if (self.iconInsets && ![self.iconInsets isKindOfClass:[NSNull class]]) {
-			id topInset = self.iconInsets[@"top"];
-			id leftInset = self.iconInsets[@"left"];
-			id bottomInset = self.iconInsets[@"bottom"];
-			id rightInset = self.iconInsets[@"right"];
-			
-			CGFloat top = topInset != (id)[NSNull null] ? [RCTConvert CGFloat:topInset] : 0;
-			CGFloat left = topInset != (id)[NSNull null] ? [RCTConvert CGFloat:leftInset] : 0;
-			CGFloat bottom = topInset != (id)[NSNull null] ? [RCTConvert CGFloat:bottomInset] : 0;
-			CGFloat right = topInset != (id)[NSNull null] ? [RCTConvert CGFloat:rightInset] : 0;
-			
-			tabItem.imageInsets = UIEdgeInsetsMake(top, left, bottom, right);
-		}
-		
-		[self appendTitleAttributes:tabItem];
-		
-		[topViewController setTabBarItem:tabItem];
-	}
-	
-	if (self.badge) {
-		NSString *badge = nil;
-		if (self.badge != nil && ![self.badge isEqual:[NSNull null]]) {
-			badge = [RCTConvert NSString:self.badge];
-		}
-		UITabBarItem *tabBarItem = topViewController.tabBarItem;
-		tabBarItem.badgeValue = badge;
-		if (self.badgeColor) {
-			tabBarItem.badgeColor = [RCTConvert UIColor:self.badgeColor];
-		}
-		
-		if ([self.badge isEqual:[NSNull null]] || [self.badge isEqualToString:@""]) {
-			tabBarItem.badgeValue = nil;
-		}
-	}
-	
-	if (self.visible) {
-		[topViewController.tabBarController setSelectedIndex:[viewController.tabBarController.viewControllers indexOfObject:viewController]];
-	}
-	
-	[self resetOptions];
-}
-
-- (UIImage *)getIconImage {
-	return [self getIconImageWithTint:self.iconColor];
-}
-
-- (UIImage *)getSelectedIconImage {
-	if (self.selectedIcon) {
-		if (self.selectedIconColor) {
-			return [[[RCTConvert UIImage:self.selectedIcon] withTintColor:[RCTConvert UIColor:self.selectedIconColor]] imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
-		} else {
-			return [[RCTConvert UIImage:self.selectedIcon] imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
-		}
-	} else {
-		return [self getIconImageWithTint:self.selectedIconColor];
-	}
-	
-	return nil;
-}
-
-- (UIImage *)getIconImageWithTint:(NSDictionary *)tintColor {
-	if (self.icon) {
-		if (tintColor) {
-			return [[[RCTConvert UIImage:self.icon] withTintColor:[RCTConvert UIColor:tintColor]] imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
-		} else {
-			return [[RCTConvert UIImage:self.icon] imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
-		}
-	}
-	
-	return nil;
-}
-
-- (void)appendTitleAttributes:(UITabBarItem *)tabItem {
-	NSMutableDictionary* selectedAttributes = [NSMutableDictionary dictionaryWithDictionary:[tabItem titleTextAttributesForState:UIControlStateNormal]];
-	if (self.selectedTextColor) {
-		selectedAttributes[NSForegroundColorAttributeName] = [RCTConvert UIColor:self.selectedTextColor];
-	} else {
-		selectedAttributes[NSForegroundColorAttributeName] = [UIColor blackColor];
-	}
-	
-	selectedAttributes[NSFontAttributeName] = [self tabBarTextFont];
-	[tabItem setTitleTextAttributes:selectedAttributes forState:UIControlStateSelected];
 	
+	self.badgeColor = [ColorParser parse:dict key:@"badgeColor"];
+	self.icon = [ImageParser parse:dict key:@"icon"];
+	self.selectedIcon = [ImageParser parse:dict key:@"selectedIcon"];
+	self.iconColor = [ColorParser parse:dict key:@"iconColor"];
+	self.selectedIconColor = [ColorParser parse:dict key:@"selectedIconColor"];
+	self.selectedTextColor = [ColorParser parse:dict key:@"selectedTextColor"];
+	self.iconInsets = [DictionaryParser parse:dict key:@"iconInsets"];
 	
-	NSMutableDictionary* normalAttributes = [NSMutableDictionary dictionaryWithDictionary:[tabItem titleTextAttributesForState:UIControlStateNormal]];
-	if (self.textColor) {
-		normalAttributes[NSForegroundColorAttributeName] = [RCTConvert UIColor:self.textColor];
-	} else {
-		normalAttributes[NSForegroundColorAttributeName] = [UIColor blackColor];
-	}
+	self.textColor = [ColorParser parse:dict key:@"textColor"];
+	self.fontSize = [NumberParser parse:dict key:@"fontSize"];
+	self.visible = [BoolParser parse:dict key:@"visible"];
 	
-	normalAttributes[NSFontAttributeName] = [self tabBarTextFont];
-	[tabItem setTitleTextAttributes:normalAttributes forState:UIControlStateNormal];
-}
-
-
--(UIFont *)tabBarTextFont {
-	if (self.fontFamily) {
-		return [UIFont fontWithName:self.fontFamily size:self.tabBarTextFontSizeValue];
-	}
-	else if (self.fontSize) {
-		return [UIFont systemFontOfSize:self.tabBarTextFontSizeValue];
-	}
-	else {
-		return nil;
-	}
-}
-
--(CGFloat)tabBarTextFontSizeValue {
-	return self.fontSize ? [self.fontSize floatValue] : 10;
-}
-
-- (UIViewController *)getTabControllerFirstChild:(UIViewController *)viewController {
-	while (viewController != nil) {
-		if ([viewController.parentViewController isKindOfClass:[UITabBarController class]] || !viewController.parentViewController) {
-			return viewController;
-		}
-		
-		viewController = viewController.parentViewController;
-	}
-	
-	return nil;
+	return self;
 }
 
 -(void)resetOptions {

lib/ios/RNNBottomTabPresenter.h

+#import "RNNBasePresenter.h"
+
+@interface RNNBottomTabPresenter : NSObject
+
+- (void)bindViewController:(UIViewController *)viewController;
+
+- (void)applyOptions:(RNNNavigationOptions *)options;
+
+- (void)setDefaultOptions:(RNNNavigationOptions *)defaultOptions;
+
+@end

lib/ios/RNNBottomTabPresenter.m

+#import "RNNBottomTabPresenter.h"
+#import "RNNTabBarItemCreator.h"
+
+@interface RNNBottomTabPresenter()
+
+@property (nonatomic, weak) id bindedViewController;
+@property (nonatomic, retain) RNNNavigationOptions* defaultOptions;
+
+@end
+
+@implementation RNNBottomTabPresenter
+
+- (void)bindViewController:(UIViewController *)viewController {
+	_bindedViewController = viewController;
+}
+
+- (void)applyOptions:(RNNNavigationOptions *)options {
+	UIViewController* viewController = self.bindedViewController;
+	if ((options.bottomTab.text.hasValue || options.bottomTab.icon.hasValue || options.bottomTab.selectedIcon.hasValue)) {
+		RNNNavigationOptions* withDefault = (RNNNavigationOptions *)[[options copy] withDefault:self.defaultOptions];
+		UITabBarItem* tabItem = [RNNTabBarItemCreator updateTabBarItem:viewController.tabBarItem bottomTabOptions:withDefault.bottomTab];
+		viewController.tabBarItem = tabItem;
+		[options.bottomTab.text consume];
+		[options.bottomTab.icon consume];
+		[options.bottomTab.selectedIcon consume];
+	}
+}
+
+- (void)setDefaultOptions:(RNNNavigationOptions *)defaultOptions {
+	_defaultOptions = defaultOptions;
+}
+
+@end

lib/ios/RNNBottomTabsOptions.h

 
 @interface RNNBottomTabsOptions : RNNOptions
 
-@property (nonatomic, strong) NSNumber* visible;
-@property (nonatomic, strong) NSNumber* currentTabIndex;
-@property (nonatomic, strong) NSString* testID;
-@property (nonatomic, strong) NSNumber* drawBehind;
-@property (nonatomic, strong) NSString* currentTabId;
+@property (nonatomic, strong) Bool* visible;
+@property (nonatomic, strong) IntNumber* currentTabIndex;
+@property (nonatomic, strong) Bool* drawBehind;
+@property (nonatomic, strong) Color* tabColor;
+@property (nonatomic, strong) Color* selectedTabColor;
+@property (nonatomic, strong) Bool* translucent;
+@property (nonatomic, strong) Bool* hideShadow;
+@property (nonatomic, strong) Color* backgroundColor;
+@property (nonatomic, strong) Number* fontSize;
 
-@property (nonatomic, strong) NSNumber* tabColor;
-@property (nonatomic, strong) NSNumber* selectedTabColor;
-@property (nonatomic, strong) NSString* barStyle;
-@property (nonatomic, strong) NSNumber* translucent;
-@property (nonatomic, strong) NSNumber* hideShadow;
-@property (nonatomic, strong) NSNumber* backgroundColor;
-@property (nonatomic, strong) NSString* fontFamily;
-@property (nonatomic, strong) NSNumber* fontSize;
+@property (nonatomic, strong) Text* testID;
+@property (nonatomic, strong) Text* currentTabId;
+@property (nonatomic, strong) Text* barStyle;
+@property (nonatomic, strong) Text* fontFamily;
 
 @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]];
-	}
+- (instancetype)initWithDict:(NSDictionary *)dict {
+	self = [super init];
 	
-	if (self.currentTabId) {
-		[(RNNTabBarController*)viewController.tabBarController setSelectedIndexByComponentID:self.currentTabId];
-	}
+	self.visible = [BoolParser parse:dict key:@"visible"];
+	self.currentTabIndex = [IntNumberParser parse:dict key:@"currentTabIndex"];
+	self.drawBehind = [BoolParser parse:dict key:@"drawBehind"];
+	self.tabColor = [ColorParser parse:dict key:@"tabColor"];
+	self.selectedTabColor = [ColorParser parse:dict key:@"selectedTabColor"];
+	self.translucent = [BoolParser parse:dict key:@"translucent"];
+	self.hideShadow = [BoolParser parse:dict key:@"hideShadow"];
+	self.backgroundColor = [ColorParser parse:dict key:@"backgroundColor"];
+	self.fontSize = [NumberParser parse:dict key:@"fontSize"];
 	
-	if (self.testID) {
-		viewController.tabBarController.tabBar.accessibilityIdentifier = self.testID;
-	}
+	self.testID = [TextParser parse:dict key:@"testID"];
+	self.currentTabId = [TextParser parse:dict key:@"currentTabId"];
+	self.barStyle = [TextParser parse:dict key:@"barStyle"];
+	self.fontFamily = [TextParser parse:dict key:@"fontFamily"];
 	
-	if (self.drawBehind) {
-		if ([self.drawBehind boolValue]) {
-			[viewController setExtendedLayoutIncludesOpaqueBars:YES];
-			viewController.edgesForExtendedLayout |= UIRectEdgeBottom;
-		} else {
-			[viewController setExtendedLayoutIncludesOpaqueBars:NO];
-			viewController.edgesForExtendedLayout &= ~UIRectEdgeBottom;
-		}
-	}
-	
-	if (self.backgroundColor) {
-		viewController.tabBarController.tabBar.barTintColor = [RCTConvert UIColor:self.backgroundColor];
-	} else {
-		viewController.tabBarController.tabBar.barTintColor = nil;
-	}
-	
-	if (self.barStyle) {
-		viewController.tabBarController.tabBar.barStyle = [RCTConvert UIBarStyle:self.barStyle];
-	} else {
-		viewController.tabBarController.tabBar.barStyle = UIBarStyleDefault;
-	}
-
-	if (self.translucent) {
-		viewController.tabBarController.tabBar.translucent = [self.translucent boolValue];
-	} else {
-		viewController.tabBarController.tabBar.translucent = NO;
-	}
-	
-	if (self.hideShadow) {
-		viewController.tabBarController.tabBar.clipsToBounds = [self.hideShadow boolValue];
-	}
-
-	[self resetOptions];
-}
-
--(UIFont *)tabBarTextFont {
-	if (self.fontFamily) {
-		return [UIFont fontWithName:self.fontFamily size:self.tabBarTextFontSizeValue];
-	}
-	else if (self.fontSize) {
-		return [UIFont systemFontOfSize:self.tabBarTextFontSizeValue];
-	}
-	else {
-		return nil;
-	}
-}
-
--(CGFloat)tabBarTextFontSizeValue {
-	return self.fontSize ? [self.fontSize floatValue] : 10;
-}
-
-- (void)resetOptions {
-	self.currentTabId = nil;
-	self.currentTabIndex = nil;
+	return self;
 }
 
 @end

lib/ios/RNNButtonOptions.h

 
 @interface RNNButtonOptions : RNNOptions
 
-@property (nonatomic, strong) NSString* fontFamily;
-@property (nonatomic, strong) NSNumber* fontSize;
-@property (nonatomic, strong) NSNumber* color;
-@property (nonatomic, strong) NSNumber* disabledColor;
-@property (nonatomic, strong) NSNumber* icon;
-@property (nonatomic, strong) NSString* text;
-@property (nonatomic, strong) NSNumber* enabled;
+@property (nonatomic, strong) Text* fontFamily;
+@property (nonatomic, strong) Text* text;
+@property (nonatomic, strong) Number* fontSize;
+@property (nonatomic, strong) Color* color;
+@property (nonatomic, strong) Color* disabledColor;
+@property (nonatomic, strong) Image* icon;
+@property (nonatomic, strong) Bool* enabled;
 
 @end

lib/ios/RNNButtonOptions.m

 
 @implementation RNNButtonOptions
 
+- (instancetype)initWithDict:(NSDictionary *)dict {
+	self = [super init];
+	
+	self.fontFamily = [TextParser parse:dict key:@"fontFamily"];
+	self.text = [TextParser parse:dict key:@"text"];
+	self.fontSize = [NumberParser parse:dict key:@"fontSize"];
+	self.color = [ColorParser parse:dict key:@"color"];
+	self.disabledColor = [ColorParser parse:dict key:@"disabledColor"];
+	self.icon = [ImageParser parse:dict key:@"icon"];
+	self.enabled = [BoolParser parse:dict key:@"enabled"];
+	
+
+	return self;
+}
+
 @end

lib/ios/RNNCommandsHandler.m

 #import "RNNElementFinder.h"
 #import "React/RCTUIManager.h"
 #import "RNNErrorHandler.h"
+#import "RNNDefaultOptionsHelper.h"
 
 static NSString* const setRoot	= @"setRoot";
 static NSString* const setStackRoot	= @"setStackRoot";
 	[self assertReady];
 	
 	UIViewController<RNNLayoutProtocol>* vc = (UIViewController<RNNLayoutProtocol>*)[_store findComponentForId:componentId];
-	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:mergeOptions];
+	RNNNavigationOptions* newOptions = [[RNNNavigationOptions alloc] initWithDict:mergeOptions];
 	if ([vc conformsToProtocol:@protocol(RNNLayoutProtocol)] || [vc isKindOfClass:[RNNRootViewController class]]) {
 		[CATransaction begin];
 		[CATransaction setCompletionBlock:completion];
 		
-		[vc.getLeafViewController mergeAndPresentOptions:options];
-		
+		[vc.options overrideOptions:newOptions];
+		[vc mergeOptions:newOptions];
+
 		[CATransaction commit];
 	}
 }
 
 - (void)setDefaultOptions:(NSDictionary*)optionsDict completion:(RNNTransitionCompletionBlock)completion {
 	[self assertReady];
-	[_controllerFactory.optionsManager setDefaultOptionsDict:optionsDict];
+	RNNNavigationOptions* defaultOptions = [[RNNNavigationOptions alloc] initWithDict:optionsDict];
+	[_controllerFactory setDefaultOptions:defaultOptions];
+	
+	UIViewController *rootViewController = UIApplication.sharedApplication.delegate.window.rootViewController;
+	[RNNDefaultOptionsHelper recrusivelySetDefaultOptions:defaultOptions onRootViewController:rootViewController];
+	
+	completion();
 }
 
 - (void)push:(NSString*)componentId layout:(NSDictionary*)layout completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection {
 	[self assertReady];
 	
 	UIViewController<RNNParentProtocol> *newVC = [_controllerFactory createLayoutAndSaveToStore:layout];
-	RNNNavigationOptions* options = [newVC getLeafViewController].options;
+	RNNNavigationOptions* options = [newVC getCurrentChild].options;
 	UIViewController *fromVC = [_store findComponentForId:componentId];
 	__weak typeof(RNNEventEmitter*) weakEventEmitter = _eventEmitter;
 	[_stackManager setStackRoot:newVC fromViewController:fromVC animated:options.animations.setStackRoot.enable completion:^{
 	} rejection:rejection];
 }
 
-- (void)pop:(NSString*)componentId mergeOptions:(NSDictionary*)options completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection {
+- (void)pop:(NSString*)componentId mergeOptions:(NSDictionary*)mergeOptions completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection {
 	[self assertReady];
 	
 	RNNRootViewController *vc = (RNNRootViewController*)[_store findComponentForId:componentId];
-	[vc.options mergeWith:options];
+	RNNNavigationOptions *options = [[RNNNavigationOptions alloc] initWithDict:mergeOptions];
+	[vc.options overrideOptions:options];
 	
 	UINavigationController *nvc = vc.navigationController;
 	
 	}];
 }
 
-- (void)popTo:(NSString*)componentId mergeOptions:(NSDictionary *)options completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection {
+- (void)popTo:(NSString*)componentId mergeOptions:(NSDictionary *)mergeOptions completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection {
 	[self assertReady];
 	RNNRootViewController *vc = (RNNRootViewController*)[_store findComponentForId:componentId];
-	[vc.options mergeWith:options];
+	RNNNavigationOptions *options = [[RNNNavigationOptions alloc] initWithDict:mergeOptions];
+	[vc.options overrideOptions:options];
 	
 	[_stackManager popTo:vc animated:vc.options.animations.pop.enable completion:^(NSArray *poppedViewControllers) {
 		[_eventEmitter sendOnNavigationCommandCompletion:popTo params:@{@"componentId": componentId}];
 	} rejection:rejection];
 }
 
-- (void)popToRoot:(NSString*)componentId mergeOptions:(NSDictionary *)options completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection {
+- (void)popToRoot:(NSString*)componentId mergeOptions:(NSDictionary *)mergeOptions completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection {
 	[self assertReady];
 	RNNRootViewController *vc = (RNNRootViewController*)[_store findComponentForId:componentId];
-	[vc.options mergeWith:options];
+	RNNNavigationOptions *options = [[RNNNavigationOptions alloc] initWithDict:mergeOptions];
+	[vc.options overrideOptions:options];
 	
 	[CATransaction begin];
 	[CATransaction setCompletionBlock:^{
 	
 	UIViewController<RNNParentProtocol> *newVc = [_controllerFactory createLayoutAndSaveToStore:layout];
 	
-	[newVc.getLeafViewController waitForReactViewRender:newVc.getLeafViewController.options.animations.showModal.waitForRender perform:^{
-		[_modalManager showModal:newVc animated:newVc.getLeafViewController.options.animations.showModal.enable hasCustomAnimation:newVc.getLeafViewController.options.animations.showModal.hasCustomAnimation completion:^(NSString *componentId) {
+	[newVc.getCurrentChild waitForReactViewRender:newVc.getCurrentChild.options.animations.showModal.waitForRender perform:^{
+		[_modalManager showModal:newVc animated:newVc.getCurrentChild.options.animations.showModal.enable hasCustomAnimation:newVc.getCurrentChild.options.animations.showModal.hasCustomAnimation completion:^(NSString *componentId) {
 			[_eventEmitter sendOnNavigationCommandCompletion:showModal params:@{@"layout": layout}];
 			completion(componentId);
 		}];
 	}];
 }
 
-- (void)dismissModal:(NSString*)componentId mergeOptions:(NSDictionary *)options completion:(RNNTransitionCompletionBlock)completion {
+- (void)dismissModal:(NSString*)componentId mergeOptions:(NSDictionary *)mergeOptions completion:(RNNTransitionCompletionBlock)completion {
 	[self assertReady];
 	
 	[CATransaction begin];
 		[_eventEmitter sendOnNavigationCommandCompletion:dismissModal params:@{@"componentId": componentId}];
 	}];
 	UIViewController<RNNParentProtocol> *modalToDismiss = (UIViewController<RNNParentProtocol>*)[_store findComponentForId:componentId];
-	[modalToDismiss.getLeafViewController.options mergeWith:options];
+	RNNNavigationOptions *options = [[RNNNavigationOptions alloc] initWithDict:mergeOptions];
+	[modalToDismiss.getCurrentChild.options overrideOptions:options];
 	
 	[self removePopedViewControllers:modalToDismiss.navigationController.viewControllers];
 	

lib/ios/RNNComponentOptions.h

 
 @interface RNNComponentOptions : RNNOptions
 
-@property (nonatomic, strong) NSString* name;
-@property (nonatomic, strong) NSString* componentId;
-@property (nonatomic, strong) NSString* alignment;
+@property (nonatomic, strong) Text* name;
+@property (nonatomic, strong) Text* componentId;
+@property (nonatomic, strong) Text* alignment;
 
 @end

lib/ios/RNNComponentOptions.m

 
 @implementation RNNComponentOptions
 
+- (instancetype)initWithDict:(NSDictionary *)dict {
+	self = [super init];
+	
+	self.name = [TextParser parse:dict key:@"name"];
+	self.componentId = [TextParser parse:dict key:@"componentId"];
+	self.alignment = [TextParser parse:dict key:@"alignment"];
+	
+	return self;
+}
+
 @end

lib/ios/RNNControllerFactory.h

 #import "RNNStore.h"
 #import "RNNEventEmitter.h"
 #import "RNNParentProtocol.h"
-#import "RNNOptionsManager.h"
 
 @interface RNNControllerFactory : NSObject
 
 -(UIViewController<RNNParentProtocol, UIViewControllerPreviewingDelegate> *)createLayoutAndSaveToStore:(NSDictionary*)layout;
 
 @property (nonatomic, strong) RNNEventEmitter *eventEmitter;
-@property (nonatomic, strong) RNNOptionsManager *optionsManager;
+
+@property (nonatomic, strong) RNNNavigationOptions* defaultOptions;
 
 @end

lib/ios/RNNControllerFactory.m

 #import "RNNTabBarController.h"
 #import "RNNTopTabsViewController.h"
 #import "RNNLayoutInfo.h"
-#import "RNNOptionsManager.h"
+#import "RNNRootViewController.h"
+#import "UIViewController+SideMenuController.h"
 #import "RNNViewControllerPresenter.h"
+#import "RNNNavigationControllerPresenter.h"
 #import "RNNTabBarPresenter.h"
-#import "RNNRootViewController.h"
+#import "RNNSideMenuPresenter.h"
 
 @implementation RNNControllerFactory {
 	id<RNNRootViewCreator> _creator;
 	_store = store;
 	_eventEmitter = eventEmitter;
 	_bridge = bridge;
-	_optionsManager = [RNNOptionsManager new];
 	
 	return self;
 }
 
 - (UIViewController<RNNParentProtocol> *)createComponent:(RNNLayoutNode*)node {
 	RNNLayoutInfo* layoutInfo = [[RNNLayoutInfo alloc] initWithNode:node];
-	RNNNavigationOptions* options = [_optionsManager createOptions:node.data[@"options"]];
+	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:node.data[@"options"]];;
 	
 	RNNViewControllerPresenter* presenter = [[RNNViewControllerPresenter alloc] init];
+	[presenter setDefaultOptions:_defaultOptions];
+	
 	RNNRootViewController* component = [[RNNRootViewController alloc] initWithLayoutInfo:layoutInfo rootViewCreator:_creator eventEmitter:_eventEmitter presenter:presenter options:options];
 	
 	if (!component.isExternalViewController) {
 
 - (UIViewController<RNNParentProtocol> *)createExternalComponent:(RNNLayoutNode*)node {
 	RNNLayoutInfo* layoutInfo = [[RNNLayoutInfo alloc] initWithNode:node];
-	RNNNavigationOptions* options = [_optionsManager createOptions:node.data[@"options"]];
+	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:node.data[@"options"]];;
 	RNNViewControllerPresenter* presenter = [[RNNViewControllerPresenter alloc] init];
-
+	[presenter setDefaultOptions:_defaultOptions];
+	
 	UIViewController* externalVC = [_store getExternalComponent:layoutInfo bridge:_bridge];
 	
 	RNNRootViewController* component = [[RNNRootViewController alloc] initExternalComponentWithLayoutInfo:layoutInfo eventEmitter:_eventEmitter presenter:presenter options:options];
 
 - (UIViewController<RNNParentProtocol> *)createStack:(RNNLayoutNode*)node {
 	RNNNavigationControllerPresenter* presenter = [[RNNNavigationControllerPresenter alloc] init];
+	[presenter setDefaultOptions:_defaultOptions];
+	
 	RNNLayoutInfo* layoutInfo = [[RNNLayoutInfo alloc] initWithNode:node];
-	RNNNavigationOptions* options = [_optionsManager createOptions:node.data[@"options"]];
+	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:node.data[@"options"]];;
 	
 	NSArray *childViewControllers = [self extractChildrenViewControllersFromNode:node];
 	
 
 -(UIViewController<RNNParentProtocol> *)createTabs:(RNNLayoutNode*)node {
 	RNNLayoutInfo* layoutInfo = [[RNNLayoutInfo alloc] initWithNode:node];
-	RNNNavigationOptions* options = [_optionsManager createOptions:node.data[@"options"]];
+	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:node.data[@"options"]];;
 	RNNTabBarPresenter* presenter = [[RNNTabBarPresenter alloc] init];
+	[presenter setDefaultOptions:_defaultOptions];
 
 	NSArray *childViewControllers = [self extractChildrenViewControllersFromNode:node];
 	
 
 - (UIViewController<RNNParentProtocol> *)createTopTabs:(RNNLayoutNode*)node {
 	RNNLayoutInfo* layoutInfo = [[RNNLayoutInfo alloc] initWithNode:node];
-	RNNNavigationOptions* options = [_optionsManager createOptions:node.data[@"options"]];
-	RNNBasePresenter* presenter = [[RNNBasePresenter alloc] init];
+	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:node.data[@"options"]];;
+	RNNViewControllerPresenter* presenter = [[RNNViewControllerPresenter alloc] init];
+	[presenter setDefaultOptions:_defaultOptions];
 
 	NSArray *childViewControllers = [self extractChildrenViewControllersFromNode:node];
 	
 
 - (UIViewController<RNNParentProtocol> *)createSideMenu:(RNNLayoutNode*)node {
 	RNNLayoutInfo* layoutInfo = [[RNNLayoutInfo alloc] initWithNode:node];
-	RNNNavigationOptions* options = [_optionsManager createOptions:node.data[@"options"]];
-	RNNBasePresenter* presenter = [[RNNBasePresenter alloc] init];
+	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:node.data[@"options"]];;
+	RNNSideMenuPresenter* presenter = [[RNNSideMenuPresenter alloc] init];
+	[presenter setDefaultOptions:_defaultOptions];
 
 	NSArray *childViewControllers = [self extractChildrenViewControllersFromNode:node];
 	
 - (UIViewController<RNNParentProtocol> *)createSideMenuChild:(RNNLayoutNode*)node type:(RNNSideMenuChildType)type {
 	UIViewController<RNNParentProtocol>* childVc = [self fromTree:node.children[0]];
 	RNNLayoutInfo* layoutInfo = [[RNNLayoutInfo alloc] initWithNode:node];
-	RNNNavigationOptions* options = [_optionsManager createOptions:node.data[@"options"]];
+	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:node.data[@"options"]];;
 
-	RNNSideMenuChildVC *sideMenuChild = [[RNNSideMenuChildVC alloc] initWithLayoutInfo:layoutInfo childViewControllers:@[childVc] options:options presenter:[[RNNBasePresenter alloc] init] type:type];
+	RNNSideMenuChildVC *sideMenuChild = [[RNNSideMenuChildVC alloc] initWithLayoutInfo:layoutInfo childViewControllers:@[childVc] options:options presenter:[[RNNViewControllerPresenter alloc] init] type:type];
 	
 	return sideMenuChild;
 }
 
 - (UIViewController<RNNParentProtocol> *)createSplitView:(RNNLayoutNode*)node {
 	RNNLayoutInfo* layoutInfo = [[RNNLayoutInfo alloc] initWithNode:node];
-	RNNNavigationOptions* options = [_optionsManager createOptions:node.data[@"options"]];
-	RNNBasePresenter* presenter = [[RNNBasePresenter alloc] init];
+	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:node.data[@"options"]];;
+	RNNViewControllerPresenter* presenter = [[RNNViewControllerPresenter alloc] init];
+	[presenter setDefaultOptions:_defaultOptions];
 
 	NSArray *childViewControllers = [self extractChildrenViewControllersFromNode:node];
 

lib/ios/RNNDefaultOptionsHelper.h

+#import <Foundation/Foundation.h>
+#import "RNNLayoutProtocol.h"
+
+@interface RNNDefaultOptionsHelper : NSObject
+
++ (void)recrusivelySetDefaultOptions:(RNNNavigationOptions *)defaultOptions onRootViewController:(UIViewController *)rootViewController;
+
+@end

lib/ios/RNNDefaultOptionsHelper.m

+#import "RNNDefaultOptionsHelper.h"
+
+@implementation RNNDefaultOptionsHelper
+
++ (void)recrusivelySetDefaultOptions:(RNNNavigationOptions *)defaultOptions onRootViewController:(UIViewController *)rootViewController {
+	if ([rootViewController conformsToProtocol:@protocol(RNNLayoutProtocol)])
+		[((UIViewController<RNNLayoutProtocol> *)rootViewController).presenter setDefaultOptions:defaultOptions];
+	
+	for (UIViewController<RNNLayoutProtocol>* childViewController in rootViewController.childViewControllers) {
+		if ([childViewController conformsToProtocol:@protocol(RNNLayoutProtocol)]) {
+			[childViewController.presenter setDefaultOptions:defaultOptions];
+		}
+		
+		[self recrusivelySetDefaultOptions:defaultOptions onRootViewController:childViewController];
+	}
+}
+
+@end

lib/ios/RNNFontAttributesCreator.h

+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+@interface RNNFontAttributesCreator : NSObject
+
++ (NSDictionary *)createFontAttributesWithFontFamily:(NSString *)fontFamily fontSize:(NSNumber *)fontSize color:(UIColor *)color;
+
+@end

lib/ios/RNNFontAttributesCreator.m

+#import "RNNFontAttributesCreator.h"
+
+@implementation RNNFontAttributesCreator
+
++ (NSDictionary *)createFontAttributesWithFontFamily:(NSString *)fontFamily fontSize:(NSNumber *)fontSize color:(UIColor *)color {
+	NSMutableDictionary* titleTextAttributes = [NSMutableDictionary new];
+	if (fontFamily || fontSize || color) {
+		if (color) {
+			titleTextAttributes[NSForegroundColorAttributeName] = color;
+		}
+		if (fontFamily){
+			if (fontSize) {
+				titleTextAttributes[NSFontAttributeName] = [UIFont fontWithName:fontFamily size:[fontSize floatValue]];
+			} else {
+				titleTextAttributes[NSFontAttributeName] = [UIFont fontWithName:fontFamily size:17];
+			}
+		} else if (fontSize) {
+			titleTextAttributes[NSFontAttributeName] = [UIFont systemFontOfSize:[fontSize floatValue]];
+		}
+	}
+	
+	return titleTextAttributes;
+}
+
+@end

lib/ios/RNNLargeTitleOptions.h

 
 @interface RNNLargeTitleOptions : RNNOptions
 
-@property (nonatomic, strong) NSNumber* fontSize;
-@property (nonatomic, strong) NSNumber* visible;
-@property (nonatomic, strong) NSNumber* color;
-@property (nonatomic, strong) NSString* fontFamily;
+@property (nonatomic, strong) Number* fontSize;
+@property (nonatomic, strong) Bool* visible;
+@property (nonatomic, strong) Color* color;
+@property (nonatomic, strong) Text* fontFamily;
+
 @end

lib/ios/RNNLargeTitleOptions.m

 #import "RNNLargeTitleOptions.h"
-#import "RNNTitleViewHelper.h"
-
 
 @implementation RNNLargeTitleOptions
 
-- (void)applyOn:(UIViewController *)viewController {
-
-	if (@available(iOS 11.0, *)) {
-		
-		viewController.navigationItem.largeTitleDisplayMode = UINavigationItemLargeTitleDisplayModeNever;
+- (instancetype)initWithDict:(NSDictionary *)dict {
+	self = [super init];
 	
-		if ([self.visible boolValue]){
-			viewController.navigationController.navigationBar.prefersLargeTitles = YES;
-			viewController.navigationItem.largeTitleDisplayMode = UINavigationItemLargeTitleDisplayModeAlways;
-		} else {
-			viewController.navigationController.navigationBar.prefersLargeTitles = NO;
-		}
-		
-		NSDictionary* fontAttributes = [self fontAttributes];
-		viewController.navigationController.navigationBar.largeTitleTextAttributes = fontAttributes;
-	}
-}
-
-- (NSDictionary *)fontAttributes {
-	NSMutableDictionary* navigationBarTitleTextAttributes = [NSMutableDictionary new];
-	if (self.fontFamily || self.fontSize || self.color) {
-		if (self.color) {
-			navigationBarTitleTextAttributes[NSForegroundColorAttributeName] = [RCTConvert UIColor:self.color];
-		}
-		if (self.fontFamily){
-			if (self.fontSize) {
-				navigationBarTitleTextAttributes[NSFontAttributeName] = [UIFont fontWithName:self.fontFamily size:[self.fontSize floatValue]];
-			} else {
-				navigationBarTitleTextAttributes[NSFontAttributeName] = [UIFont fontWithName:self.fontFamily size:20];
-			}
-		} else if (self.fontSize) {
-			navigationBarTitleTextAttributes[NSFontAttributeName] = [UIFont systemFontOfSize:[self.fontSize floatValue]];
-		}
-	}
+	self.fontSize = [NumberParser parse:dict key:@"fontSize"];
+	self.visible = [BoolParser parse:dict key:@"visible"];
+	self.color = [ColorParser parse:dict key:@"color"];
+	self.fontFamily = [TextParser parse:dict key:@"fontFamily"];
 	
-	return navigationBarTitleTextAttributes;
-}
-
-- (NSNumber *)fontSize {
-	return _fontSize ? _fontSize : nil;
+	return self;
 }
 
 @end

lib/ios/RNNLayoutInfo.h

 #import <Foundation/Foundation.h>
-#import "RNNOptionsManager.h"
 #import "RNNLayoutNode.h"
 
 @interface RNNLayoutInfo : NSObject

lib/ios/RNNLayoutOptions.h

 
 @interface RNNLayoutOptions : RNNOptions
 
-@property (nonatomic, strong) NSNumber* backgroundColor;
+@property (nonatomic, strong) Color* backgroundColor;
 @property (nonatomic, strong) id orientation;
 
 - (UIInterfaceOrientationMask)supportedOrientations;

lib/ios/RNNLayoutOptions.m

 #import "RNNLayoutOptions.h"
 #import <React/RCTConvert.h>
+#import "UIViewController+RNNOptions.h"
 
 @implementation RNNLayoutOptions
 
-- (void)applyOn:(UIViewController *)viewController {
-	if (self.backgroundColor) {
-		UIColor* screenColor = [RCTConvert UIColor:self.backgroundColor];
-		viewController.view.backgroundColor = screenColor;
-	}
+- (instancetype)initWithDict:(NSDictionary *)dict {
+	self = [super init];
+	
+	self.backgroundColor = [ColorParser parse:dict key:@"backgroundColor"];
+	self.orientation = dict[@"orientation"];
+	
+	return self;
 }
 
 - (UIInterfaceOrientationMask)supportedOrientations {

lib/ios/RNNLayoutProtocol.h

 #import "RNNLayoutInfo.h"
-#import "RNNBasePresenter.h"
+#import "RNNViewControllerPresenter.h"
 #import "RNNLeafProtocol.h"
 
 @protocol RNNLayoutProtocol <NSObject, UINavigationControllerDelegate, UIViewControllerTransitioningDelegate, UISplitViewControllerDelegate>
 @property (nonatomic, retain) RNNLayoutInfo* layoutInfo;
 @property (nonatomic, strong) RNNNavigationOptions* options;
 
-- (UIViewController<RNNLeafProtocol, RNNLayoutProtocol> *)getLeafViewController;
+- (UIViewController<RNNLeafProtocol, RNNLayoutProtocol> *)getCurrentChild;
+
+- (void)mergeOptions:(RNNNavigationOptions *)options;
+
+- (RNNNavigationOptions *)resolveOptions;
 
 @end

lib/ios/RNNLeafProtocol.h

 
 - (void)bindViewController:(UIViewController *)viewController;
 
-- (void)mergeAndPresentOptions:(RNNNavigationOptions *)newOptions;
-
 @end

lib/ios/RNNModalManager.m

 
 -(void)removePendingNextModalIfOnTop:(RNNTransitionCompletionBlock)completion {
 	UIViewController<RNNParentProtocol> *modalToDismiss = [_pendingModalIdsToDismiss lastObject];
-	RNNNavigationOptions* options = modalToDismiss.getLeafViewController.options;
+	RNNNavigationOptions* options = modalToDismiss.getCurrentChild.options;
 
 	if(!modalToDismiss) {
 		return;
 	} else {
 		[modalToDismiss.view removeFromSuperview];
 		modalToDismiss.view = nil;
-		modalToDismiss.getLeafViewController.options.animations.dismissModal.enable = NO;
+		modalToDismiss.getCurrentChild.options.animations.dismissModal.enable = NO;
 		[self dismissedModal:modalToDismiss];
 		
 		if (completion) {

lib/ios/RNNNavigationButtons.m

 		@throw [NSException exceptionWithName:@"NSInvalidArgumentException" reason:[@"button id is not specified " stringByAppendingString:title] userInfo:nil];
 	}
 	
-	UIImage* iconImage = nil;
-	id icon = [self getValue:dictionary[@"icon"] withDefault:defaultStyle.icon];
-	if (icon) {
-		iconImage = [RCTConvert UIImage:icon];
+	UIImage* defaultIcon = [defaultStyle.icon getWithDefaultValue:nil];
+	UIImage* iconImage = [self getValue:dictionary[@"icon"] withDefault:defaultIcon];
+	if (![iconImage isKindOfClass:[UIImage class]]) {
+		iconImage = [RCTConvert UIImage:iconImage];
 	}
 	
 	RNNUIBarButtonItem *barButtonItem;
 	barButtonItem.target = self.viewController;
 	barButtonItem.action = @selector(onButtonPress:);
 	
-	NSNumber *enabled = [self getValue:dictionary[@"enabled"] withDefault:defaultStyle.enabled];
+	NSNumber *enabled = [self getValue:dictionary[@"enabled"] withDefault:defaultStyle.enabled.getValue];
 	BOOL enabledBool = enabled ? [enabled boolValue] : YES;
 	[barButtonItem setEnabled:enabledBool];
 	
 	NSMutableDictionary* textAttributes = [[NSMutableDictionary alloc] init];
 	NSMutableDictionary* disabledTextAttributes = [[NSMutableDictionary alloc] init];
 	
-	UIColor* color = [self color:dictionary[@"color"] defaultColor:defaultStyle.color];
-	UIColor* disabledColor = [self color:dictionary[@"disabledColor"] defaultColor:defaultStyle.disabledColor];
+	UIColor* color = [self color:[RCTConvert UIColor:dictionary[@"color"]] defaultColor:[defaultStyle.color getWithDefaultValue:nil]];
+	UIColor* disabledColor = [self color:[RCTConvert UIColor:dictionary[@"disabledColor"]] defaultColor:[defaultStyle.disabledColor getWithDefaultValue:nil]];
 	if (!enabledBool && disabledColor) {
 		color = disabledColor;
 		[disabledTextAttributes setObject:disabledColor forKey:NSForegroundColorAttributeName];
 		[barButtonItem setImage:[[iconImage withTintColor:color] imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal]];
 	}
 	
-	NSNumber* fontSize = [self fontSize:dictionary[@"fontSize"] defaultFontSize:defaultStyle.fontSize];
-	NSString* fontFamily = [self fontFamily:dictionary[@"fontFamily"] defaultFontFamily:defaultStyle.fontFamily];
+	NSNumber* fontSize = [self fontSize:dictionary[@"fontSize"] defaultFontSize:[defaultStyle.fontSize getWithDefaultValue:nil]];
+	NSString* fontFamily = [self fontFamily:dictionary[@"fontFamily"] defaultFontFamily:[defaultStyle.fontFamily getWithDefaultValue:nil]];
 	UIFont *font = nil;
 	if (fontFamily) {
 		font = [UIFont fontWithName:fontFamily size:[fontSize floatValue]];
 	return barButtonItem;
 }
 
-- (UIColor *)color:(NSNumber *)color defaultColor:(NSNumber *)defaultColor {
+- (UIColor *)color:(UIColor *)color defaultColor:(UIColor *)defaultColor {
 	if (color) {
-		return [RCTConvert UIColor:color];
+		return color;
 	} else if (defaultColor) {
-		return [RCTConvert UIColor:defaultColor];
+		return defaultColor;
 	}
 	
 	return nil;

lib/ios/RNNNavigationController.h

 #import <UIKit/UIKit.h>
 #import "RNNParentProtocol.h"
 #import "RNNNavigationControllerPresenter.h"
+#import "UINavigationController+RNNOptions.h"
 
 @interface RNNNavigationController : UINavigationController <RNNParentProtocol>
 
 @property (nonatomic, retain) RNNNavigationControllerPresenter* presenter;
 @property (nonatomic, strong) RNNNavigationOptions* options;
 
+- (void)setTopBarBackgroundColor:(UIColor *)backgroundColor;
+
 @end

lib/ios/RNNNavigationController.m

 #import "RNNModalAnimation.h"
 #import "RNNRootViewController.h"
 
+const NSInteger TOP_BAR_TRANSPARENT_TAG = 78264803;
+
+@interface RNNNavigationController()
+
+@property (nonatomic, strong) NSMutableDictionary* originalTopBarImages;
+
+@end
+
 @implementation RNNNavigationController
 
 - (instancetype)initWithLayoutInfo:(RNNLayoutInfo *)layoutInfo childViewControllers:(NSArray *)childViewControllers options:(RNNNavigationOptions *)options presenter:(RNNNavigationControllerPresenter *)presenter {
 	self = [super init];
 
 	self.presenter = presenter;
+	[self.presenter bindViewController:self];
 	self.options = options;
+	
 	self.layoutInfo = layoutInfo;
 	
 	[self setViewControllers:childViewControllers];
 	return self;
 }
 
+- (void)willMoveToParentViewController:(UIViewController *)parent {
+	if (parent) {
+		[_presenter applyOptionsOnWillMoveToParentViewController:self.options];
+	}
+}
+
+- (void)onChildWillAppear {
+	[_presenter applyOptions:self.resolveOptions];
+	[((UIViewController<RNNParentProtocol> *)self.parentViewController) onChildWillAppear];
+}
+
+- (RNNNavigationOptions *)resolveOptions {
+	return (RNNNavigationOptions *)[self.getCurrentChild.resolveOptions.copy mergeOptions:self.options];
+}
+
+- (void)mergeOptions:(RNNNavigationOptions *)options {
+	[_presenter mergeOptions:options];
+	[((UIViewController<RNNLayoutProtocol> *)self.parentViewController) mergeOptions:options];
+}
+
+- (UITabBarItem *)tabBarItem {
+	return super.tabBarItem ? super.tabBarItem : self.viewControllers.lastObject.tabBarItem;
+}
+
 - (UIInterfaceOrientationMask)supportedInterfaceOrientations {
 	return self.viewControllers.lastObject.supportedInterfaceOrientations;
 }
 }
 
 - (UIStatusBarStyle)preferredStatusBarStyle {
-	return self.getLeafViewController.preferredStatusBarStyle;
+	return self.getCurrentChild.preferredStatusBarStyle;
 }
 
 - (UIModalPresentationStyle)modalPresentationStyle {
-	return self.getLeafViewController.modalPresentationStyle;
+	return self.getCurrentChild.modalPresentationStyle;
 }
 
 - (UIViewController *)popViewControllerAnimated:(BOOL)animated {
 		UIViewController *controller = self.viewControllers[self.viewControllers.count - 2];
 		if ([controller isKindOfClass:[RNNRootViewController class]]) {
 			RNNRootViewController *rnnController = (RNNRootViewController *)controller;
-			[rnnController.presenter present:rnnController.options onViewControllerDidLoad:rnnController];
+			[self.presenter applyOptions:rnnController.options];
 		}
 	}
 	
 }
 
 - (nullable id <UIViewControllerAnimatedTransitioning>)animationControllerForPresentedController:(UIViewController *)presented presentingController:(UIViewController *)presenting sourceController:(UIViewController *)source {
-	return [[RNNModalAnimation alloc] initWithScreenTransition:self.getLeafViewController.options.animations.showModal isDismiss:NO];
+	return [[RNNModalAnimation alloc] initWithScreenTransition:self.getCurrentChild.options.animations.showModal isDismiss:NO];
 }
 
 - (id<UIViewControllerAnimatedTransitioning>)animationControllerForDismissedController:(UIViewController *)dismissed {
-	return [[RNNModalAnimation alloc] initWithScreenTransition:self.getLeafViewController.options.animations.dismissModal isDismiss:YES];
+	return [[RNNModalAnimation alloc] initWithScreenTransition:self.getCurrentChild.options.animations.dismissModal isDismiss:YES];
 }
 
-- (UIViewController *)getLeafViewController {
+- (UIViewController *)getCurrentChild {
 	return ((UIViewController<RNNParentProtocol>*)self.topViewController);
 }
 
 	return self.topViewController;
 }
 
-- (void)willMoveToParentViewController:(UIViewController *)parent {
-	[_presenter present:self.options onViewControllerDidLoad:self];
+- (void)setTopBarBackgroundColor:(UIColor *)backgroundColor {
+	if (backgroundColor) {
+		CGFloat bgColorAlpha = CGColorGetAlpha(backgroundColor.CGColor);
+		
+		if (bgColorAlpha == 0.0) {
+			if (![self.navigationBar viewWithTag:TOP_BAR_TRANSPARENT_TAG]){
+				[self storeOriginalTopBarImages:self];
+				UIView *transparentView = [[UIView alloc] initWithFrame:CGRectZero];
+				transparentView.backgroundColor = [UIColor clearColor];
+				transparentView.tag = TOP_BAR_TRANSPARENT_TAG;
+				[self.navigationBar insertSubview:transparentView atIndex:0];
+			}
+			self.navigationBar.translucent = YES;
+			[self.navigationBar setBackgroundColor:[UIColor clearColor]];
+			self.navigationBar.shadowImage = [UIImage new];
+			[self.navigationBar setBackgroundImage:[UIImage new] forBarMetrics:UIBarMetricsDefault];
+		} else {
+			self.navigationBar.barTintColor = backgroundColor;
+			UIView *transparentView = [self.navigationBar viewWithTag:TOP_BAR_TRANSPARENT_TAG];
+			if (transparentView){
+				[transparentView removeFromSuperview];
+				[self.navigationBar setBackgroundImage:self.originalTopBarImages[@"backgroundImage"] forBarMetrics:UIBarMetricsDefault];
+				self.navigationBar.shadowImage = self.originalTopBarImages[@"shadowImage"];
+				self.originalTopBarImages = nil;
+			}
+		}
+	} else {
+		UIView *transparentView = [self.navigationBar viewWithTag:TOP_BAR_TRANSPARENT_TAG];
+		if (transparentView){
+			[transparentView removeFromSuperview];
+			[self.navigationBar setBackgroundImage:self.originalTopBarImages[@"backgroundImage"] forBarMetrics:UIBarMetricsDefault];
+			self.navigationBar.shadowImage = self.originalTopBarImages[@"shadowImage"];
+			self.originalTopBarImages = nil;
+		}
+	}
+}
+
+- (void)storeOriginalTopBarImages:(UINavigationController *)navigationController {
+	NSMutableDictionary *originalTopBarImages = [@{} mutableCopy];
+	UIImage *bgImage = [navigationController.navigationBar backgroundImageForBarMetrics:UIBarMetricsDefault];
+	if (bgImage != nil) {
+		originalTopBarImages[@"backgroundImage"] = bgImage;
+	}
+	UIImage *shadowImage = navigationController.navigationBar.shadowImage;
+	if (shadowImage != nil) {
+		originalTopBarImages[@"shadowImage"] = shadowImage;
+	}
+	self.originalTopBarImages = originalTopBarImages;
 }
 
 

lib/ios/RNNNavigationControllerPresenter.h

-#import <Foundation/Foundation.h>
 #import "RNNBasePresenter.h"
 
 @interface RNNNavigationControllerPresenter : RNNBasePresenter
 
-
 @end

lib/ios/RNNNavigationControllerPresenter.m

 #import "RNNNavigationControllerPresenter.h"
+#import "UINavigationController+RNNOptions.h"
+#import "RNNNavigationController.h"
 
 @implementation RNNNavigationControllerPresenter
 
-- (void)present:(RNNNavigationOptions *)options onViewControllerDidLoad:(UINavigationController *)navigationController {
-	[options applyOnNavigationController:navigationController];
+- (void)applyOptions:(RNNNavigationOptions *)initialOptions {
+	[super applyOptions:initialOptions];
+	RNNNavigationOptions* options = [initialOptions withDefault:self.defaultOptions];
+	
+	
+	RNNNavigationController* navigationController = self.bindedViewController;
+
+	[navigationController rnn_setInteractivePopGestureEnabled:[options.popGesture getWithDefaultValue:YES]];
+	[navigationController rnn_setRootBackgroundImage:[options.rootBackgroundImage getWithDefaultValue:nil]];
+	[navigationController rnn_setNavigationBarTestID:[options.topBar.testID getWithDefaultValue:nil]];
+	[navigationController rnn_setNavigationBarVisible:[options.topBar.visible getWithDefaultValue:YES] animated:[options.topBar.animate getWithDefaultValue:YES]];
+	[navigationController rnn_hideBarsOnScroll:[options.topBar.hideOnScroll getWithDefaultValue:NO]];
+	[navigationController rnn_setNavigationBarNoBorder:[options.topBar.noBorder getWithDefaultValue:NO]];
+	[navigationController rnn_setBarStyle:[RCTConvert UIBarStyle:[options.topBar.barStyle getWithDefaultValue:@"default"]]];
+	[navigationController rnn_setNavigationBarTranslucent:[options.topBar.background.translucent getWithDefaultValue:NO]];
+	[navigationController rnn_setNavigationBarClipsToBounds:[options.topBar.background.clipToBounds getWithDefaultValue:NO]];
+	[navigationController rnn_setNavigationBarBlur:[options.topBar.background.blur getWithDefaultValue:NO]];
+	[navigationController setTopBarBackgroundColor:[options.topBar.background.color getWithDefaultValue:nil]];
+	[navigationController rnn_setNavigationBarLargeTitleVisible:[options.topBar.largeTitle.visible getWithDefaultValue:NO]];
+	[navigationController rnn_setNavigationBarLargeTitleFontFamily:[options.topBar.largeTitle.fontFamily getWithDefaultValue:nil] fontSize:[options.topBar.largeTitle.fontSize getWithDefaultValue:nil] color:[options.topBar.largeTitle.color getWithDefaultValue:nil]];
+	[navigationController rnn_setBackButtonIcon:[options.topBar.backButton.icon getWithDefaultValue:nil] withColor:[options.topBar.backButton.color getWithDefaultValue:nil] title:[options.topBar.backButton.showTitle getWithDefaultValue:YES] ? [options.topBar.backButton.title getWithDefaultValue:nil] : @""];
+	[navigationController rnn_setNavigationBarFontFamily:[options.topBar.title.fontFamily getWithDefaultValue:nil] fontSize:[options.topBar.title.fontSize getWithDefaultValue:nil] color:[options.topBar.title.color getWithDefaultValue:nil]];
 }
 
-- (void)present:(RNNNavigationOptions *)options onViewControllerWillAppear:(UINavigationController *)navigationController {
-	[options applyOnNavigationController:navigationController];
+- (void)mergeOptions:(RNNNavigationOptions *)options {
+	[super mergeOptions:options];
+	
+	RNNNavigationController* navigationController = self.bindedViewController;
+	RNNNavigationOptions* withDefault = (RNNNavigationOptions *)[options withDefault:self.defaultOptions];
+	
+	if (options.popGesture.hasValue) {
+		[navigationController rnn_setInteractivePopGestureEnabled:withDefault.popGesture.get];
+	}
+	
+	if (options.rootBackgroundImage.hasValue) {
+		[navigationController rnn_setRootBackgroundImage:withDefault.rootBackgroundImage.get];
+	}
+	
+	if (options.topBar.testID.hasValue) {
+		[navigationController rnn_setNavigationBarTestID:withDefault.topBar.testID.get];
+	}
+	
+	if (options.topBar.visible.hasValue) {
+		[navigationController rnn_setNavigationBarVisible:withDefault.topBar.visible.get animated:[withDefault.topBar.animate getWithDefaultValue:YES]];
+	}
+	
+	if (options.topBar.hideOnScroll.hasValue) {
+		[navigationController rnn_hideBarsOnScroll:[withDefault.topBar.hideOnScroll get]];
+	}
+	
+	if (options.topBar.noBorder.hasValue) {
+		[navigationController rnn_setNavigationBarNoBorder:[withDefault.topBar.noBorder get]];
+	}
+	
+	if (options.topBar.barStyle.hasValue) {
+		[navigationController rnn_setBarStyle:[RCTConvert UIBarStyle:withDefault.topBar.barStyle.get]];
+	}
+	
+	if (options.topBar.background.translucent.hasValue) {
+		[navigationController rnn_setNavigationBarTranslucent:[withDefault.topBar.background.translucent get]];
+	}
+	
+	if (options.topBar.background.clipToBounds.hasValue) {
+		[navigationController rnn_setNavigationBarClipsToBounds:[withDefault.topBar.background.clipToBounds get]];
+	}
+	
+	if (options.topBar.background.blur.hasValue) {
+		[navigationController rnn_setNavigationBarBlur:[withDefault.topBar.background.blur get]];
+	}
+	
+	if (options.topBar.background.color.hasValue) {
+		[navigationController setTopBarBackgroundColor:withDefault.topBar.background.color.get];
+	}
+	
+	if (options.topBar.largeTitle.visible.hasValue) {
+		[navigationController rnn_setNavigationBarLargeTitleVisible:withDefault.topBar.largeTitle.visible.get];
+	}
+	
+	if (options.topBar.backButton.icon.hasValue) {
+		[navigationController rnn_setBackButtonIcon:[withDefault.topBar.backButton.icon getWithDefaultValue:nil] withColor:[withDefault.topBar.backButton.color getWithDefaultValue:nil] title:[withDefault.topBar.backButton.showTitle getWithDefaultValue:nil] ? withDefault.topBar.backButton.title.get : @""];
+
+	}
+	
+	[navigationController rnn_setNavigationBarLargeTitleFontFamily:[withDefault.topBar.largeTitle.fontFamily getWithDefaultValue:nil] fontSize:[withDefault.topBar.largeTitle.fontSize getWithDefaultValue:nil] color:[withDefault.topBar.largeTitle.color getWithDefaultValue:nil]];
+	
+	[navigationController rnn_setNavigationBarFontFamily:[withDefault.topBar.title.fontFamily getWithDefaultValue:nil] fontSize:[withDefault.topBar.title.fontSize getWithDefaultValue:nil] color:[withDefault.topBar.title.color getWithDefaultValue:nil]];
+
 }
 
 @end

lib/ios/RNNNavigationOptions.h

-#import <Foundation/Foundation.h>
 #import "RNNTopBarOptions.h"
 #import "RNNBottomTabsOptions.h"
 #import "RNNBottomTabOptions.h"
 @property (nonatomic, strong) RNNPreviewOptions* preview;
 @property (nonatomic, strong) RNNLayoutOptions* layout;
 
-@property (nonatomic, strong) NSMutableDictionary* originalTopBarImages;
-@property (nonatomic, strong) NSNumber* popGesture;
-@property (nonatomic, strong) NSDictionary* backgroundImage;
-@property (nonatomic, strong) NSDictionary* rootBackgroundImage;
-@property (nonatomic, strong) NSString* modalPresentationStyle;
-@property (nonatomic, strong) NSString* modalTransitionStyle;
+@property (nonatomic, strong) Bool* popGesture;
+@property (nonatomic, strong) Image* backgroundImage;
+@property (nonatomic, strong) Image* rootBackgroundImage;
+@property (nonatomic, strong) Text* modalPresentationStyle;
+@property (nonatomic, strong) Text* modalTransitionStyle;
+
+- (instancetype)initEmptyOptions;
+
+- (RNNNavigationOptions *)withDefault:(RNNNavigationOptions *)defaultOptions;
+
+- (RNNNavigationOptions *)copy;
 
 @end

lib/ios/RNNNavigationOptions.m

 #import "RNNRootViewController.h"
 #import "RNNSplitViewController.h"
 #import "RNNNavigationButtons.h"
+#import "UIViewController+RNNOptions.h"
+#import "UINavigationController+RNNOptions.h"
 
 @implementation RNNNavigationOptions
 
-- (void)applyOn:(UIViewController *)viewController {
-	[self.topBar applyOn:viewController];
-	[self.bottomTabs applyOn:viewController];
-	[self.topTab applyOn:viewController];
-	[self.bottomTab applyOn:viewController];
-	[self.sideMenu applyOn:viewController];
-	[self.overlay applyOn:viewController];
-	[self.statusBar applyOn:viewController];
-	[self.layout applyOn:viewController];
+- (instancetype)initWithDict:(NSDictionary *)dict {
+	self = [super init];
 	
-	[self applyOtherOptionsOn:viewController];
+	self.topBar = [[RNNTopBarOptions alloc] initWithDict:dict[@"topBar"]];
+	self.bottomTabs = [[RNNBottomTabsOptions alloc] initWithDict:dict[@"bottomTabs"]];
+	self.bottomTab = [[RNNBottomTabOptions alloc] initWithDict:dict[@"bottomTab"]];
+	self.topTabs = [[RNNTopTabsOptions alloc] initWithDict:dict[@"topTabs"]];
+	self.topTab = [[RNNTopTabOptions alloc] initWithDict:dict[@"topTab"]];
+	self.sideMenu = [[RNNSideMenuOptions alloc] initWithDict:dict[@"sideMenu"]];
+	self.overlay = [[RNNOverlayOptions alloc] initWithDict:dict[@"overlay"]];
+	self.customTransition = [[RNNAnimationOptions alloc] initWithDict:dict[@"customTransition"]];
+	self.animations = [[RNNTransitionsOptions alloc] initWithDict:dict[@"animations"]];
+	self.statusBar = [[RNNStatusBarOptions alloc] initWithDict:dict[@"statusBar"]];
+	self.preview = [[RNNPreviewOptions alloc] initWithDict:dict[@"preview"]];
+	self.layout = [[RNNLayoutOptions alloc] initWithDict:dict[@"layout"]];
 	
-	[self applyOnNavigationController:viewController.navigationController];
-	[self applyOnTabBarController:viewController.tabBarController];
-}
-
-- (void)applyOnNavigationController:(UINavigationController *)navigationController {
-	[self.topBar applyOnNavigationController:navigationController];
-	[self.statusBar applyOn:navigationController];
-	[self.layout applyOn:navigationController];
-	[self.bottomTab applyOn:navigationController];
-	[self applyOtherOptionsOnNavigationController:navigationController];
+	self.popGesture = [[Bool alloc] initWithValue:dict[@"popGesture"]];
+	
+	self.backgroundImage = [ImageParser parse:dict key:@"backgroundImage"];
+	self.rootBackgroundImage = [ImageParser parse:dict key:@"rootBackgroundImage"];
+	self.modalPresentationStyle = [[Text alloc] initWithValue:dict[@"modalPresentationStyle"]];
+	self.modalTransitionStyle = [[Text alloc] initWithValue:dict[@"modalTransitionStyle"]];
+	
+	return self;
 }
 
-- (void)applyOnTabBarController:(UITabBarController *)tabBarController {
-	[self.bottomTabs applyOnTabBarController:tabBarController];
+- (instancetype)initEmptyOptions {
+	self = [self initWithDict:@{}];
+	return self;
 }
 
-- (void)applyOtherOptionsOnNavigationController:(UINavigationController*)navigationController {
-	if (self.popGesture) {
-		navigationController.interactivePopGestureRecognizer.enabled = [self.popGesture boolValue];
-	}
+- (RNNOptions *)copy {
+	RNNNavigationOptions* newOptions = [[RNNNavigationOptions alloc] initWithDict:@{}];
+	[newOptions overrideOptions:self];
 	
-	if (self.rootBackgroundImage) {
-		UIImageView* backgroundImageView = (navigationController.view.subviews.count > 0) ? navigationController.view.subviews[0] : nil;
-		if (![backgroundImageView isKindOfClass:[UIImageView class]]) {
-			backgroundImageView = [[UIImageView alloc] initWithFrame:navigationController.view.bounds];
-			[navigationController.view insertSubview:backgroundImageView atIndex:0];
-		}
-		
-		backgroundImageView.layer.masksToBounds = YES;
-		backgroundImageView.image = [self.rootBackgroundImage isKindOfClass:[UIImage class]] ? (UIImage*)self.rootBackgroundImage : [RCTConvert UIImage:self.rootBackgroundImage];
-		[backgroundImageView setContentMode:UIViewContentModeScaleAspectFill];
-	}
+	return newOptions;
 }
 
-- (void)applyOtherOptionsOn:(UIViewController*)viewController {
-	if (self.backgroundImage) {
-		UIImageView* backgroundImageView = (viewController.view.subviews.count > 0) ? viewController.view.subviews[0] : nil;
-		if (![backgroundImageView isKindOfClass:[UIImageView class]]) {
-			backgroundImageView = [[UIImageView alloc] initWithFrame:viewController.view.bounds];
-			[viewController.view insertSubview:backgroundImageView atIndex:0];
-		}
-		
-		backgroundImageView.layer.masksToBounds = YES;
-		backgroundImageView.image = [self.backgroundImage isKindOfClass:[UIImage class]] ? (UIImage*)self.backgroundImage : [RCTConvert UIImage:self.backgroundImage];
-		[backgroundImageView setContentMode:UIViewContentModeScaleAspectFill];
-	}
-
-	if (self.modalPresentationStyle) {
-		viewController.modalPresentationStyle = [RCTConvert UIModalPresentationStyle:self.modalPresentationStyle];
-		[viewController.view setBackgroundColor:[UIColor clearColor]];
-	}
-	if (self.modalTransitionStyle) {
-		viewController.modalTransitionStyle = [RCTConvert UIModalTransitionStyle:self.modalTransitionStyle];
-	}
+- (RNNNavigationOptions *)withDefault:(RNNNavigationOptions *)defaultOptions {
+	return (RNNNavigationOptions *)[super withDefault:defaultOptions];
 }
 
 @end

lib/ios/RNNOptions.h

-#import <Foundation/Foundation.h>
 #import <UIKit/UIKit.h>
 #import <React/RCTConvert.h>
+#import "BoolParser.h"
+#import "TextParser.h"
+#import "NumberParser.h"
+#import "DictionaryParser.h"
+#import "ColorParser.h"
+#import "ImageParser.h"
+#import "IntNumberParser.h"
+#import "DoubleParser.h"
 
-@class RNNOptions;
+@interface RNNOptions : NSObject
 
-@protocol RNNOptionsProtocol <NSObject>
-
-@optional
-- (void)resetOptions;
-
-@required
-- (void)applyOn:(UIViewController *)viewController;
-- (void)applyOnNavigationController:(UINavigationController *)navigationController;
-- (void)applyOnTabBarController:(UITabBarController *)tabBarController;
-
-@end
+- (instancetype)initWithDict:(NSDictionary*)dict;
 
-@interface RNNOptions : NSObject <RNNOptionsProtocol>
+- (RNNOptions *)overrideOptions:(RNNOptions *)otherOptions;
+- (RNNOptions *)mergeOptions:(RNNOptions *)otherOptions;
 
-- (instancetype)initWithDict:(NSDictionary*)dict;
-- (void)mergeWith:(NSDictionary*)otherOptions;
-- (void)applyOn:(UIViewController *)viewController defaultOptions:(RNNOptions*)defaultOptions;
-- (BOOL)hasProperty:(NSString*)propName;
-- (void)mergeOptions:(RNNOptions *)otherOptions;
-- (void)mergeOptions:(RNNOptions *)otherOptions overrideOptions:(BOOL)override;
+- (RNNOptions *)withDefault:(RNNOptions *)defaultOptions;
 
 @end

lib/ios/RNNOptions.m

 
 - (instancetype)initWithDict:(NSDictionary *)dict {
 	self = [super init];
-	[self initializeOptionsPropertiesWithDict:dict];
-	
-	[self mergeWith:dict];
 	return self;
 }
 
-- (void)applyOn:(UIViewController *)viewController defaultOptions:(RNNOptions *)defaultOptions {
-	[defaultOptions applyOn:viewController];
-	[self applyOn:viewController];
-}
-
-- (void)applyOn:(UIViewController *)viewController {
-	
-}
-
-- (void)applyOnNavigationController:(UINavigationController *)navigationController {
-	
-}
-
-- (void)applyOnTabBarController:(UITabBarController *)tabBarController {
-	
-}
-
-- (void)mergeWith:(NSDictionary *)otherOptions {
-	for (id key in otherOptions) {
-		if ([self hasProperty: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)mergeOptions:(RNNOptions *)otherOptions overrideOptions:(BOOL)override {
+- (RNNOptions *)mergeOptions:(RNNOptions *)otherOptions overrideOptions:(BOOL)override {
 	for (id prop in [self objectProperties:otherOptions]) {
 		id value = [otherOptions valueForKey:prop];
 		if ([value isKindOfClass:[RNNOptions class]]) {
 			[[self valueForKey:prop] mergeOptions:value overrideOptions:override];
+		} else if ([value isKindOfClass:[Param class]]) {
+			if ((((Param *)value).hasValue) && (override || !((Param *)[self valueForKey:prop]).hasValue)) {
+				[self setValue:value forKey:prop];
+			}
 		} else if (value && (override || ![self valueForKey:prop])) {
 			[self setValue:value forKey:prop];
 		}
 	}
+	
+	return self;
 }
 
-- (void)mergeOptions:(RNNOptions *)otherOptions {
-	[self mergeOptions:otherOptions overrideOptions:YES];
+- (RNNOptions *)overrideOptions:(RNNOptions *)otherOptions {
+	return [self mergeOptions:otherOptions overrideOptions:YES];
 }
 
-- (BOOL)hasProperty:(NSString*)propName {
-	return [self respondsToSelector:NSSelectorFromString(propName)];
+- (RNNOptions *)mergeOptions:(RNNOptions *)otherOptions {
+	return [self mergeOptions:otherOptions overrideOptions:NO];
 }
 
-- (void)initializeOptionsPropertiesWithDict:(NSDictionary*)dict {
-	unsigned int count;
-	objc_property_t* props = class_copyPropertyList([self class], &count);
-	for (int i = 0; i < count; i++) {
-		objc_property_t property = props[i];
-		NSString *propertyName = [NSString stringWithCString:property_getName(property) encoding:NSUTF8StringEncoding];
-		const char * type = property_getAttributes(property);
-		NSString * typeString = [NSString stringWithUTF8String:type];
-		NSArray * attributes = [typeString componentsSeparatedByString:@","];
-		NSString * typeAttribute = [attributes objectAtIndex:0];
-		
-		if ([typeAttribute hasPrefix:@"T@"] && [typeAttribute length] > 3) {
-			NSString * typeClassName = [typeAttribute substringWithRange:NSMakeRange(3, [typeAttribute length]-4)];
-			Class typeClass = NSClassFromString(typeClassName);
-			if ([typeClass isSubclassOfClass:[RNNOptions class]]) {
-				RNNOptions* value = [[typeClass alloc] initWithDict:dict[propertyName]];
-				[self setValue:value forKey:propertyName];
-			}
-		}
-		
-	}
-	free(props);
+- (RNNOptions *)withDefault:(RNNOptions *)defaultOptions {
+	RNNOptions* newOptions = [[[self class] alloc] initWithDict:@{}];
+	[newOptions mergeOptions:defaultOptions overrideOptions:YES];
+	[newOptions mergeOptions:self overrideOptions:YES];
+	
+	return newOptions;
 }
 
 - (NSArray *)objectProperties:(NSObject *)object {

lib/ios/RNNOptionsManager.h

-#import <Foundation/Foundation.h>
-#import "RNNNavigationOptions.h"
-
-@interface RNNOptionsManager : NSObject
-
-- (RNNNavigationOptions *)createOptions:(NSDictionary *)optionsDict;
-
-@property (nonatomic, strong) NSDictionary* defaultOptionsDict;
-
-@end

lib/ios/RNNOptionsManager.m

-#import "RNNOptionsManager.h"
-
-@implementation RNNOptionsManager
-
-- (RNNNavigationOptions *)createOptions:(NSDictionary *)optionsDict {
-	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:optionsDict];
-	
-	[options mergeOptions:[[RNNNavigationOptions alloc] initWithDict:_defaultOptionsDict] overrideOptions:NO];
-	
-	return options;
-}
-@end

lib/ios/RNNOverlayOptions.h

 
 @interface RNNOverlayOptions : RNNOptions
 
-@property (nonatomic, strong) NSNumber* interceptTouchOutside;
+@property (nonatomic, strong) Bool* interceptTouchOutside;
 
 @end

lib/ios/RNNOverlayOptions.m

 
 @implementation RNNOverlayOptions
 
+- (instancetype)initWithDict:(NSDictionary *)dict {
+	self = [super init];
+	
+	self.interceptTouchOutside = [BoolParser parse:dict key:@"interceptTouchOutside"];
+	
+	return self;
+}
+
 - (void)applyOn:(UIViewController *)viewController {
-	if (self.interceptTouchOutside) {
-		RCTRootView* rootView = (RCTRootView*)viewController.view;
-		rootView.passThroughTouches = ![self.interceptTouchOutside boolValue];
-	}
+//	if (self.interceptTouchOutside) {
+//		RCTRootView* rootView = (RCTRootView*)viewController.view;
+//		rootView.passThroughTouches = ![self.interceptTouchOutside boolValue];
+//	}
 }
 
 @end

lib/ios/RNNParentProtocol.h

 
 - (instancetype)initWithLayoutInfo:(RNNLayoutInfo *)layoutInfo childViewControllers:(NSArray *)childViewControllers options:(RNNNavigationOptions *)options presenter:(RNNBasePresenter *)presenter;
 
+- (void)onChildWillAppear;
+
 @end

lib/ios/RNNReactRootViewCreator.m

 }
 
 -(UIView*)createRootViewFromComponentOptions:(RNNComponentOptions*)componentOptions {
-	return [self createCustomReactView:componentOptions.name rootViewId:componentOptions.componentId];
+	return [self createCustomReactView:componentOptions.name.get rootViewId:componentOptions.componentId.get];
 }
 
 @end

lib/ios/RNNRootViewController.h

-#import <Foundation/Foundation.h>
-#import <UIKit/UIKit.h>
 #import "RNNLayoutNode.h"
 #import "RNNRootViewCreator.h"
 #import "RNNEventEmitter.h"

lib/ios/RNNRootViewController.m

 #import "RNNPushAnimation.h"
 #import "RNNReactView.h"
 #import "RNNParentProtocol.h"
+#import "RNNTitleViewHelper.h"
 
 @interface RNNRootViewController() {
 	RNNReactView* _customTitleView;
 
 - (instancetype)initWithLayoutInfo:(RNNLayoutInfo *)layoutInfo rootViewCreator:(id<RNNRootViewCreator>)creator eventEmitter:(RNNEventEmitter *)eventEmitter presenter:(RNNViewControllerPresenter *)presenter options:(RNNNavigationOptions *)options {
 	self = [super init];
-	self.eventEmitter = eventEmitter;
-	self.creator = creator;
-	self.layoutInfo = layoutInfo;
-	self.presenter = presenter;
-	self.options = options;
-	
-	self.animator = [[RNNAnimator alloc] initWithTransitionOptions:self.options.customTransition];
 	
+	self.layoutInfo = layoutInfo;
+	self.creator = creator;
 	if (self.creator) {
 		self.view = [creator createRootView:self.layoutInfo.name rootViewId:self.layoutInfo.componentId];
 		[[NSNotificationCenter defaultCenter] addObserver:self
 												   object:nil];
 	}
 	
+	self.eventEmitter = eventEmitter;
+	self.presenter = presenter;
+	[self.presenter bindViewController:self];
+	self.options = options;
+	
+	self.animator = [[RNNAnimator alloc] initWithTransitionOptions:self.options.customTransition];
+	
 	[[NSNotificationCenter defaultCenter] addObserver:self
 											 selector:@selector(onJsReload)
 												 name:RCTJavaScriptWillStartLoadingNotification
 	[viewController didMoveToParentViewController:self];
 }
 
+- (void)willMoveToParentViewController:(UIViewController *)parent {
+	if (parent) {
+		[_presenter applyOptionsOnWillMoveToParentViewController:self.options];
+	}
+}
+
+- (void)mergeOptions:(RNNNavigationOptions *)options {
+	[_presenter mergeOptions:options];
+	[((UIViewController<RNNLayoutProtocol> *)self.parentViewController) mergeOptions:options];
+	
+	[self initCustomViews];
+}
+
 -(void)viewWillAppear:(BOOL)animated{
 	[super viewWillAppear:animated];
 	_isBeingPresented = YES;
-	[_presenter present:self.options onViewControllerWillAppear:self];
-	[self initReactCustomViews];
+	
+	[_presenter applyOptions:self.options];
+	[((UIViewController<RNNParentProtocol> *)self.parentViewController) onChildWillAppear];
+	
+	[self initCustomViews];
+}
+
+- (RNNNavigationOptions *)resolveOptions {
+	return self.options;
 }
 
 -(void)viewDidAppear:(BOOL)animated {
 	_isBeingPresented = NO;
 }
 
--(void)viewDidDisappear:(BOOL)animated {
+- (void)viewDidDisappear:(BOOL)animated {
 	[super viewDidDisappear:animated];
 	[self.eventEmitter sendComponentDidDisappear:self.layoutInfo.componentId componentName:self.layoutInfo.name];
 }
 
-- (void)willMoveToParentViewController:(UIViewController *)parent {
-	[_presenter present:self.options onViewControllerDidLoad:self];
-}
-
-- (void)mergeAndPresentOptions:(RNNNavigationOptions *)newOptions {
-	[self.options mergeOptions:newOptions overrideOptions:YES];
-	[_presenter present:self.options onViewControllerWillAppear:self];
-	
-	[self initReactCustomViews];
-}
-
 - (void)reactViewReady {
 	if (_reactViewReadyBlock) {
 		_reactViewReadyBlock();
 	}
 }
 
-- (UIViewController *)getLeafViewController {
+- (UIViewController *)getCurrentChild {
 	return self;
 }
 
 	[self.eventEmitter sendOnSearchBarCancelPressed:self.layoutInfo.componentId];
 }
 
-- (void)initReactCustomViews {
+- (void)initCustomViews {
 	[self setCustomNavigationTitleView];
 	[self setCustomNavigationBarView];
 	[self setCustomNavigationComponentBackground];
+	
+	if (!_customTitleView) {
+		[self setTitleViewWithSubtitle];
+	}
+}
+
+- (void)setTitleViewWithSubtitle {
+	if (self.options.topBar.subtitle.text.hasValue) {
+		RNNTitleViewHelper* titleViewHelper = [[RNNTitleViewHelper alloc] initWithTitleViewOptions:self.optionsWithDefault.topBar.title subTitleOptions:self.optionsWithDefault.topBar.subtitle viewController:self];
+		[titleViewHelper setup];
+	}
 }
 
 - (void)setCustomNavigationTitleView {
 	if (!_customTitleView && _isBeingPresented) {
-		if (self.options.topBar.title.component.name) {
+		if (self.options.topBar.title.component.name.hasValue) {
 			_customTitleView = (RNNReactView*)[_creator createRootViewFromComponentOptions:self.options.topBar.title.component];
 			_customTitleView.backgroundColor = UIColor.clearColor;
-			[_customTitleView setAlignment:self.options.topBar.title.component.alignment];
-			BOOL isCenter = [self.options.topBar.title.component.alignment isEqualToString:@"center"];
+			NSString* alignment = [self.options.topBar.title.component.alignment getWithDefaultValue:@""];
+			[_customTitleView setAlignment:alignment];
+			BOOL isCenter = [alignment isEqualToString:@"center"];
 			__weak RNNReactView *weakTitleView = _customTitleView;
 			CGRect frame = self.navigationController.navigationBar.bounds;
 			[_customTitleView setFrame:frame];
 
 - (void)setCustomNavigationBarView {
 	if (!_customTopBar) {
-		if (self.options.topBar.component.name) {
+		if (self.options.topBar.component.name.hasValue) {
 			RCTRootView *reactView = (RCTRootView*)[_creator createRootViewFromComponentOptions:self.options.topBar.component];
 			
 			_customTopBar = [[RNNCustomTitleView alloc] initWithFrame:self.navigationController.navigationBar.bounds subView:reactView alignment:@"fill"];
 
 - (void)setCustomNavigationComponentBackground {
 	if (!_customTopBarBackground) {
-		if (self.options.topBar.background.component.name) {
+		if (self.options.topBar.background.component.name.hasValue) {
 			RCTRootView *reactView = (RCTRootView*)[_creator createRootViewFromComponentOptions:self.options.topBar.background.component];
 			
 			_customTopBarBackground = [[RNNCustomTitleView alloc] initWithFrame:self.navigationController.navigationBar.bounds subView:reactView alignment:@"fill"];
 	}
 }
 
+- (RNNNavigationOptions *)optionsWithDefault {
+	return (RNNNavigationOptions *)[[self.options copy] withDefault:_presenter.defaultOptions];
+}
+
 -(BOOL)isCustomTransitioned {
-	return self.options.customTransition.animations != nil;
+	return self.optionsWithDefault.customTransition.animations != nil;
 }
 
 - (BOOL)isExternalViewController {
 }
 
 - (BOOL)prefersStatusBarHidden {
-	if (self.options.statusBar.visible) {
-		return ![self.options.statusBar.visible boolValue];
-	} else if ([self.options.statusBar.hideWithTopBar boolValue]) {
+	if (self.optionsWithDefault.statusBar.visible.hasValue) {
+		return ![self.optionsWithDefault.statusBar.visible get];
+	} else if ([self.optionsWithDefault.statusBar.hideWithTopBar getWithDefaultValue:NO]) {
 		return self.navigationController.isNavigationBarHidden;
 	}
 	
 }
 
 - (UIStatusBarStyle)preferredStatusBarStyle {
-	if (self.options.statusBar.style && [self.options.statusBar.style isEqualToString:@"light"]) {
+	if ([[self.optionsWithDefault.statusBar.style getWithDefaultValue:@"default"] isEqualToString:@"light"]) {
 		return UIStatusBarStyleLightContent;
 	} else {
 		return UIStatusBarStyleDefault;
 }
 
 - (UIInterfaceOrientationMask)supportedInterfaceOrientations {
-	return self.options.layout.supportedOrientations;
+	return self.optionsWithDefault.layout.supportedOrientations;
 }
 
 - (BOOL)hidesBottomBarWhenPushed
 {
-	if (self.options.bottomTabs && self.options.bottomTabs.visible) {
-		return ![self.options.bottomTabs.visible boolValue];
+	if (self.optionsWithDefault.bottomTabs.visible.hasValue) {
+		return !self.optionsWithDefault.bottomTabs.visible.get;
 	}
 	return NO;
 }
 
 - (void)navigationController:(UINavigationController *)navigationController didShowViewController:(UIViewController *)viewController animated:(BOOL)animated{
 	RNNRootViewController* vc =  (RNNRootViewController*)viewController;
-	if (![vc.options.topBar.backButton.transition isEqualToString:@"custom"]){
+	if (![[vc.optionsWithDefault.topBar.backButton.transition getWithDefaultValue:@""] isEqualToString:@"custom"]){
 		navigationController.delegate = nil;
 	}
 }
 												 toViewController:(UIViewController*)toVC {
 	if (self.animator) {
 		return self.animator;
-	} else if (operation == UINavigationControllerOperationPush && self.options.animations.push.hasCustomAnimation) {
-		return [[RNNPushAnimation alloc] initWithScreenTransition:self.options.animations.push];
-	} else if (operation == UINavigationControllerOperationPop && self.options.animations.pop.hasCustomAnimation) {
-		return [[RNNPushAnimation alloc] initWithScreenTransition:self.options.animations.pop];
+	} else if (operation == UINavigationControllerOperationPush && self.optionsWithDefault.animations.push.hasCustomAnimation) {
+		return [[RNNPushAnimation alloc] initWithScreenTransition:self.optionsWithDefault.animations.push];
+	} else if (operation == UINavigationControllerOperationPop && self.optionsWithDefault.animations.pop.hasCustomAnimation) {
+		return [[RNNPushAnimation alloc] initWithScreenTransition:self.optionsWithDefault.animations.pop];
 	} else {
 		return nil;
 	}
 }
 
 - (nullable id <UIViewControllerAnimatedTransitioning>)animationControllerForPresentedController:(UIViewController *)presented presentingController:(UIViewController *)presenting sourceController:(UIViewController *)source {
-	return [[RNNModalAnimation alloc] initWithScreenTransition:self.options.animations.showModal isDismiss:NO];
+	return [[RNNModalAnimation alloc] initWithScreenTransition:self.optionsWithDefault.animations.showModal isDismiss:NO];
 }
 
 - (id<UIViewControllerAnimatedTransitioning>)animationControllerForDismissedController:(UIViewController *)dismissed {
-	return [[RNNModalAnimation alloc] initWithScreenTransition:self.options.animations.dismissModal isDismiss:YES];
+	return [[RNNModalAnimation alloc] initWithScreenTransition:self.optionsWithDefault.animations.dismissModal isDismiss:YES];
 }
 
 - (UIViewController *)previewingContext:(id<UIViewControllerPreviewing>)previewingContext viewControllerForLocation:(CGPoint)location{

lib/ios/RNNSideMenuChildVC.h

 @property (readonly) UIViewController<RNNParentProtocol> *child;
 
 @property (nonatomic, retain) RNNLayoutInfo* layoutInfo;
-@property (nonatomic, retain) RNNBasePresenter* presenter;
+@property (nonatomic, retain) RNNViewControllerPresenter* presenter;
 @property (nonatomic, strong) RNNNavigationOptions* options;
 
-- (instancetype)initWithLayoutInfo:(RNNLayoutInfo *)layoutInfo childViewControllers:(NSArray *)childViewControllers options:(RNNNavigationOptions *)options presenter:(RNNBasePresenter *)presenter type:(RNNSideMenuChildType)type;
+- (instancetype)initWithLayoutInfo:(RNNLayoutInfo *)layoutInfo childViewControllers:(NSArray *)childViewControllers options:(RNNNavigationOptions *)options presenter:(RNNViewControllerPresenter *)presenter type:(RNNSideMenuChildType)type;
 
 @end

lib/ios/RNNSideMenuChildVC.m

 
 @implementation RNNSideMenuChildVC
 
-- (instancetype)initWithLayoutInfo:(RNNLayoutInfo *)layoutInfo childViewControllers:(NSArray *)childViewControllers options:(RNNNavigationOptions *)options presenter:(RNNBasePresenter *)presenter type:(RNNSideMenuChildType)type {
+- (instancetype)initWithLayoutInfo:(RNNLayoutInfo *)layoutInfo childViewControllers:(NSArray *)childViewControllers options:(RNNNavigationOptions *)options presenter:(RNNViewControllerPresenter *)presenter type:(RNNSideMenuChildType)type {
 	self = [self initWithLayoutInfo:layoutInfo childViewControllers:childViewControllers options:options presenter:presenter];
 	
 	self.type = type;
 	return self;
 }
 
-- (instancetype)initWithLayoutInfo:(RNNLayoutInfo *)layoutInfo childViewControllers:(NSArray *)childViewControllers options:(RNNNavigationOptions *)options presenter:(RNNBasePresenter *)presenter {
+- (instancetype)initWithLayoutInfo:(RNNLayoutInfo *)layoutInfo childViewControllers:(NSArray *)childViewControllers options:(RNNNavigationOptions *)options presenter:(RNNViewControllerPresenter *)presenter {
 	self = [super init];
 	
+	self.child = childViewControllers[0];
+	
 	self.presenter = presenter;
+	[self.presenter bindViewController:self];
+	
+	
 	self.options = options;
 	self.layoutInfo = layoutInfo;
 	
-	[self bindChildViewControllers:childViewControllers];
-	
+	[self bindChildViewController:self.child];
+
 	return self;
 }
 
-- (void)bindChildViewControllers:(NSArray<UIViewController<RNNParentProtocol> *> *)viewControllers {
-	UIViewController<RNNParentProtocol>* child = viewControllers[0];
-	
+- (void)onChildWillAppear {
+	[_presenter applyOptions:self.resolveOptions];
+	[((UIViewController<RNNParentProtocol> *)self.parentViewController) onChildWillAppear];
+}
+
+- (RNNNavigationOptions *)resolveOptions {
+	return (RNNNavigationOptions *)[self.getCurrentChild.resolveOptions.copy mergeOptions:self.options];
+}
+
+- (void)mergeOptions:(RNNNavigationOptions *)options {
+	[_presenter mergeOptions:options];
+	[((UIViewController<RNNLayoutProtocol> *)self.parentViewController) mergeOptions:options];
+}
+
+- (UITabBarItem *)tabBarItem {
+	return super.tabBarItem ? super.tabBarItem : self.child.tabBarItem;
+}
+
+- (void)bindChildViewController:(UIViewController<RNNParentProtocol>*)child {
 	self.child = child;
 	[self addChildViewController:self.child];
 	[self.child.view setFrame:self.view.bounds];
 	[self.view bringSubviewToFront:self.child.view];
 }
 
-- (UIViewController *)getLeafViewController {
-	return [self.child getLeafViewController];
-}
-
-- (void)willMoveToParentViewController:(UIViewController *)parent {
-	[_presenter present:self.options onViewControllerDidLoad:self];
+- (UIViewController *)getCurrentChild {
+	return [self.child getCurrentChild];
 }
 
 - (UIStatusBarStyle)preferredStatusBarStyle {

lib/ios/RNNSideMenuController.h

-//
-//  RNNSideMenuController.h
-//  ReactNativeNavigation
-//
-//  Created by Ran Greenberg on 09/02/2017.
-//  Copyright © 2017 Wix. All rights reserved.
-//
-
 #import <UIKit/UIKit.h>
 #import "RNNSideMenuChildVC.h"
 #import "MMDrawerController.h"
 #import "RNNParentProtocol.h"
 
-@interface RNNSideMenuController : UIViewController <RNNParentProtocol>
+@interface RNNSideMenuController : MMDrawerController <RNNParentProtocol>
 
 @property (readonly) RNNSideMenuChildVC *center;
 @property (readonly) RNNSideMenuChildVC *left;
 @property (readonly) RNNSideMenuChildVC *right;
-@property (readonly) MMDrawerController *sideMenu;
 
 @property (nonatomic, retain) RNNLayoutInfo* layoutInfo;
-@property (nonatomic, retain) RNNBasePresenter* presenter;
+@property (nonatomic, retain) RNNViewControllerPresenter* presenter;
 @property (nonatomic, strong) RNNNavigationOptions* options;
 
--(void)showSideMenu:(MMDrawerSide)side animated:(BOOL)animated;
--(void)hideSideMenu:(MMDrawerSide)side animated:(BOOL)animated;
+- (void)side:(MMDrawerSide)side enabled:(BOOL)enabled;
+- (void)side:(MMDrawerSide)side visible:(BOOL)visible;
+- (void)side:(MMDrawerSide)side width:(double)width;
 
 @end

lib/ios/RNNSideMenuController.m

-//
-//  RNNSideMenuController.m
-//  ReactNativeNavigation
-//
-//  Created by Ran Greenberg on 09/02/2017.
-//  Copyright © 2017 Wix. All rights reserved.
-//
-
 #import "RNNSideMenuController.h"
 #import "RNNSideMenuChildVC.h"
 #import "MMDrawerController.h"
+#import "MMDrawerVisualState.h"
 
 @interface RNNSideMenuController ()
 
 @property (readwrite) RNNSideMenuChildVC *center;
 @property (readwrite) RNNSideMenuChildVC *left;
 @property (readwrite) RNNSideMenuChildVC *right;
-@property (readwrite) MMDrawerController *sideMenu;
 
 @end
 
 @implementation RNNSideMenuController
 
-- (instancetype)initWithLayoutInfo:(RNNLayoutInfo *)layoutInfo childViewControllers:(NSArray *)childViewControllers options:(RNNNavigationOptions *)options presenter:(RNNBasePresenter *)presenter {
-	self = [super init];
+- (instancetype)initWithLayoutInfo:(RNNLayoutInfo *)layoutInfo childViewControllers:(NSArray *)childViewControllers options:(RNNNavigationOptions *)options presenter:(RNNViewControllerPresenter *)presenter {
+	[self setControllers:childViewControllers];
+	self = [super initWithCenterViewController:self.center leftDrawerViewController:self.left rightDrawerViewController:self.right];
 	
 	self.presenter = presenter;
+	[self.presenter bindViewController:self];
+	
 	self.options = options;
+	
 	self.layoutInfo = layoutInfo;
 	
-	[self bindChildViewControllers:childViewControllers];
+	self.openDrawerGestureModeMask = MMOpenDrawerGestureModeAll;
+	self.closeDrawerGestureModeMask = MMCloseDrawerGestureModeAll;
 	
 	// Fixes #3697
 	[self setExtendedLayoutIncludesOpaqueBars:YES];
 	return self;
 }
 
-- (void)bindChildViewControllers:(NSArray<UIViewController<RNNLayoutProtocol> *> *)viewControllers {
-	[self setControllers:viewControllers];
-	
-	self.sideMenu = [[MMDrawerController alloc] initWithCenterViewController:self.center leftDrawerViewController:self.left rightDrawerViewController:self.right];
-	
-	self.sideMenu.openDrawerGestureModeMask = MMOpenDrawerGestureModeAll;
-	self.sideMenu.closeDrawerGestureModeMask = MMCloseDrawerGestureModeAll;
+- (void)willMoveToParentViewController:(UIViewController *)parent {
+	if (parent) {
+		[_presenter applyOptionsOnWillMoveToParentViewController:self.options];
+	}
+}
+
+- (void)viewWillAppear:(BOOL)animated {
+	[super viewWillAppear:animated];
+	[_presenter applyOptions:self.options];
+}
+
+- (UITabBarItem *)tabBarItem {
+	return super.tabBarItem ? super.tabBarItem : self.center.tabBarItem;
+}
+
+- (void)onChildWillAppear {
+	[_presenter applyOptions:self.resolveOptions];
+	[((UIViewController<RNNParentProtocol> *)self.parentViewController) onChildWillAppear];
+}
+
+- (RNNNavigationOptions *)resolveOptions {
+	return (RNNNavigationOptions *)[self.getCurrentChild.resolveOptions.copy mergeOptions:self.options];
+}
+
+- (void)mergeOptions:(RNNNavigationOptions *)options {
+	[_presenter mergeOptions:options];
+	[((UIViewController<RNNLayoutProtocol> *)self.parentViewController) mergeOptions:options];
+}
+
+- (void)setAnimationType:(NSString *)animationType {
+	MMDrawerControllerDrawerVisualStateBlock animationTypeStateBlock = nil;
+	if ([animationType isEqualToString:@"door"]) animationTypeStateBlock = [MMDrawerVisualState swingingDoorVisualStateBlock];
+	else if ([animationType isEqualToString:@"parallax"]) animationTypeStateBlock = [MMDrawerVisualState parallaxVisualStateBlockWithParallaxFactor:2.0];
+	else if ([animationType isEqualToString:@"slide"]) animationTypeStateBlock = [MMDrawerVisualState slideVisualStateBlock];
+	else if ([animationType isEqualToString:@"slide-and-scale"]) animationTypeStateBlock = [MMDrawerVisualState slideAndScaleVisualStateBlock];
 	
-	[self addChildViewController:self.sideMenu];
-	[self.sideMenu.view setFrame:self.view.bounds];
-	[self.view addSubview:self.sideMenu.view];
-	[self.view bringSubviewToFront:self.sideMenu.view];
+	if (animationTypeStateBlock) {
+		[self setDrawerVisualStateBlock:animationTypeStateBlock];
+	}
+}
+
+- (void)side:(MMDrawerSide)side width:(double)width {
+	switch (side) {
+		case MMDrawerSideRight:
+			self.maximumRightDrawerWidth = width;
+			break;
+		case MMDrawerSideLeft:
+			self.maximumLeftDrawerWidth = width;
+		default:
+			break;
+	}
+}
+
+- (void)side:(MMDrawerSide)side visible:(BOOL)visible {
+	if (visible) {
+		[self showSideMenu:side animated:YES];
+	} else {
+		[self hideSideMenu:side animated:YES];
+	}
 }
 
 -(void)showSideMenu:(MMDrawerSide)side animated:(BOOL)animated {
-	[self.sideMenu openDrawerSide:side animated:animated completion:nil];
+	[self openDrawerSide:side animated:animated completion:nil];
 }
 
 -(void)hideSideMenu:(MMDrawerSide)side animated:(BOOL)animated {
-	[self.sideMenu closeDrawerAnimated:animated completion:nil];
+	[self closeDrawerAnimated:animated completion:nil];
+}
+
+- (void)side:(MMDrawerSide)side enabled:(BOOL)enabled {
+	switch (side) {
+		case MMDrawerSideRight:
+			self.rightSideEnabled = enabled;
+			break;
+		case MMDrawerSideLeft:
+			self.leftSideEnabled = enabled;
+		default:
+			break;
+	}
+	self.openDrawerGestureModeMask = enabled ? MMOpenDrawerGestureModeAll : MMOpenDrawerGestureModeNone;
 }
 
 -(void)setControllers:(NSArray*)controllers {
 }
 
 - (UIViewController *)openedViewController {
-	switch (self.sideMenu.openSide) {
+	switch (self.openSide) {
 		case MMDrawerSideNone:
 			return self.center;
 		case MMDrawerSideLeft:
 	}
 }
 
-- (UIViewController<RNNLayoutProtocol> *)getLeafViewController {
-	return [self.center getLeafViewController];
-}
-
-- (void)willMoveToParentViewController:(UIViewController *)parent {
-	[_presenter present:self.options onViewControllerDidLoad:self];
+- (UIViewController<RNNLayoutProtocol> *)getCurrentChild {
+	return [self.center getCurrentChild];
 }
 
 @end