Remove animated option

Each animation (push, pop etc) can be enabled or disabled separately

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

 package com.reactnativenavigation.parse;
 
 
+import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.parse.params.NullBool;
+
 import org.json.JSONObject;
 
 public class NestedAnimationsOptions {
         return options;
     }
 
+    public Bool enabled = new NullBool();
     public AnimationOptions content = new AnimationOptions();
     public AnimationOptions bottomTabs = new AnimationOptions();
     public AnimationOptions topBar = new AnimationOptions();
         topBar.mergeWith(other.topBar);
         content.mergeWith(other.content);
         bottomTabs.mergeWith(other.bottomTabs);
+        if (other.enabled.hasValue()) enabled = other.enabled;
     }
 
     void mergeWithDefault(NestedAnimationsOptions defaultOptions) {
         content.mergeWithDefault(defaultOptions.content);
         bottomTabs.mergeWithDefault(defaultOptions.bottomTabs);
         topBar.mergeWithDefault(defaultOptions.topBar);
+        if (!enabled.hasValue()) enabled = defaultOptions.enabled;
     }
 
     public boolean hasValue() {

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

 import android.support.annotation.CheckResult;
 import android.support.annotation.NonNull;
 
-import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Color;
-import com.reactnativenavigation.parse.params.NullBool;
 import com.reactnativenavigation.parse.params.NullColor;
-import com.reactnativenavigation.parse.parsers.BoolParser;
 import com.reactnativenavigation.parse.parsers.ColorParser;
 import com.reactnativenavigation.utils.TypefaceLoader;
 
         if (json == null) return result.withDefaultOptions(defaultOptions);
 
         result.orientationOptions = OrientationOptions.parse(json);
-        result.topBarOptions = TopBarOptions.parse(typefaceManager, json.optJSONObject("topBar"));
+        result.topBar = TopBarOptions.parse(typefaceManager, json.optJSONObject("topBar"));
         result.topTabsOptions = TopTabsOptions.parse(json.optJSONObject("topTabs"));
         result.topTabOptions = TopTabOptions.parse(typefaceManager, json.optJSONObject("topTab"));
         result.bottomTabOptions = BottomTabOptions.parse(json.optJSONObject("bottomTab"));
         result.overlayOptions = OverlayOptions.parse(json.optJSONObject("overlay"));
         result.fabOptions = FabOptions.parse(json.optJSONObject("fab"));
         result.sideMenuRootOptions = SideMenuRootOptions.parse(json.optJSONObject("sideMenu"));
-        result.animationsOptions = AnimationsOptions.parse(json.optJSONObject("animations"));
-        result.animated = BoolParser.parse(json, "animated");
+        result.animations = AnimationsOptions.parse(json.optJSONObject("animations"));
         result.screenBackgroundColor = ColorParser.parse(json, "screenBackgroundColor");
 
         return result.withDefaultOptions(defaultOptions);
     }
 
     @NonNull public OrientationOptions orientationOptions = new OrientationOptions();
-    @NonNull public TopBarOptions topBarOptions = new TopBarOptions();
+    @NonNull public TopBarOptions topBar = new TopBarOptions();
     @NonNull public TopTabsOptions topTabsOptions = new TopTabsOptions();
     @NonNull public TopTabOptions topTabOptions = new TopTabOptions();
     @NonNull public BottomTabOptions bottomTabOptions = new BottomTabOptions();
     @NonNull public BottomTabsOptions bottomTabsOptions = new BottomTabsOptions();
     @NonNull public OverlayOptions overlayOptions = new OverlayOptions();
     @NonNull public FabOptions fabOptions = new FabOptions();
-    @NonNull public AnimationsOptions animationsOptions = new AnimationsOptions();
+    @NonNull public AnimationsOptions animations = new AnimationsOptions();
     @NonNull public SideMenuRootOptions sideMenuRootOptions = new SideMenuRootOptions();
