Button color (#3713)

* Revert "merging buttons fix"

This reverts commit 74077bbc55.

* Revert "fix undefined buttons"

This reverts commit e3b4d15a06.

* Revert "fix e2e"

This reverts commit 05b3f5808f.

* Revert "Handle merge buttons style"

This reverts commit 9c705402eb.

* Add background component with MATCH_PARENT height

* temporary solution for merging button color

This commit introduces two temporary options to control button colors
* rightButtonColor
* leftButtonColor

These options can be used to color buttons. Colors defined in buttons take
precedence over these two options.

* Get buttonColor options from resolved options

* leftButtonColor & rightButtonColor support - iOS

* Disabled color

* disabled buttons color support

* Rebase fixes

* empty commit

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

         options.elevation = FractionParser.parse(json, "elevation");
         options.buttons = TopBarButtons.parse(typefaceLoader, json);
 
+        options.rightButtonColor = ColorParser.parse(json, "rightButtonColor");
+        options.leftButtonColor = ColorParser.parse(json, "leftButtonColor");
+
         options.validate();
         return options;
     }
     public Fraction borderHeight = new NullFraction();
     public Color borderColor = new NullColor();
 
+    // Deprecated
+    public Color rightButtonColor = new NullColor();
+    public Color leftButtonColor = new NullColor();
+    public Color rightButtonDisabledColor = new NullColor();
+    public Color leftButtonDisabledColor = new NullColor();
+
+    public TopBarOptions copy() {
+        TopBarOptions result = new TopBarOptions();
+        result.mergeWith(this);
+        return result;
+    }
+
     void mergeWith(final TopBarOptions other) {
         title.mergeWith(other.title);
         subtitle.mergeWith(other.subtitle);
         if (other.borderHeight.hasValue()) borderHeight = other.borderHeight;
         if (other.borderColor.hasValue()) borderColor = other.borderColor;
         if (other.elevation.hasValue()) elevation = other.elevation;
+
+        if (other.rightButtonColor.hasValue()) rightButtonColor = other.rightButtonColor;
+        if (other.leftButtonColor.hasValue()) leftButtonColor = other.leftButtonColor;
+        if (other.rightButtonDisabledColor.hasValue()) rightButtonDisabledColor = other.rightButtonDisabledColor;
+        if (other.leftButtonDisabledColor.hasValue()) leftButtonDisabledColor = other.leftButtonDisabledColor;
+
         validate();
     }
 
-    void mergeWithDefault(TopBarOptions defaultOptions) {
+    public TopBarOptions mergeWithDefault(TopBarOptions defaultOptions) {
         title.mergeWithDefault(defaultOptions.title);
         subtitle.mergeWithDefault(defaultOptions.subtitle);
         background.mergeWithDefault(defaultOptions.background);
         if (!borderHeight.hasValue()) borderHeight = defaultOptions.borderHeight;
         if (!borderColor.hasValue()) borderColor = defaultOptions.borderColor;
         if (!elevation.hasValue()) elevation = defaultOptions.elevation;
+
+        if (!rightButtonColor.hasValue()) rightButtonColor = defaultOptions.rightButtonColor;
+        if (!leftButtonColor.hasValue()) leftButtonColor = defaultOptions.leftButtonColor;
+        if (!rightButtonDisabledColor.hasValue()) rightButtonDisabledColor = defaultOptions.rightButtonDisabledColor;
+        if (!leftButtonDisabledColor.hasValue()) leftButtonDisabledColor = defaultOptions.leftButtonDisabledColor;
+
         validate();
+        return this;
     }
 
     public void validate() {

lib/android/app/src/main/java/com/reactnativenavigation/parse/params/Button.java

     public Text testId = new NullText();
     public Component component = new Component();
 
-    protected static Button parseJson(JSONObject json, TypefaceLoader typefaceManager) {
+    private static Button parseJson(JSONObject json, TypefaceLoader typefaceManager) {
         Button button = new Button();
         button.id = json.optString("id");
         button.text = TextParser.parse(json, "text");
         return buttons;
     }
 
+    public Button copy() {
+        Button button = new Button();
+        button.mergeWith(this);
+        return button;
+    }
+
     public boolean hasComponent() {
         return component.hasValue();
     }
         if (other.component.hasValue()) component = other.component;
         if (other.showAsAction.hasValue()) showAsAction = other.showAsAction;
         if (other.icon.hasValue()) icon = other.icon;
+        if (other.id != null) id = other.id;
     }
 
     public void mergeWithDefault(Button defaultOptions) {

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

 import android.app.Activity;
 import android.content.Context;
 import android.graphics.Color;
+import android.support.annotation.Nullable;
 import android.view.View;
 import android.view.ViewGroup.LayoutParams;
 
 import com.reactnativenavigation.parse.TopBarOptions;
 import com.reactnativenavigation.parse.TopTabOptions;
 import com.reactnativenavigation.parse.TopTabsOptions;
+import com.reactnativenavigation.parse.params.Button;
 import com.reactnativenavigation.utils.UiUtils;
 import com.reactnativenavigation.viewcontrollers.IReactView;
 import com.reactnativenavigation.views.Component;
 import com.reactnativenavigation.views.topbar.TopBar;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public class StackOptionsPresenter {
     private static final int DEFAULT_TITLE_COLOR = Color.BLACK;
     private static final int DEFAULT_SUBTITLE_COLOR = Color.GRAY;
     private static final int DEFAULT_BORDER_COLOR = Color.BLACK;
+    private static final double DEFAULT_ELEVATION = 4d;
     private final double defaultTitleFontSize;
     private final double defaultSubtitleFontSize;
 
     }
 
     public void applyChildOptions(Options options, Component child) {
-        Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
-        applyOrientation(withDefaultOptions.layout.orientation);
-        applyButtons(withDefaultOptions.topBar.buttons);
-        applyTopBarOptions(withDefaultOptions.topBar, withDefaultOptions.animations, child, options);
-        applyTopTabsOptions(withDefaultOptions.topTabs);
-        applyTopTabOptions(withDefaultOptions.topTabOptions);
+        Options withDefault = options.copy().withDefaultOptions(defaultOptions);
+        applyOrientation(withDefault.layout.orientation);
+        applyButtons(withDefault.topBar, withDefault.topBar.rightButtonColor, withDefault.topBar.leftButtonColor, withDefault.topBar.rightButtonDisabledColor, withDefault.topBar.leftButtonDisabledColor);
+        applyTopBarOptions(withDefault.topBar, withDefault.animations, child, options);
+        applyTopTabsOptions(withDefault.topTabs);
+        applyTopTabOptions(withDefault.topTabOptions);
     }
 
     public void applyOrientation(OrientationOptions options) {
 
     private void applyTopBarOptions(TopBarOptions options, AnimationsOptions animationOptions, Component component, Options componentOptions) {
         topBar.setHeight(options.height.get(LayoutParams.WRAP_CONTENT));
-        topBar.setElevation(options.elevation.get(4d));
+        topBar.setElevation(options.elevation.get(DEFAULT_ELEVATION));
 
         topBar.setTitleHeight(options.title.height.get(LayoutParams.WRAP_CONTENT));
         topBar.setTitle(options.title.text.get(""));
         }
     }
 
-    private void applyButtons(TopBarButtons buttons) {
-        topBar.setLeftButtons(buttons.left);
-        topBar.setRightButtons(buttons.right);
-        if (buttons.back.visible.isTrue() && !buttons.hasLeftButtons()) topBar.setBackButton(buttons.back);
+    private void applyButtons(TopBarOptions options, com.reactnativenavigation.parse.params.Color rightButtonColor, com.reactnativenavigation.parse.params.Color leftButtonColor, com.reactnativenavigation.parse.params.Color rightButtonDisabledColor, com.reactnativenavigation.parse.params.Color leftButtonDisabledColor) {
+        List<Button> rightButtons = mergeButtonsWithColor(options.buttons.right, rightButtonColor, rightButtonDisabledColor);
+        List<Button> leftButtons = mergeButtonsWithColor(options.buttons.left, leftButtonColor, leftButtonDisabledColor);
+        topBar.setRightButtons(rightButtons);
+        topBar.setLeftButtons(leftButtons);
+        if (options.buttons.back.visible.isTrue() && !options.buttons.hasLeftButtons()) topBar.setBackButton(options.buttons.back);
     }
 
     private void applyTopTabsOptions(TopTabsOptions options) {
         }
     }
 
-    public void mergeChildOptions(Options options, Component child) {
+    public void mergeChildOptions(Options options, Options childOptions, Component child) {
+        TopBarOptions topBar = options.copy().mergeWith(childOptions).withDefaultOptions(defaultOptions).topBar;
         mergeOrientation(options.layout.orientation);
-        mergeButtons(options.topBar.buttons);
+        mergeButtons(options.topBar.buttons,
+                topBar.rightButtonColor,
+                topBar.leftButtonColor,
+                topBar.rightButtonDisabledColor,
+                topBar.leftButtonDisabledColor
+        );
         mergeTopBarOptions(options.topBar, options.animations, child);
         mergeTopTabsOptions(options.topTabs);
         mergeTopTabOptions(options.topTabOptions);
         if (orientationOptions.hasValue()) applyOrientation(orientationOptions);
     }
 
-    private void mergeButtons(TopBarButtons buttons) {
-        if (buttons.left != null) topBar.setLeftButtons(buttons.left);
-        if (buttons.right != null) topBar.setRightButtons(buttons.right);
+    private void mergeButtons(TopBarButtons buttons, com.reactnativenavigation.parse.params.Color rightButtonColor, com.reactnativenavigation.parse.params.Color leftButtonColor, com.reactnativenavigation.parse.params.Color rightButtonDisabledColor, com.reactnativenavigation.parse.params.Color leftButtonDisabledColor) {
+        List<Button> rightButtons = mergeButtonsWithColor(buttons.right, rightButtonColor, rightButtonDisabledColor);
+        List<Button> leftButtons = mergeButtonsWithColor(buttons.left, leftButtonColor, leftButtonDisabledColor);
+        if (buttons.right != null) topBar.setRightButtons(rightButtons);
+        if (buttons.left != null) topBar.setLeftButtons(leftButtons);
         if (buttons.back.hasValue()) topBar.setBackButton(buttons.back);
     }
 
+    @Nullable
+    private List<Button> mergeButtonsWithColor(List<Button> buttons, com.reactnativenavigation.parse.params.Color buttonColor, com.reactnativenavigation.parse.params.Color disabledColor) {
+        List<Button> result = null;
+        if (buttons != null) {
+            result = new ArrayList<>();
+            for (Button button : buttons) {
+                Button copy = button.copy();
+                if (!button.color.hasValue()) copy.color = buttonColor;
+                if (!button.disabledColor.hasValue()) copy.disabledColor = disabledColor;
+                result.add(copy);
+            }
+        }
+        return result;
+    }
+
     private void mergeTopBarOptions(TopBarOptions options, AnimationsOptions animationsOptions, Component component) {
         if (options.height.hasValue()) topBar.setHeight(options.height.get());
         if (options.elevation.hasValue()) topBar.setElevation(options.elevation.get());

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/TopBarButtonController.java

     private TopBarButtonController.OnClickListener onPressListener;
     private Drawable icon;
 
-    public TopBarButtonController(Activity activity, NavigationIconResolver navigationIconResolver, ImageLoader imageLoader, ButtonOptionsPresenter optionsPresenter, Button button, ReactViewCreator viewCreator, OnClickListener onClickListener) {
+    public TopBarButtonController(Activity activity,
+                                  NavigationIconResolver navigationIconResolver,
+                                  ImageLoader imageLoader,
+                                  ButtonOptionsPresenter optionsPresenter,
+                                  Button button,
+                                  ReactViewCreator viewCreator,
+                                  OnClickListener onClickListener) {
         super(activity, button.id, new Options());
         this.navigationIconResolver = navigationIconResolver;
         this.imageLoader = imageLoader;

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/StackController.java

     @Override
     public void mergeChildOptions(Options options, Component child) {
         super.mergeChildOptions(options, child);
-        presenter.mergeChildOptions(options, child);
+        presenter.mergeChildOptions(options, resolveCurrentOptions(), child);
         if (options.fabOptions.hasValue() && child instanceof ReactComponent) {
             fabOptionsPresenter.mergeOptions(options.fabOptions, (ReactComponent) child, getView());
         }

lib/android/app/src/main/java/com/reactnativenavigation/views/topbar/TopBar.java

 import com.reactnativenavigation.utils.CompatUtils;
 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.UiUtils;
-import com.reactnativenavigation.utils.ViewUtils;
 import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
 import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
     private TopBarAnimator animator;
     private TopTabs topTabs;
     private FrameLayout root;
-    private LinearLayout content;
-    private StackLayout parentView;
     private TopBarBackgroundViewController topBarBackgroundViewController;
     private View border;
     private ImageLoader imageLoader;
         this.imageLoader = imageLoader;
         collapsingBehavior = new TopBarCollapseBehavior(this);
         this.topBarBackgroundViewController = topBarBackgroundViewController;
-        this.parentView = parentView;
         topTabs = new TopTabs(getContext());
         animator = new TopBarAnimator(this, parentView.getStackId());
         createLayout(buttonCreator, titleBarReactViewCreator, onClickListener);
         titleBar = createTitleBar(getContext(), buttonCreator, titleBarReactViewCreator, onClickListener, imageLoader);
         topTabs = createTopTabs();
         border = createBorder();
-        content = createContentLayout();
+        LinearLayout content = createContentLayout();
 
         root = new FrameLayout(getContext());
         root.setId(CompatUtils.generateViewId());
     public void setBackgroundComponent(Component component) {
         if (component.hasValue()) {
             topBarBackgroundViewController.setComponent(component);
-            RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(MATCH_PARENT, ViewUtils.getPreferredHeight(this));
+            RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT);
             root.addView(topBarBackgroundViewController.getView(), 0, lp);
         }
     }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/StackOptionsPresenterTest.java

 import com.reactnativenavigation.parse.SubtitleOptions;
 import com.reactnativenavigation.parse.TitleOptions;
 import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.parse.params.Button;
 import com.reactnativenavigation.parse.params.Color;
 import com.reactnativenavigation.parse.params.Fraction;
 import com.reactnativenavigation.parse.params.Number;
 
 import org.json.JSONObject;
 import org.junit.Test;
+import org.mockito.ArgumentCaptor;
 import org.mockito.Mockito;
 
 import java.util.ArrayList;
+import java.util.List;
 
+import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyBoolean;
 import static org.mockito.ArgumentMatchers.anyDouble;
 
 public class StackOptionsPresenterTest extends BaseTest {
 
+    private static final Options EMPTY_OPTIONS = new Options();
     private StackOptionsPresenter uut;
     private TestComponentLayout child;
     private Activity activity;
     @Test
     public void mergeOrientation() throws Exception {
         Options options = new Options();
-        uut.mergeChildOptions(options, child);
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, child);
         verify(uut, times(0)).applyOrientation(any());
 
         JSONObject orientation = new JSONObject().put("orientation", "landscape");
         options.layout.orientation = OrientationOptions.parse(orientation);
-        uut.mergeChildOptions(options, child);
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, child);
         verify(uut, times(1)).applyOrientation(options.layout.orientation);
     }
 
     @Test
     public void mergeButtons() {
         Options options = new Options();
-        uut.mergeChildOptions(options, child);
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, child);
         verify(topBar, times(0)).setRightButtons(any());
         verify(topBar, times(0)).setLeftButtons(any());
 
         options.topBar.buttons.right = new ArrayList<>();
-        uut.mergeChildOptions(options, child);
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, child);
         verify(topBar, times(1)).setRightButtons(any());
 
         options.topBar.buttons.left = new ArrayList<>();
-        uut.mergeChildOptions(options, child);
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, child);
         verify(topBar, times(1)).setLeftButtons(any());
     }
 
     @Test
     public void mergeTopBarOptions() {
         Options options = new Options();
-        uut.mergeChildOptions(options, child);
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, child);
         assertTopBarOptions(options, 0);
 
         TitleOptions title = new TitleOptions();
         options.topBar.drawBehind = new Bool(false);
         options.topBar.hideOnScroll = new Bool(false);
         options.topBar.validate();
-        uut.mergeChildOptions(options, child);
+
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, child);
 
         assertTopBarOptions(options, 1);
 
         options.topBar.drawBehind = new Bool(true);
-        uut.mergeChildOptions(options, child);
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, child);
         verify(child, times(1)).drawBehindTopBar();
     }
 
     @Test
     public void mergeTopTabsOptions() {
         Options options = new Options();
-        uut.mergeChildOptions(options, child);
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, child);
         verify(topBar, times(0)).applyTopTabsColors(any(), any());
         verify(topBar, times(0)).applyTopTabsFontSize(any());
         verify(topBar, times(0)).setTopTabsVisible(anyBoolean());
         options.topTabs.unselectedTabColor = new Color(1);
         options.topTabs.fontSize = new Number(1);
         options.topTabs.visible = new Bool(true);
-        uut.mergeChildOptions(options, child);
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, child);
         verify(topBar, times(1)).applyTopTabsColors(options.topTabs.selectedTabColor, options.topTabs.unselectedTabColor);
         verify(topBar, times(1)).applyTopTabsFontSize(options.topTabs.fontSize);
         verify(topBar, times(1)).setTopTabsVisible(anyBoolean());
     @Test
     public void mergeTopTabOptions() {
         Options options = new Options();
-        uut.mergeChildOptions(options, child);
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, child);
 
         verify(topBar, times(0)).setTopTabFontFamily(anyInt(), any());
 
         options.topTabOptions.tabIndex = 1;
         options.topTabOptions.fontFamily = Typeface.DEFAULT_BOLD;