-    @NonNull public Bool animated = new NullBool();
     @NonNull public Color screenBackgroundColor = new NullColor();
 
     void setTopTabIndex(int i) {
     public Options copy() {
         Options result = new Options();
         result.orientationOptions.mergeWith(orientationOptions);
-        result.topBarOptions.mergeWith(topBarOptions);
+        result.topBar.mergeWith(topBar);
         result.topTabsOptions.mergeWith(topTabsOptions);
         result.topTabOptions.mergeWith(topTabOptions);
         result.bottomTabOptions.mergeWith(bottomTabOptions);
         result.overlayOptions = overlayOptions;
         result.fabOptions.mergeWith(fabOptions);
         result.sideMenuRootOptions.mergeWith(sideMenuRootOptions);
-        result.animationsOptions.mergeWith(animationsOptions);
-        result.animated = animated;
+        result.animations.mergeWith(animations);
         result.screenBackgroundColor = screenBackgroundColor;
         return result;
     }
 	public Options mergeWith(final Options other) {
         Options result = copy();
         result.orientationOptions.mergeWith(other.orientationOptions);
-        result.topBarOptions.mergeWith(other.topBarOptions);
+        result.topBar.mergeWith(other.topBar);
         result.topTabsOptions.mergeWith(other.topTabsOptions);
         result.topTabOptions.mergeWith(other.topTabOptions);
         result.bottomTabOptions.mergeWith(other.bottomTabOptions);
         result.bottomTabsOptions.mergeWith(other.bottomTabsOptions);
         result.fabOptions.mergeWith(other.fabOptions);
-        result.animationsOptions.mergeWith(other.animationsOptions);
+        result.animations.mergeWith(other.animations);
         result.sideMenuRootOptions.mergeWith(other.sideMenuRootOptions);
-        if (other.animated.hasValue()) result.animated = other.animated;
-        if (other.screenBackgroundColor.hasValue()) {
-            result.screenBackgroundColor = other.screenBackgroundColor;
-        }
+        if (other.screenBackgroundColor.hasValue()) result.screenBackgroundColor = other.screenBackgroundColor;
         return result;
     }
 
     Options withDefaultOptions(final Options defaultOptions) {
         orientationOptions.mergeWithDefault(defaultOptions.orientationOptions);
-        topBarOptions.mergeWithDefault(defaultOptions.topBarOptions);
+        topBar.mergeWithDefault(defaultOptions.topBar);
         topTabOptions.mergeWithDefault(defaultOptions.topTabOptions);
         topTabsOptions.mergeWithDefault(defaultOptions.topTabsOptions);
         bottomTabOptions.mergeWithDefault(defaultOptions.bottomTabOptions);
         bottomTabsOptions.mergeWithDefault(defaultOptions.bottomTabsOptions);
         fabOptions.mergeWithDefault(defaultOptions.fabOptions);
-        animationsOptions.mergeWithDefault(defaultOptions.animationsOptions);
+        animations.mergeWithDefault(defaultOptions.animations);
         sideMenuRootOptions.mergeWithDefault(defaultOptions.sideMenuRootOptions);
-        if (!animated.hasValue()) animated = defaultOptions.animated;
-        if (!screenBackgroundColor.hasValue()) {
-            screenBackgroundColor = defaultOptions.screenBackgroundColor;
-        }
+        if (!screenBackgroundColor.hasValue()) screenBackgroundColor = defaultOptions.screenBackgroundColor;
         return this;
     }
 
     public Options clearTopBarOptions() {
-        topBarOptions = new TopBarOptions();
+        topBar = new TopBarOptions();
         return this;
     }
 
     }
 
     public Options clearAnimationOptions() {
-        animationsOptions = new AnimationsOptions();
+        animations = new AnimationsOptions();
         return this;
     }
 

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

     }
 
     public void present(Options options) {
-        applyBottomTabsOptions(options.bottomTabsOptions, options.animationsOptions);
+        applyBottomTabsOptions(options.bottomTabsOptions, options.animations);
     }
 
     public void present(Options options, int tabIndex) {

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

 import com.reactnativenavigation.parse.TopBarOptions;
 import com.reactnativenavigation.parse.TopTabOptions;
 import com.reactnativenavigation.parse.TopTabsOptions;
-import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Button;
 import com.reactnativenavigation.utils.UiUtils;
 import com.reactnativenavigation.viewcontrollers.IReactView;
 
     public void applyChildOptions(Options options, Component child) {
         applyOrientation(options.orientationOptions);
-        applyButtons(options.topBarOptions.leftButtons, options.topBarOptions.rightButtons);
-        applyTopBarOptions(options.topBarOptions, options.animationsOptions, child, options.animated);
+        applyButtons(options.topBar.leftButtons, options.topBar.rightButtons);
+        applyTopBarOptions(options.topBar, options.animations, child, options);
         applyTopTabsOptions(options.topTabsOptions);
         applyTopTabOptions(options.topTabOptions);
     }
         ((Activity) topBar.getContext()).setRequestedOrientation(options.getValue());
     }
 