-        uut.mergeChildOptions(options, child);
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, child);
 
         verify(topBar, times(1)).setTopTabFontFamily(1, Typeface.DEFAULT_BOLD);
     }
 
         Options childOptions = new Options();
         childOptions.topBar.title.text = new Text("someText");
-        uut.mergeChildOptions(childOptions, child);
+        uut.mergeChildOptions(childOptions, EMPTY_OPTIONS, child);
 
         verify(topBar, times(0)).setBackgroundColor(anyInt());
     }
 
+    public void applyButtons_buttonColorIsMergedToButtons() {
+        Options options = new Options();
+        Button rightButton1 = new Button();
+        Button rightButton2 = new Button();
+        Button leftButton = new Button();
+
+        options.topBar.rightButtonColor = new Color(10);
+        options.topBar.leftButtonColor = new Color(100);
+
+        options.topBar.buttons.right = new ArrayList<>();
+        options.topBar.buttons.right.add(rightButton1);
+        options.topBar.buttons.right.add(rightButton2);
+
+        options.topBar.buttons.left = new ArrayList<>();
+        options.topBar.buttons.left.add(leftButton);
+
+        uut.applyChildOptions(options, child);
+        ArgumentCaptor<List<Button>> rightCaptor = ArgumentCaptor.forClass(List.class);
+        verify(topBar).setRightButtons(rightCaptor.capture());
+        assertThat(rightCaptor.getValue().get(0).color.get()).isEqualTo(options.topBar.rightButtonColor.get());
+        assertThat(rightCaptor.getValue().get(1).color.get()).isEqualTo(options.topBar.rightButtonColor.get());
+        assertThat(rightCaptor.getValue().get(0)).isNotEqualTo(rightButton1);
+        assertThat(rightCaptor.getValue().get(1)).isNotEqualTo(rightButton2);
+
+        ArgumentCaptor<List<Button>> leftCaptor = ArgumentCaptor.forClass(List.class);
+        verify(topBar).setLeftButtons(leftCaptor.capture());
+        assertThat(leftCaptor.getValue().get(0).color).isEqualTo(options.topBar.leftButtonColor);
+        assertThat(leftCaptor.getValue().get(0)).isNotEqualTo(leftButton);
+    }
+
+    @Test
+    public void mergeChildOptions_buttonColorIsResolvedFromAppliedOptions() {
+        Options appliedOptions = new Options();
+        appliedOptions.topBar.rightButtonColor = new Color(10);
+        appliedOptions.topBar.leftButtonColor = new Color(100);
+
+        Options options2 = new Options();
+        Button rightButton1 = new Button();
+        Button rightButton2 = new Button();
+        Button leftButton = new Button();
+
+        options2.topBar.buttons.right = new ArrayList<>();
+        options2.topBar.buttons.right.add(rightButton1);
+        options2.topBar.buttons.right.add(rightButton2);
+
+        options2.topBar.buttons.left = new ArrayList<>();
+        options2.topBar.buttons.left.add(leftButton);
+
+        uut.mergeChildOptions(options2, appliedOptions, child);
+        ArgumentCaptor<List<Button>> rightCaptor = ArgumentCaptor.forClass(List.class);
+        verify(topBar, times(1)).setRightButtons(rightCaptor.capture());
+        assertThat(rightCaptor.getValue().get(0).color.get()).isEqualTo(appliedOptions.topBar.rightButtonColor.get());
+        assertThat(rightCaptor.getValue().get(1).color.get()).isEqualTo(appliedOptions.topBar.rightButtonColor.get());
+        assertThat(rightCaptor.getValue().get(0)).isNotEqualTo(rightButton1);
+        assertThat(rightCaptor.getValue().get(1)).isNotEqualTo(rightButton2);
+
+        ArgumentCaptor<List<Button>> leftCaptor = ArgumentCaptor.forClass(List.class);
+        verify(topBar, times(1)).setLeftButtons(leftCaptor.capture());
+        assertThat(leftCaptor.getValue().get(0).color.get()).isEqualTo(appliedOptions.topBar.leftButtonColor.get());
+        assertThat(leftCaptor.getValue().get(0)).isNotEqualTo(leftButton);
+    }
+
+    @Test
+    public void mergeChildOptions_buttonColorIsResolvedFromMergedOptions() {
+        Options resolvedOptions = new Options();
+        resolvedOptions.topBar.rightButtonColor = new Color(10);
+        resolvedOptions.topBar.leftButtonColor = new Color(100);
+
+        Options options2 = new Options();
+        Button rightButton1 = new Button();
+        Button rightButton2 = new Button();
+        Button leftButton = new Button();
+
+        options2.topBar.buttons.right = new ArrayList<>();
+        options2.topBar.buttons.right.add(rightButton1);
+        options2.topBar.buttons.right.add(rightButton2);
+
+        options2.topBar.buttons.left = new ArrayList<>();
+        options2.topBar.buttons.left.add(leftButton);
+
+        uut.mergeChildOptions(options2, resolvedOptions, child);
+        ArgumentCaptor<List<Button>> rightCaptor = ArgumentCaptor.forClass(List.class);
+        verify(topBar).setRightButtons(rightCaptor.capture());
+        assertThat(rightCaptor.getValue().get(0).color.get()).isEqualTo(resolvedOptions.topBar.rightButtonColor.get());
+        assertThat(rightCaptor.getValue().get(1).color.get()).isEqualTo(resolvedOptions.topBar.rightButtonColor.get());
+        assertThat(rightCaptor.getValue().get(0)).isNotEqualTo(rightButton1);
+        assertThat(rightCaptor.getValue().get(1)).isNotEqualTo(rightButton2);
+
+        ArgumentCaptor<List<Button>> leftCaptor = ArgumentCaptor.forClass(List.class);
+        verify(topBar).setLeftButtons(leftCaptor.capture());
+        assertThat(leftCaptor.getValue().get(0).color.get()).isEqualTo(resolvedOptions.topBar.leftButtonColor.get());
+        assertThat(leftCaptor.getValue().get(0)).isNotEqualTo(leftButton);
+    }
+
     private void assertTopBarOptions(Options options, int t) {
         if (options.topBar.title.component.hasValue()) {
             verify(topBar, times(0)).setTitle(any());

lib/android/app/src/test/java/com/reactnativenavigation/views/TopBarBackgroundComponentTest.java

         TopBarBackgroundView background = (TopBarBackgroundView) ViewUtils.findChildrenByClassRecursive(uut, TopBarBackgroundView.class).get(0);
         assertThat(background).isNotNull();
         assertThat(background.getLayoutParams().width).isEqualTo(ViewGroup.LayoutParams.MATCH_PARENT);
-        assertThat(background.getLayoutParams().height).isEqualTo(100);
+        assertThat(background.getLayoutParams().height).isEqualTo(ViewGroup.LayoutParams.MATCH_PARENT);
     }
 
     @Test

lib/ios/RNNNavigationButtons.m

 	NSMutableDictionary* disabledTextAttributes = [[NSMutableDictionary alloc] init];
 	
 	UIColor* color = [self color:dictionary[@"color"] defaultColor:defaultStyle.color];
+	UIColor* disabledColor = [self color:dictionary[@"disabledColor"] defaultColor:defaultStyle.disabledColor];
+	if (!enabledBool && disabledColor) {
+		color = disabledColor;
+		[disabledTextAttributes setObject:disabledColor forKey:NSForegroundColorAttributeName];
+	}
+	
 	if (color) {
 		[textAttributes setObject:color forKey:NSForegroundColorAttributeName];
 		[barButtonItem setImage:iconImage];
 		[barButtonItem setTintColor:color];
 	}
 	
-	UIColor* disabledColor = [self color:dictionary[@"disabledColor"] defaultColor:defaultStyle.disabledColor];;
-	if (disabledColor) {
-		UIColor *color = disabledColor;
-		[disabledTextAttributes setObject:color forKey:NSForegroundColorAttributeName];
-	}
-	
 	NSNumber* fontSize = [self fontSize:dictionary[@"fontSize"] defaultFontSize:defaultStyle.fontSize];
 	NSString* fontFamily = [self fontFamily:dictionary[@"fontFamily"] defaultFontFamily:defaultStyle.fontFamily];
 	UIFont *font = nil;

lib/ios/RNNTopBarOptions.h

 @property (nonatomic, strong) NSArray* rightButtons;
 @property (nonatomic, strong) NSNumber* visible;
 @property (nonatomic, strong) NSNumber* hideOnScroll;
-@property (nonatomic, strong) NSNumber* buttonColor;
+@property (nonatomic, strong) NSNumber* leftButtonColor;
+@property (nonatomic, strong) NSNumber* rightButtonColor;
+@property (nonatomic, strong) NSNumber* leftButtonDisabledColor;
+@property (nonatomic, strong) NSNumber* rightButtonDisabledColor;
 @property (nonatomic, strong) NSString* barStyle;
 @property (nonatomic, strong) NSNumber* translucent;
 @property (nonatomic, strong) NSNumber* transparent;

lib/ios/RNNTopBarOptions.m

 		viewController.navigationController.navigationBar.accessibilityIdentifier = self.testID;
 	}
 	
-	if (self.buttonColor) {
-		UIColor* buttonColor = [RCTConvert UIColor:self.buttonColor];
-		viewController.navigationController.navigationBar.tintColor = buttonColor;
-	} else {
-		viewController.navigationController.navigationBar.tintColor = nil;
-	}
-	
 	if (self.rightButtons || self.leftButtons) {
 		_navigationButtons = [[RNNNavigationButtons alloc] initWithViewController:(RNNRootViewController*)viewController];
 		[_navigationButtons applyLeftButtons:self.leftButtons rightButtons:self.rightButtons defaultLeftButtonStyle:self.leftButtonStyle defaultRightButtonStyle:self.rightButtonStyle];
 }
 
 - (void)setLeftButtons:(id)leftButtons {
+	if (self.leftButtonColor) {
+		_leftButtonStyle.color = self.leftButtonColor;
+	}
+	
+	if (self.leftButtonDisabledColor) {
+		_leftButtonStyle.disabledColor = self.leftButtonDisabledColor;
+	}
+	
 	if ([leftButtons isKindOfClass:[NSArray class]]) {
 		_leftButtons = leftButtons;
 	} else if ([leftButtons isKindOfClass:[NSDictionary class]]) {
 }
 
 - (void)setRightButtons:(id)rightButtons {
+	if (self.rightButtonColor) {
+		_rightButtonStyle.color = self.rightButtonColor;
+	}
+	
+	if (self.rightButtonDisabledColor) {
+		_rightButtonStyle.disabledColor = self.rightButtonDisabledColor;
+	}
+	
 	if ([rightButtons isKindOfClass:[NSArray class]]) {
 		_rightButtons = rightButtons;
 	} else if ([rightButtons isKindOfClass:[NSDictionary class]]) {

lib/src/commands/LayoutTreeCrawler.test.ts

     });
   });
 