-    private void applyTopBarOptions(TopBarOptions options, AnimationsOptions animationOptions, Component component, Bool animated) {
+    private void applyTopBarOptions(TopBarOptions options, AnimationsOptions animationOptions, Component component, Options componentOptions) {
         topBar.setTitle(options.title.text.get(""));
         if (options.title.component.hasValue()) topBar.setTitleComponent(options.title.component);
         topBar.setTitleFontSize(options.title.fontSize.get(defaultTitleFontSize));
         if (options.testId.hasValue()) topBar.setTestId(options.testId.get());
 
         if (options.visible.isFalse()) {
-            if (options.animate.isTrueOrUndefined() && animated.isTrueOrUndefined()) {
+            if (options.animate.isTrueOrUndefined() && componentOptions.animations.push.enabled.isTrueOrUndefined()) {
                 topBar.hideAnimate(animationOptions.pop.topBar);
             } else {
                 topBar.hide();
             }
         }
         if (options.visible.isTrueOrUndefined()) {
-            if (options.animate.isTrueOrUndefined() && animated.isTrueOrUndefined()) {
+            if (options.animate.isTrueOrUndefined() && componentOptions.animations.push.enabled.isTrueOrUndefined()) {
                 topBar.showAnimate(animationOptions.push.topBar);
             } else {
                 topBar.show();
         if (topTabOptions.fontFamily != null) topBar.setTopTabFontFamily(topTabOptions.tabIndex, topTabOptions.fontFamily);
     }
 
-    public void onChildWillDisappear(Options disappearing, Options appearing) {
-        if (disappearing.topBarOptions.visible.isTrueOrUndefined() && appearing.topBarOptions.visible.isFalse()) {
-            if (disappearing.topBarOptions.animate.isTrueOrUndefined() && disappearing.animated.isTrueOrUndefined()) {
-                topBar.hideAnimate(disappearing.animationsOptions.pop.topBar);
+    public void onChildWillPop(Options disappearing, Options appearing) {
+        if (disappearing.topBar.visible.isTrueOrUndefined() && appearing.topBar.visible.isFalse()) {
+            if (disappearing.topBar.animate.isTrueOrUndefined() && disappearing.animations.pop.enabled.isTrueOrUndefined()) {
+                topBar.hideAnimate(disappearing.animations.pop.topBar);
             } else {
                 topBar.hide();
             }
 
     public void mergeChildOptions(Options options, Component child) {
         mergeOrientation(options.orientationOptions);
-        mergeButtons(options.topBarOptions.leftButtons, options.topBarOptions.rightButtons);
-        mergeTopBarOptions(options.topBarOptions, options.animationsOptions, child);
+        mergeButtons(options.topBar.leftButtons, options.topBar.rightButtons);
+        mergeTopBarOptions(options.topBar, options.animations, child);
         mergeTopTabsOptions(options.topTabsOptions);
         mergeTopTabOptions(options.topTabOptions);
     }

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

         root = viewController;
         View view = viewController.getView();
 
-        AnimationsOptions animationsOptions = viewController.options.animationsOptions;
+        AnimationsOptions animationsOptions = viewController.options.animations;
         getView().addView(view);
         if (animationsOptions.startApp.hasValue()) {
             new NavigationAnimator(viewController.getActivity(), animationsOptions)

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

                         child
                 )
         );
-        animator.setOptions(options.animationsOptions);
+        animator.setOptions(options.animations);
     }
 
     @Override
     public void mergeChildOptions(Options options, Component child) {
         super.mergeChildOptions(options, child);
         getView().mergeChildOptions(options, child);
-        animator.mergeOptions(options.animationsOptions);
+        animator.mergeOptions(options.animations);
         if (options.fabOptions.hasValue() && child instanceof ReactComponent) {
             fabOptionsPresenter.mergeOptions(options.fabOptions, (ReactComponent) child, getView());
         }
         getView().addView(child.getView(), MATCH_PARENT, MATCH_PARENT);
 
         if (toRemove != null) {
-            if (child.options.animated.isTrueOrUndefined()) {
+            if (child.options.animations.push.enabled.isTrueOrUndefined()) {
                 animator.push(child.getView(), () -> {
                     getView().removeView(toRemove.getView());
                     listener.onSuccess(child.getId());
         disappearing.onViewWillDisappear();
         appearing.onViewWillAppear();
         getView().addView(appearing.getView(), 0);
-        getView().onChildWillDisappear(disappearing.options, appearing.options);
+        getView().onChildWillPop(disappearing.options, appearing.options);
 
-        if (disappearing.options.animated.isTrueOrUndefined()) {
+        if (disappearing.options.animations.pop.enabled.isTrueOrUndefined()) {
             animator.pop(disappearing.getView(), () -> finishPopping(disappearing, listener));
         } else {
             finishPopping(disappearing, listener);

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/modal/Modal.java

         dialog.setOnKeyListener(this);
         dialog.setOnDismissListener(this);
         dialog.setOnShowListener(this);
-        animator = new ModalAnimator(viewController.getActivity(), viewController.options.animationsOptions);
+        animator = new ModalAnimator(viewController.getActivity(), viewController.options.animations);
     }
 
     public void show() {

lib/android/app/src/main/java/com/reactnativenavigation/views/StackLayout.java

         optionsPresenter.applyChildOptions(options, child);
     }
 
-    public void onChildWillDisappear(Options disappearing, Options appearing) {
-        optionsPresenter.onChildWillDisappear(disappearing, appearing);
+    public void onChildWillPop(Options disappearing, Options appearing) {
+        optionsPresenter.onChildWillPop(disappearing, appearing);
     }
 
     public void mergeChildOptions(Options options, Component child) {

lib/android/app/src/test/java/com/reactnativenavigation/BaseTest.java

 import android.support.v7.app.*;
 import android.view.*;
 
+import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.viewcontrollers.ViewController;
+
 import org.junit.*;
 import org.junit.runner.*;
 import org.robolectric.*;
         assertThat(child.getId()).isNotZero().isPositive();
         assertThat(parent.findViewById(child.getId())).isNull();
     }
+
+    protected void disablePushAnimation(ViewController... controllers) {
+        for (ViewController controller : controllers) {
+            controller.options.animations.push.enabled = new Bool(false);
+        }
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/parse/OptionsTest.java

     }
 
     private void assertResult(Options result) {
-        assertThat(result.topBarOptions.title.text.get()).isEqualTo(TITLE);
-        assertThat(result.topBarOptions.background.color.get()).isEqualTo(TOP_BAR_BACKGROUND_COLOR);
-        assertThat(result.topBarOptions.title.color.get()).isEqualTo(TOP_BAR_TEXT_COLOR);
-        assertThat(result.topBarOptions.title.fontSize.get()).isEqualTo(TOP_BAR_FONT_SIZE);
-        assertThat(result.topBarOptions.title.fontFamily).isEqualTo(TOP_BAR_TYPEFACE);
-        assertThat(result.topBarOptions.subtitle.color.get()).isEqualTo(SUBTITLE_TEXT_COLOR);
-        assertThat(result.topBarOptions.subtitle.fontSize.get()).isEqualTo(SUBTITLE_FONT_SIZE);
-        assertThat(result.topBarOptions.subtitle.alignment).isEqualTo(Alignment.fromString(SUBTITLE_ALIGNMENT));
-        assertThat(result.topBarOptions.subtitle.fontFamily).isEqualTo(SUBTITLE_TYPEFACE);
-        assertThat(result.topBarOptions.visible.get()).isEqualTo(TOP_BAR_VISIBLE.get());
-        assertThat(result.topBarOptions.drawBehind.get()).isEqualTo(TOP_BAR_DRAW_BEHIND.get());
-        assertThat(result.topBarOptions.hideOnScroll.get()).isEqualTo(TOP_BAR_HIDE_ON_SCROLL.get());
+        assertThat(result.topBar.title.text.get()).isEqualTo(TITLE);
+        assertThat(result.topBar.background.color.get()).isEqualTo(TOP_BAR_BACKGROUND_COLOR);
+        assertThat(result.topBar.title.color.get()).isEqualTo(TOP_BAR_TEXT_COLOR);
+        assertThat(result.topBar.title.fontSize.get()).isEqualTo(TOP_BAR_FONT_SIZE);
+        assertThat(result.topBar.title.fontFamily).isEqualTo(TOP_BAR_TYPEFACE);
+        assertThat(result.topBar.subtitle.color.get()).isEqualTo(SUBTITLE_TEXT_COLOR);
+        assertThat(result.topBar.subtitle.fontSize.get()).isEqualTo(SUBTITLE_FONT_SIZE);
+        assertThat(result.topBar.subtitle.alignment).isEqualTo(Alignment.fromString(SUBTITLE_ALIGNMENT));
+        assertThat(result.topBar.subtitle.fontFamily).isEqualTo(SUBTITLE_TYPEFACE);
+        assertThat(result.topBar.visible.get()).isEqualTo(TOP_BAR_VISIBLE.get());
+        assertThat(result.topBar.drawBehind.get()).isEqualTo(TOP_BAR_DRAW_BEHIND.get());
+        assertThat(result.topBar.hideOnScroll.get()).isEqualTo(TOP_BAR_HIDE_ON_SCROLL.get());
         assertThat(result.bottomTabsOptions.animate.get()).isEqualTo(BOTTOM_TABS_ANIMATE.get());
         assertThat(result.bottomTabsOptions.visible.get()).isEqualTo(BOTTOM_TABS_VISIBLE.get());
         assertThat(result.bottomTabsOptions.currentTabId.get()).isEqualTo(BOTTOM_TABS_CURRENT_TAB_ID);
         JSONObject json1 = new JSONObject();
         json1.put("topBar", createTopBar(true));
         Options options1 = Options.parse(mockLoader, json1);
-        options1.topBarOptions.title.text = new Text("some title");
+        options1.topBar.title.text = new Text("some title");
 
         JSONObject json2 = new JSONObject();
         json2.put("topBar", createTopBar(false));
         Options options2 = Options.parse(mockLoader, json2);
-        options2.topBarOptions.title.text = new NullText();
+        options2.topBar.title.text = new NullText();
 
         Options merged = options1.mergeWith(options2);
-        assertThat(options1.topBarOptions.visible.get()).isTrue();
-        assertThat(merged.topBarOptions.visible.get()).isFalse();
-        assertThat(merged.topBarOptions.title.text.get()).isEqualTo("some title");
+        assertThat(options1.topBar.visible.get()).isTrue();
+        assertThat(merged.topBar.visible.get()).isFalse();
+        assertThat(merged.topBar.title.text.get()).isEqualTo("some title");
     }
 
     @Test
     @Test
     public void defaultEmptyOptions() {
         Options uut = new Options();
-        assertThat(uut.topBarOptions.title.text.get("")).isEmpty();
+        assertThat(uut.topBar.title.text.get("")).isEmpty();
         assertThat(uut.screenBackgroundColor.hasValue()).isFalse();
 
     }
     @Test
     public void topBar_defaultOptions() {
         Options uut = new Options();
-        assertThat(uut.topBarOptions.visible.isFalseOrUndefined()).isTrue();
-        assertThat(uut.topBarOptions.animate.isTrueOrUndefined()).isTrue();
+        assertThat(uut.topBar.visible.isFalseOrUndefined()).isTrue();
+        assertThat(uut.topBar.animate.isTrueOrUndefined()).isTrue();
     }
 
     @Test
     public void clear_topBarOptions() {
         Options uut = new Options();
-        uut.topBarOptions.title.text = new Text("some title");
+        uut.topBar.title.text = new Text("some title");
         uut.clearTopBarOptions();
-        assertThat(uut.topBarOptions.title.text.hasValue()).isFalse();
+        assertThat(uut.topBar.title.text.hasValue()).isFalse();
     }
 
     @Test

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

 import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
 import com.reactnativenavigation.parse.FabOptions;
 import com.reactnativenavigation.parse.Options;
-import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Text;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
     @NonNull
     private Options getOptionsWithFab() {
         Options options = new Options();
-        options.animated = new Bool(false);
         FabOptions fabOptions = new FabOptions();
         fabOptions.id = new Text("FAB");
         options.fabOptions = fabOptions;
 
     @Test
     public void hideOnPop() {
+        disablePushAnimation(childNoFab, childFab);
         stackController.push(childNoFab, new CommandListenerAdapter());
         stackController.push(childFab, new CommandListenerAdapter());
         childFab.onViewAppeared();
 
     @Test
     public void showOnPop() {
-        childFab.options.animated = new Bool(false);
-        childNoFab.options.animated = new Bool(false);
-
+        disablePushAnimation(childFab, childNoFab);
         stackController.push(childFab, new CommandListenerAdapter());
         stackController.push(childNoFab, new CommandListenerAdapter());
         childNoFab.onViewAppeared();

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

 
     @Test
     public void setStackRoot() {
-        child1.options.animated = new Bool(false);
-        child2.options.animated = new Bool(false);
-        child3.options.animated = new Bool(false);
+        disablePushAnimation(child1, child2, child3);
 
         StackController stack = newStack();
         uut.setRoot(stack, new MockPromise());
     public void setOptions_CallsApplyNavigationOptions() {
         ComponentViewController componentVc = new SimpleComponentViewController(activity, "theId", new Options());
         componentVc.setParentController(parentController);
-        assertThat(componentVc.options.topBarOptions.title.text.get("")).isEmpty();
+        assertThat(componentVc.options.topBar.title.text.get("")).isEmpty();
         uut.setRoot(componentVc, new MockPromise());
 
         Options options = new Options();
-        options.topBarOptions.title.text = new Text("new title");
+        options.topBar.title.text = new Text("new title");
 
         uut.setOptions("theId", options);
-        assertThat(componentVc.options.topBarOptions.title.text.get()).isEqualTo("new title");
+        assertThat(componentVc.options.topBar.title.text.get()).isEqualTo("new title");
     }
 
     @Test
 
     @Test
     public void pushedStackCanBePopped() {
-        child1.options.animated = new Bool(false);
-        child2.options.animated = new Bool(false);
+        child1.options.animations.push.enabled = new Bool(false);
+        child2.options.animations.push.enabled = new Bool(false);
         StackController parent = newStack();
         parent.ensureViewIsCreated();
         uut.setRoot(parent, new MockPromise());

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

 
     @Test
     public void initialOptionsAppliedOnAppear() {
-        uut.options.topBarOptions.title.text = new Text("the title");
+        uut.options.topBar.title.text = new Text("the title");
         StackController stackController =
                 new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()), new TopBarController(), "stackId", new Options());
         stackController.push(uut, new CommandListenerAdapter());
     @Test
     public void mergeNavigationOptionsUpdatesCurrentOptions() {
         uut.ensureViewIsCreated();
-        assertThat(uut.options.topBarOptions.title.text.get("")).isEmpty();
+        assertThat(uut.options.topBar.title.text.get("")).isEmpty();
         Options options = new Options();
-        options.topBarOptions.title.text = new Text("new title");
+        options.topBar.title.text = new Text("new title");
         uut.mergeOptions(options);
-        assertThat(uut.options.topBarOptions.title.text.get()).isEqualTo("new title");
+        assertThat(uut.options.topBar.title.text.get()).isEqualTo("new title");
     }
 
     @Test
         assertThat(stackController.getTopBar().getTitle()).isEmpty();
 
         Options opts = new Options();
-        opts.topBarOptions.title.text = new Text("the new title");
+        opts.topBar.title.text = new Text("the new title");
         uut.mergeOptions(opts);
 
         assertThat(stackController.getTopBar().getTitle()).isEqualTo("the new title");
         uut.onViewAppeared();
 
         Options opts = new Options();
-        opts.topBarOptions.background.color = new com.reactnativenavigation.parse.params.Color(Color.RED);
+        opts.topBar.background.color = new com.reactnativenavigation.parse.params.Color(Color.RED);
         uut.mergeOptions(opts);
 
         assertThat(((ColorDrawable) stackController.getTopBar().getTitleBar().getBackground()).getColor()).isEqualTo(Color.RED);
             @Override
             public void onSuccess(String childId) {
                 Options opts = new Options();
-                opts.topBarOptions.title.text = new Text("the title");
-                opts.topBarOptions.title.color = new com.reactnativenavigation.parse.params.Color(Color.RED);
+                opts.topBar.title.text = new Text("the title");
+                opts.topBar.title.color = new com.reactnativenavigation.parse.params.Color(Color.RED);
                 uut.mergeOptions(opts);
 
                 assertThat(stackController.getTopBar().getTitleTextView()).isNotEqualTo(null);
     @Test
     public void appliesTopBarTextSize() {
         assertThat(uut.initialOptions).isSameAs(initialNavigationOptions);
-        initialNavigationOptions.topBarOptions.title.text = new Text("the title");
+        initialNavigationOptions.topBar.title.text = new Text("the title");
         uut.ensureViewIsCreated();
         uut.onViewAppeared();
 
         Options opts = new Options();
-        opts.topBarOptions.title.text = new Text("the title");
-        opts.topBarOptions.title.fontSize = new Fraction(18);
+        opts.topBar.title.text = new Text("the title");
+        opts.topBar.title.fontSize = new Fraction(18);
         uut.mergeOptions(opts);
 
         assertThat(stackController.getTopBar().getTitleTextView()).isNotEqualTo(null);
     @Test
     public void appliesTopBarVisible() {
         assertThat(uut.initialOptions).isSameAs(initialNavigationOptions);
-        initialNavigationOptions.topBarOptions.title.text = new Text("the title");
+        initialNavigationOptions.topBar.title.text = new Text("the title");
         uut.ensureViewIsCreated();
         uut.onViewAppeared();
         assertThat(stackController.getTopBar().getVisibility()).isNotEqualTo(View.GONE);
 
         Options opts = new Options();
-        opts.topBarOptions.visible = new Bool(false);
-        opts.topBarOptions.animate = new Bool(false);
+        opts.topBar.visible = new Bool(false);
+        opts.topBar.animate = new Bool(false);
         uut.mergeOptions(opts);
 
         assertThat(stackController.getTopBar().getVisibility()).isEqualTo(View.GONE);
 
     @Test
     public void appliesDrawUnder() {
-        uut.options.topBarOptions.title.text = new Text("the title");
-        uut.options.topBarOptions.drawBehind = new Bool(false);
+        uut.options.topBar.title.text = new Text("the title");
+        uut.options.topBar.drawBehind = new Bool(false);
         uut.ensureViewIsCreated();
         stackController.ensureViewIsCreated();
         stackController.push(uut, new CommandListenerAdapter() {
                 assertThat(uutLayoutParams.topMargin).isNotEqualTo(0);
 
                 Options opts = new Options();
-                opts.topBarOptions.drawBehind = new Bool(true);
+                opts.topBar.drawBehind = new Bool(true);
                 uut.mergeOptions(opts);
 
                 uutLayoutParams = (RelativeLayout.LayoutParams) (uut.getComponent().asView()).getLayoutParams();
     public void appliesTopBarComponent() throws Exception {
         JSONObject json = new JSONObject();
         json.put("component", new JSONObject().put("name","someComponent").put("componentId", "id"));
-        uut.options.topBarOptions.background = TopBarBackgroundOptions.parse(json);
+        uut.options.topBar.background = TopBarBackgroundOptions.parse(json);
         uut.ensureViewIsCreated();
         stackController.push(uut, new CommandListenerAdapter());
         uut.onViewAppeared();
     public void appliesSubtitle() throws Exception {
         JSONObject json = new JSONObject();
         json.put("text", "sub");
-        uut.options.topBarOptions.subtitle = SubtitleOptions.parse(new TypefaceLoaderMock(), json);
+        uut.options.topBar.subtitle = SubtitleOptions.parse(new TypefaceLoaderMock(), json);
         uut.ensureViewIsCreated();
         stackController.push(uut, new CommandListenerAdapter());
         uut.onViewAppeared();

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

         verify(topBar, times(0)).setRightButtons(any());
         verify(topBar, times(0)).setLeftButtons(any());
 
-        options.topBarOptions.rightButtons = new ArrayList<>();
+        options.topBar.rightButtons = new ArrayList<>();
         uut.mergeChildOptions(options, child);
         verify(topBar, times(1)).setRightButtons(any());
 
-        options.topBarOptions.leftButtons = new ArrayList<>();
+        options.topBar.leftButtons = new ArrayList<>();
         uut.mergeChildOptions(options, child);
         verify(topBar, times(1)).setLeftButtons(any());
     }
         titleOptions.color = new Color(0);
         titleOptions.fontSize = new Fraction(1.0f);
         titleOptions.fontFamily = Typeface.DEFAULT_BOLD;
-        options.topBarOptions.title = titleOptions;
+        options.topBar.title = titleOptions;
         SubtitleOptions subtitleOptions = new SubtitleOptions();
         subtitleOptions.text = new Text("Sub");
         subtitleOptions.color = new Color(1);
-        options.topBarOptions.subtitle = subtitleOptions;
-        options.topBarOptions.background.color = new Color(0);
-        options.topBarOptions.testId = new Text("test123");
-        options.topBarOptions.animate = new Bool(false);
-        options.topBarOptions.visible = new Bool(false);
-        options.topBarOptions.drawBehind = new Bool(false);
-        options.topBarOptions.hideOnScroll = new Bool(false);
+        options.topBar.subtitle = subtitleOptions;
+        options.topBar.background.color = new Color(0);
+        options.topBar.testId = new Text("test123");
+        options.topBar.animate = new Bool(false);
+        options.topBar.visible = new Bool(false);
+        options.topBar.drawBehind = new Bool(false);
+        options.topBar.hideOnScroll = new Bool(false);
         uut.mergeChildOptions(options, child);
 
         assertTopBarOptions(1);
 
-        options.topBarOptions.drawBehind = new Bool(true);
+        options.topBar.drawBehind = new Bool(true);
         uut.mergeChildOptions(options, child);
         verify(child, times(1)).drawBehindTopBar();
     }

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

         activity = newActivity();
         children = new ArrayList<>();
         Options initialOptions = new Options();
-        initialOptions.topBarOptions.title.text = new Text(INITIAL_TITLE);
+        initialOptions.topBar.title.text = new Text(INITIAL_TITLE);
         uut = spy(new ParentController(activity, "uut", initialOptions) {
 
             @NonNull
     @Test
     public void mergeOptions_optionsAreMergedWhenChildAppears() {
         Options options = new Options();
-        options.topBarOptions.title.text = new Text("new title");
+        options.topBar.title.text = new Text("new title");
         ViewController child1 = spy(new SimpleViewController(activity, "child1", options));
         children.add(child1);
         uut.ensureViewIsCreated();
         ArgumentCaptor<ReactComponent> viewCaptor = ArgumentCaptor.forClass(ReactComponent.class);
         verify(uut, times(1)).clearOptions();
         verify(uut, times(1)).applyChildOptions(optionsCaptor.capture(), viewCaptor.capture());
-        assertThat(optionsCaptor.getValue().topBarOptions.title.text.get()).isEqualTo("new title");
+        assertThat(optionsCaptor.getValue().topBar.title.text.get()).isEqualTo("new title");
         assertThat(viewCaptor.getValue()).isEqualTo(child1.getView());
     }
 
     @Test
     public void mergeOptions_initialParentOptionsAreNotMutatedWhenChildAppears() {
         Options options = new Options();
-        options.topBarOptions.title.text = new Text("new title");
+        options.topBar.title.text = new Text("new title");
         ViewController child1 = spy(new SimpleViewController(activity, "child1", options));
         children.add(child1);
 
 
         child1.ensureViewIsCreated();
         child1.onViewAppeared();
-        assertThat(uut.initialOptions.topBarOptions.title.text.get()).isEqualTo(INITIAL_TITLE);
+        assertThat(uut.initialOptions.topBar.title.text.get()).isEqualTo(INITIAL_TITLE);
     }
 
     private StackController createStack() {

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

                 uut.pop(new CommandListenerAdapter() {
                     @Override
                     public void onSuccess(String childId) {
-                        verify(stackLayout[0], times(1)).onChildWillDisappear(child2.options, child1.options);
+                        verify(stackLayout[0], times(1)).onChildWillPop(child2.options, child1.options);
                     }
                 });
             }
         uut.ensureViewIsCreated();
         child1.ensureViewIsCreated();
 
-        child1.options.topBarOptions.visible = new Bool(false);
-        child1.options.topBarOptions.animate = new Bool(false);
-        child1.options.animated = new Bool(false);
-        child2.options.animated = new Bool(false);
+        child1.options.topBar.visible = new Bool(false);
+        child1.options.topBar.animate = new Bool(false);
+        disablePushAnimation(child1, child2);
 
         uut.push(child1, new CommandListenerAdapter() {
             @Override
 
                 uut.push(child2, new CommandListenerAdapter());
                 child2.onViewAppeared();
-                verify(uut.getTopBar(), times(0)).showAnimate(child2.options.animationsOptions.push.topBar);
+                verify(uut.getTopBar(), times(0)).showAnimate(child2.options.animations.push.topBar);
                 assertThat(uut.getTopBar().getVisibility()).isEqualTo(View.VISIBLE);
                 verify(uut.getTopBar(), times(1)).resetAnimationOptions();
             }
     public void push_animatesAndClearsPreviousAnimationValues() {
         uut.ensureViewIsCreated();
 
-        child1.options.topBarOptions.visible = new Bool(false);
-        child1.options.topBarOptions.animate = new Bool(false);
-        child1.options.animated = new Bool(false);
+        child1.options.topBar.visible = new Bool(false);
+        child1.options.topBar.animate = new Bool(false);
+        child1.options.animations.push.enabled = new Bool(false);
 
         uut.push(child1, new CommandListenerAdapter());
         uut.push(child2, new CommandListenerAdapter() {
 
     @Test
     public void popToRoot_PopsEverythingAboveFirstController() {
-        child1.options.animated = new Bool(false);
-        child2.options.animated = new Bool(false);
+        child1.options.animations.push.enabled = new Bool(false);
+        child2.options.animations.push.enabled = new Bool(false);
 
         uut.push(child1, new CommandListenerAdapter());
         uut.push(child2, new CommandListenerAdapter());
 
     @Test
     public void popToRoot_onlyTopChildIsAnimated() {
-        child1.options.animated = new Bool(false);
-        child2.options.animated = new Bool(false);
+        child1.options.animations.push.enabled = new Bool(false);
+        child2.options.animations.push.enabled = new Bool(false);
 
         uut.push(child1, new CommandListenerAdapter());
         uut.push(child2, new CommandListenerAdapter());
         uut.push(child3, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
-                child1.options.animated = new Bool(true);
-                child2.options.animated = new Bool(true);
                 uut.popToRoot(new CommandListenerAdapter() {
                     @Override
                     public void onSuccess(String childId) {
 
     @Test
     public void popToRoot_topChildrenAreDestroyed() {
-        child1.options.animated = new Bool(false);
-        child2.options.animated = new Bool(false);
-        child3.options.animated = new Bool(false);
+        child1.options.animations.push.enabled = new Bool(false);
+        child2.options.animations.push.enabled = new Bool(false);
+        child3.options.animations.push.enabled = new Bool(false);
 
         uut.push(child1, new CommandListenerAdapter());
         uut.push(child2, new CommandListenerAdapter());
 
     @Test
     public void pop_callWillAppearWillDisappear() {
-        child1.options.animated = new Bool(false);
-        child2.options.animated = new Bool(false);
+        child1.options.animations.push.enabled = new Bool(false);
+        child2.options.animations.push.enabled = new Bool(false);
         child1 = spy(child1);
         child2 = spy(child2);
         uut.push(child1, new CommandListenerAdapter());
     public void pop_animatesTopBar() {
         uut.ensureViewIsCreated();
 
-        child1.options.topBarOptions.visible = new Bool(false);
-        child1.options.animated = new Bool(false);
-        child2.options.animated = new Bool(true);
+        child1.options.topBar.visible = new Bool(false);
+        child1.options.animations.push.enabled = new Bool(false);
+        child2.options.animations.push.enabled = new Bool(true);
         uut.push(child1, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
                         uut.pop(new CommandListenerAdapter() {
                             @Override
                             public void onSuccess(String childId) {
-                                verify(uut.getTopBar(), times(1)).hideAnimate(child2.options.animationsOptions.pop.topBar);
+                                verify(uut.getTopBar(), times(1)).hideAnimate(child2.options.animations.pop.topBar);
                             }
                         });
                     }
     public void pop_doesNotAnimateTopBarIfScreenIsPushedWithoutAnimation() {
         uut.ensureViewIsCreated();
 
-        child1.options.topBarOptions.visible = new Bool(false);
-        child2.options.animated = new Bool(false);
+        child1.options.topBar.visible = new Bool(false);
+        child1.options.topBar.animate = new Bool(false);
+        child2.options.animations.push.enabled = new Bool(false);
+        child2.options.topBar.animate = new Bool(false);
+
         child1.ensureViewIsCreated();
         uut.push(child1, new CommandListenerAdapter() {
             @Override
                 assertThat(uut.getTopBar().getVisibility()).isEqualTo(View.VISIBLE);
 
                 uut.pop(new CommandListenerAdapter());
-                verify(uut.getTopBar(), times(0)).hideAnimate(child2.options.animationsOptions.pop.topBar);
+                verify(uut.getTopBar(), times(0)).hideAnimate(child2.options.animations.pop.topBar);
                 assertThat(uut.getTopBar().getVisibility()).isEqualTo(View.GONE);
             }
         });
         parent.push(uut, new CommandListenerAdapter());
 
         Options childOptions = new Options();
-        childOptions.topBarOptions.title.text = new Text("Something");
+        childOptions.topBar.title.text = new Text("Something");
         child1.options = childOptions;
         uut.push(child1, new CommandListenerAdapter());
         child1.ensureViewIsCreated();
         ArgumentCaptor<Options> optionsCaptor = ArgumentCaptor.forClass(Options.class);
         ArgumentCaptor<ReactComponent> viewCaptor = ArgumentCaptor.forClass(ReactComponent.class);
         verify(parent, times(1)).applyChildOptions(optionsCaptor.capture(), viewCaptor.capture());
-        assertThat(optionsCaptor.getValue().topBarOptions.title.text.hasValue()).isFalse();
+        assertThat(optionsCaptor.getValue().topBar.title.text.hasValue()).isFalse();
     }
 
     @Test
         ParentController parentController = Mockito.mock(ParentController.class);
         uut.setParentController(parentController);
         Options optionsToMerge = new Options();
-        optionsToMerge.topBarOptions.testId = new Text("topBarID");
+        optionsToMerge.topBar.testId = new Text("topBarID");
         optionsToMerge.bottomTabsOptions.testId = new Text("bottomTabsID");
         Component component = mock(Component.class);
         uut.mergeChildOptions(optionsToMerge, component);
 
         ArgumentCaptor<Options> captor = ArgumentCaptor.forClass(Options.class);
         verify(parentController, times(1)).mergeChildOptions(captor.capture(), eq(component));
-        assertThat(captor.getValue().topBarOptions.testId.hasValue()).isFalse();
+        assertThat(captor.getValue().topBar.testId.hasValue()).isFalse();
         assertThat(captor.getValue().bottomTabsOptions.testId.get()).isEqualTo(optionsToMerge.bottomTabsOptions.testId.get());
     }
 
         Component component = mock(Component.class);
 
         uut.mergeChildOptions(options, component);
-        verify(animator, times(0)).setOptions(options.animationsOptions);
-        verify(animator, times(1)).mergeOptions(options.animationsOptions);
+        verify(animator, times(0)).setOptions(options.animations);
+        verify(animator, times(1)).mergeOptions(options.animations);
     }
 
     @Test
         ParentController parentController = Mockito.mock(ParentController.class);
         uut.setParentController(parentController);
         Options options = new Options();
-        options.animationsOptions.push = NestedAnimationsOptions.parse(new JSONObject());
-        options.topBarOptions.testId = new Text("id");
+        options.animations.push = NestedAnimationsOptions.parse(new JSONObject());
+        options.topBar.testId = new Text("id");
         options.fabOptions.id = new Text("fabId");
         Component component = mock(Component.class);
 
         uut.mergeChildOptions(options, component);
         ArgumentCaptor<Options> captor = ArgumentCaptor.forClass(Options.class);
         verify(parentController, times(1)).mergeChildOptions(captor.capture(), eq(component));
-        assertThat(captor.getValue().animationsOptions.push.hasValue()).isFalse();
-        assertThat(captor.getValue().topBarOptions.testId.hasValue()).isFalse();
+        assertThat(captor.getValue().animations.push.hasValue()).isFalse();
+        assertThat(captor.getValue().topBar.testId.hasValue()).isFalse();
         assertThat(captor.getValue().fabOptions.hasValue()).isFalse();
     }
 

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

         for (int i = 0; i < SIZE; i++) {
             final Options options = new Options();
             options.topTabOptions.title = new Text("Tab " + i);
-            options.topBarOptions.title.text = new Text(createTabTopBarTitle(i));
+            options.topBar.title.text = new Text(createTabTopBarTitle(i));
             result.add(options);
         }
         return result;
         uut.onViewAppeared();
         ReactComponent currentTab = tabView(0);
         verify(uut, times(1)).applyChildOptions(any(Options.class), eq(currentTab));
-        assertThat(uut.options.topBarOptions.title.text.get()).isEqualTo(createTabTopBarTitle(0));
+        assertThat(uut.options.topBar.title.text.get()).isEqualTo(createTabTopBarTitle(0));
 
         uut.switchToTab(1);
         currentTab = tabView(1);
         verify(uut, times(1)).applyChildOptions(any(Options.class), eq(currentTab));
-        assertThat(uut.options.topBarOptions.title.text.get()).isEqualTo(createTabTopBarTitle(1));
+        assertThat(uut.options.topBar.title.text.get()).isEqualTo(createTabTopBarTitle(1));
 
         uut.switchToTab(0);
         currentTab = tabView(0);
         verify(uut, times(2)).applyChildOptions(any(Options.class), eq(currentTab));
-        assertThat(uut.options.topBarOptions.title.text.get()).isEqualTo(createTabTopBarTitle(0));
+        assertThat(uut.options.topBar.title.text.get()).isEqualTo(createTabTopBarTitle(0));
     }
 
     private TestReactView getActualTabView(int index) {
                 new TestComponentViewCreator(),
                 new Options()
         );
-        first.options.animated = new Bool(false);
-        uut.options.animated = new Bool(false);
+        first.options.animations.push.enabled = new Bool(false);
+        uut.options.animations.push.enabled = new Bool(false);
         stackController.push(first, new CommandListenerAdapter());
         stackController.push(uut, new CommandListenerAdapter());