-  it('Components: extract button style from passedOptions buttons array and merge it to all buttons', () => {
-    const MyComponent = class {
-      static get options() {
-        return {
-          topBar: {
-            leftButtons: [{
-              id: 'id'
-            }, {
-              id: 'id2'
-            }],
-            rightButtons: [{
-              id: 'id3'
-            }]
-          }
-        };
-      }
-    };
-
-    const passedOptions = {
-      topBar: {
-        leftButtons: {
-          font: 'Helvetica'
-        },
-        rightButtons: []
-      }
-    };
-
-    const node = { type: LayoutType.Component, data: { name: 'theComponentName', options: passedOptions } };
-    store.setOriginalComponentClassForName('theComponentName', MyComponent);
-
-    uut.crawl(node);
-
-    expect(node.data.options).toEqual({
-      topBar: {
-        leftButtons: [{
-          id: 'id',
-          font: 'Helvetica'
-        }, {
-          id: 'id2',
-          font: 'Helvetica'
-        }],
-        rightButtons: [{
-          id: 'id3'
-        }]
-      }
-    });
-  });
-
-  it('Components: empty buttons array should not affect static buttons', () => {
-    const MyComponent = class {
-      static get options() {
-        return {
-          topBar: {}
-        };
-      }
-    };
-
-    const passedOptions = {
-      topBar: {}
-    };
-
-    const node = { type: LayoutType.Component, data: { name: 'theComponentName', options: passedOptions } };
-    store.setOriginalComponentClassForName('theComponentName', MyComponent);
-
-    uut.crawl(node);
-
-    expect(node.data.options).toEqual({
-      topBar: {}
-    });
-  });
-
-  it('Components: static options with no topBar should not crash', () => {
-    const MyComponent = class {
-      static get options() {
-        return {
-
-        };
-      }
-    };
-
-    const passedOptions = {
-      topBar: {}
-    };
-
-    const node = { type: LayoutType.Component, data: { name: 'theComponentName', options: passedOptions } };
-    store.setOriginalComponentClassForName('theComponentName', MyComponent);
-
-    uut.crawl(node);
-
-    expect(node.data.options).toEqual({
-      topBar: {}
-    });
-  });
-
-  it('Components: undefined passed buttons should not affect static buttons', () => {
-    const MyComponent = class {
-      static get options() {
-        return {
-          topBar: {
-            leftButtons: [{
-              id: 'id'
-            }],
-            rightButtons: [{
-              id: 'id2'
-            }]
-          }
-        };
-      }
-    };
-
-    const passedOptions = {
-      topBar: {}
-    };
-
-    const node = { type: LayoutType.Component, data: { name: 'theComponentName', options: passedOptions } };
-    store.setOriginalComponentClassForName('theComponentName', MyComponent);
-
-    uut.crawl(node);
-
-    expect(node.data.options).toEqual({
-      topBar: {
-        leftButtons: [{
-          id: 'id'
-        }],
-        rightButtons: [{
-          id: 'id2'
-        }]
-      }
-    });
-  });
   it('Component: deepClones options', () => {
     const theStyle = {};
     const MyComponent = class {

lib/src/commands/LayoutTreeCrawler.ts

     const clazz = this.store.getOriginalComponentClassForName(node.data.name) || {};
     const staticOptions = _.cloneDeep(clazz.options) || {};
     const passedOptions = node.data.options || {};
-    this._mergeButtonsStyles(passedOptions, staticOptions);
     node.data.options = _.merge({}, staticOptions, passedOptions);
   }
 
-  _mergeButtonsStyles(passedOptions, staticOptions) {
-    if (passedOptions.topBar) {
-      this._normalizeButtons(passedOptions.topBar.leftButtons, (buttons, style) => {
-        passedOptions.topBar.leftButtons = buttons;
-
-        if (staticOptions.topBar) {
-          this._applyButtonsStyle(staticOptions.topBar.leftButtons, style);
-        }
-      });
-
-      this._normalizeButtons(passedOptions.topBar.rightButtons, (buttons, style) => {
-        passedOptions.topBar.rightButtons = buttons;
-
-        if (staticOptions.topBar) {
-          this._applyButtonsStyle(staticOptions.topBar.rightButtons, style);
-        }
-      });
-    }
-  }
-
-  _normalizeButtons(buttons, callback) {
-    if (_.isPlainObject(buttons)) {
-      callback([], buttons);
-    } else {
-      callback(buttons);
-    }
-  }
-
-  _applyButtonsStyle(buttons, style) {
-    if (_.isArray(buttons)) {
-      buttons.forEach((button) => {
-        _.merge(button, style);
-      });
-    }
-  }
-
   _assertKnownLayoutType(type) {
     if (!LayoutType[type]) {
       throw new Error(`Unknown layout type ${type}`);

playground/src/screens/PushedScreen.js

           id: 'singleBtn',
           text: 'single',
           testID: testIDs.TOP_BAR_BUTTON
-        }
+        },
+        rightButtonColor: 'red',
       },
       layout: {
         backgroundColor: '#f5fcff'