@nativescript-community/ui-material-core 6.2.14 → 6.2.17

package/tab-navigation-base/tab-navigation/index.ios.js

@@ -0,0 +1,794 @@
+import { Color, Device, Font, Frame, IOSHelper, ImageSource, Property, Utils, View, ViewBase, booleanConverter } from '@nativescript/core';
+import { TabContentItem } from '../tab-content-item';
+import { getIconSpecSize, itemsProperty, selectedIndexProperty, tabStripProperty } from '../tab-navigation-base';
+import { TabStrip } from '../tab-strip';
+import { TabStripItem } from '../tab-strip-item';
+import { TabNavigationBase, swipeEnabledProperty } from './index-common';
+export { TabContentItem, TabStrip, TabStripItem };
+const majorVersion = Utils.ios.MajorVersion;
+const isPhone = Device.deviceType === 'Phone';
+const invokeOnRunLoop = (function () {
+    const runloop = CFRunLoopGetMain();
+    return (action) => {
+        CFRunLoopPerformBlock(runloop, kCFRunLoopDefaultMode, action);
+        CFRunLoopWakeUp(runloop);
+    };
+})();
+var BackgroundIndicatorTemplate = /** @class */ (function (_super) {
+    __extends(BackgroundIndicatorTemplate, _super);
+    function BackgroundIndicatorTemplate() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    BackgroundIndicatorTemplate.prototype.indicatorAttributesForContext = function (context) {
+        var attributes = new MDCTabBarViewIndicatorAttributes();
+        attributes.path = UIBezierPath.bezierPathWithRect(context.bounds);
+        return attributes;
+    };
+    BackgroundIndicatorTemplate.ObjCProtocols = [MDCTabBarViewIndicatorTemplate];
+    return BackgroundIndicatorTemplate;
+}(NSObject));
+var UIPageViewControllerDataSourceImpl = /** @class */ (function (_super) {
+    __extends(UIPageViewControllerDataSourceImpl, _super);
+    function UIPageViewControllerDataSourceImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UIPageViewControllerDataSourceImpl.initWithOwner = function (owner) {
+        var dataSource = UIPageViewControllerDataSourceImpl.new();
+        dataSource._owner = owner;
+        return dataSource;
+    };
+    UIPageViewControllerDataSourceImpl.prototype.pageViewControllerViewControllerBeforeViewController = function (pageViewController, viewController) {
+        // if (traceEnabled()) {
+        //     traceWrite("TabView.delegate.SHOULD_select(" + tabBarController + ", " + viewController + ");", traceCategories.Debug);
+        // }
+        var owner = this._owner.get();
+        var selectedIndex = owner.selectedIndex;
+        if (selectedIndex === 0) {
+            return null;
+        }
+        selectedIndex--;
+        var prevItem = owner.items[selectedIndex];
+        var prevViewController = prevItem.__controller;
+        // if (!prevViewController) {
+        //     prevViewController = owner.getViewController(prevItem);
+        // }
+        owner._setCanBeLoaded(selectedIndex);
+        owner._loadUnloadTabItems(selectedIndex);
+        return prevViewController;
+    };
+    UIPageViewControllerDataSourceImpl.prototype.pageViewControllerViewControllerAfterViewController = function (pageViewController, viewController) {
+        // if (Trace.isEnabled()) {
+        //     traceWrite('TabView.delegate.SHOULD_select(' + tabBarController + ', ' + viewController + ');', traceCategories.Debug);
+        // }
+        var owner = this._owner.get();
+        var selectedIndex = owner.selectedIndex;
+        if (selectedIndex === owner.items.length - 1) {
+            return null;
+        }
+        selectedIndex++;
+        var nextItem = owner.items[selectedIndex];
+        var nextViewController = nextItem.__controller;
+        // if (!nextViewController) {
+        //     nextViewController = owner.getViewController(nextItem);
+        // }
+        owner._setCanBeLoaded(selectedIndex);
+        owner._loadUnloadTabItems(selectedIndex);
+        // nextItem.loadView(nextItem.view);
+        return nextViewController;
+    };
+    UIPageViewControllerDataSourceImpl.prototype.presentationCountForPageViewController = function (pageViewController) {
+        // TODO
+        // if (traceEnabled()) {
+        //     traceWrite("TabView.delegate.SHOULD_select(" + tabBarController + ", " + viewController + ");", traceCategories.Debug);
+        // }
+        return 0;
+    };
+    UIPageViewControllerDataSourceImpl.prototype.presentationIndexForPageViewController = function (pageViewController) {
+        // TODO
+        // if (traceEnabled()) {
+        //     traceWrite("TabView.delegate.SHOULD_select(" + tabBarController + ", " + viewController + ");", traceCategories.Debug);
+        // }
+        return 0;
+    };
+    UIPageViewControllerDataSourceImpl.ObjCProtocols = [UIPageViewControllerDataSource];
+    return UIPageViewControllerDataSourceImpl;
+}(NSObject));
+var UIPageViewControllerDelegateImpl = /** @class */ (function (_super) {
+    __extends(UIPageViewControllerDelegateImpl, _super);
+    function UIPageViewControllerDelegateImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UIPageViewControllerDelegateImpl.initWithOwner = function (owner) {
+        var delegate = UIPageViewControllerDelegateImpl.new();
+        delegate._owner = owner;
+        return delegate;
+    };
+    UIPageViewControllerDelegateImpl.prototype.pageViewControllerWillTransitionToViewControllers = function (pageViewController, viewControllers) {
+        // const owner = this._owner.get();
+        // const ownerViewControllers = owner.viewControllers;
+        // const selectedIndex = owner.selectedIndex;
+        // const nextViewController = viewControllers[0];
+        // const nextViewControllerIndex = ownerViewControllers.indexOf(nextViewController);
+        // if (selectedIndex > nextViewControllerIndex) {
+        //     owner.selectedIndex--;
+        // } else {
+        //     owner.selectedIndex++;
+        // }
+    };
+    UIPageViewControllerDelegateImpl.prototype.pageViewControllerDidFinishAnimatingPreviousViewControllersTransitionCompleted = function (pageViewController, didFinishAnimating, previousViewControllers, transitionCompleted) {
+        if (!transitionCompleted) {
+            return;
+        }
+        var owner = this._owner.get();
+        var ownerViewControllers = owner.viewControllers;
+        var selectedIndex = owner.selectedIndex;
+        var nextViewController = pageViewController.viewControllers[0];
+        var nextViewControllerIndex = ownerViewControllers.indexOf(nextViewController);
+        if (selectedIndex !== nextViewControllerIndex) {
+            // let s not animate again on selectedIndex change
+            // or it will create weird behaviors
+            owner.mAnimateNextChange = false;
+            owner.selectedIndex = nextViewControllerIndex;
+            owner.finishTabTransition();
+        }
+        // HACK: UIPageViewController fix; see https://stackoverflow.com/questions/15325891
+        if (owner.mNeedsCacheUpdate) {
+            invokeOnRunLoop(function () {
+                owner.mNeedsCacheUpdate = false;
+                var viewController = owner.viewController;
+                viewController.dataSource = null;
+                viewController.dataSource = owner._dataSource;
+            });
+        }
+    };
+    UIPageViewControllerDelegateImpl.ObjCProtocols = [UIPageViewControllerDelegate];
+    return UIPageViewControllerDelegateImpl;
+}(NSObject));
+function iterateIndexRange(index, eps, lastIndex, callback) {
+    const rangeStart = Math.max(0, index - eps);
+    const rangeEnd = Math.min(index + eps, lastIndex);
+    for (let i = rangeStart; i <= rangeEnd; i++) {
+        callback(i);
+    }
+}
+export function updateBackgroundPositions(tabStrip, tabStripItem, color = null) {
+    if (!tabStrip.nativeView || tabStripItem._index === undefined) {
+        return;
+    }
+    let bgView = tabStripItem.bgView;
+    const index = tabStripItem._index;
+    const width = tabStrip.nativeView.frame.size.width / tabStrip.items.filter((s) => s._index !== undefined).length;
+    const frame = CGRectMake(width * index, 0, width, tabStrip.nativeView.frame.size.width);
+    if (!bgView) {
+        bgView = UIView.alloc().initWithFrame(frame);
+        tabStrip.nativeView.insertSubviewAtIndex(bgView, 0);
+        tabStripItem.bgView = bgView;
+    }
+    else {
+        bgView.frame = frame;
+    }
+    const backgroundColor = tabStripItem.style.backgroundColor;
+    bgView.backgroundColor = color || (backgroundColor instanceof Color ? backgroundColor.ios : backgroundColor);
+}
+export function updateTitleAndIconPositions(tabStripItem, tabBarItem, controller) {
+    if (!tabStripItem || !tabBarItem) {
+        return;
+    }
+    const orientation = controller.interfaceOrientation;
+    const isPortrait = orientation !== 4 && orientation !== 3;
+    const isIconAboveTitle = majorVersion < 11 || (isPhone && isPortrait);
+    if (!tabStripItem.iconSource) {
+        if (isIconAboveTitle) {
+            tabBarItem.titlePositionAdjustment = { horizontal: 0, vertical: -20 };
+        }
+        else {
+            tabBarItem.titlePositionAdjustment = { horizontal: 0, vertical: 0 };
+        }
+    }
+    if (!tabStripItem.title) {
+        if (isIconAboveTitle) {
+            tabBarItem.imageInsets = new UIEdgeInsets({ top: 6, left: 0, bottom: -6, right: 0 });
+        }
+        else {
+            tabBarItem.imageInsets = new UIEdgeInsets({ top: 0, left: 0, bottom: 0, right: 0 });
+        }
+    }
+}
+export const iosCustomPositioningProperty = new Property({
+    name: 'iosCustomPositioning',
+    defaultValue: false,
+    valueConverter: booleanConverter
+});
+export class TabNavigation extends TabNavigationBase {
+    constructor() {
+        super();
+        this.mIconsCache = {};
+        this.mNeedsCacheUpdate = false;
+        this.mAnimateNextChange = true;
+        this.mLayoutPending = false;
+        this.viewController = this.createViewController();
+    }
+    createNativeView() {
+        return this.viewController.view;
+    }
+    initNativeView() {
+        super.initNativeView();
+        this.mDataSource = UIPageViewControllerDataSourceImpl.initWithOwner(new WeakRef(this));
+        this.mDelegate = UIPageViewControllerDelegateImpl.initWithOwner(new WeakRef(this));
+    }
+    disposeNativeView() {
+        this.mDataSource = null;
+        this.mDelegate = null;
+        super.disposeNativeView();
+    }
+    requestLayout() {
+        if (!this.mCanSelectItem) {
+            this.mLayoutPending = true;
+        }
+        else {
+            this.mLayoutPending = false;
+            super.requestLayout();
+        }
+    }
+    beginTabTransition() {
+        this.mCanSelectItem = false;
+    }
+    finishTabTransition() {
+        this.mCanSelectItem = true;
+        if (this.mLayoutPending) {
+            this.requestLayout();
+        }
+    }
+    onLoaded() {
+        super.onLoaded();
+        this.setViewControllers(this.items);
+        const selectedIndex = this.selectedIndex;
+        const selectedView = this.items && this.items[selectedIndex] && this.items[selectedIndex].content;
+        if (selectedView instanceof Frame) {
+            selectedView._pushInFrameStackRecursive();
+        }
+        this.viewController.dataSource = this.mDataSource;
+        this.viewController.delegate = this.mDelegate;
+    }
+    onUnloaded() {
+        this.viewController.dataSource = null;
+        this.viewController.delegate = null;
+        super.onUnloaded();
+        this.items.forEach((item, i) => {
+            item.unloadView(item.content);
+        });
+    }
+    get ios() {
+        return this.viewController;
+    }
+    layoutNativeView(left, top, right, bottom) {
+        if (this.iosCustomPositioning) {
+            super.layoutNativeView(left, top, right, bottom);
+        }
+    }
+    _setNativeViewFrame(nativeView, frame) {
+        if (this.iosCustomPositioning) {
+            super._setNativeViewFrame(nativeView, frame);
+        }
+    }
+    onSelectedIndexChanged(oldIndex, newIndex) {
+        const items = this.items;
+        if (!items) {
+            return;
+        }
+        const oldItem = items[oldIndex];
+        if (this.unloadOnTabChange && oldItem) {
+            oldItem.canBeLoaded = false;
+            oldItem.unloadView(oldItem.content);
+        }
+        const newItem = items[newIndex];
+        if (newItem && this.isLoaded) {
+            const selectedView = items[newIndex].content;
+            if (selectedView instanceof Frame) {
+                selectedView._pushInFrameStackRecursive();
+            }
+            newItem.canBeLoaded = true;
+            newItem.loadView(newItem.content);
+        }
+        const tabStripItems = this.tabStrip && this.tabStrip.items;
+        if (tabStripItems) {
+            if (tabStripItems[newIndex]) {
+                tabStripItems[newIndex]._emit(TabStripItem.selectEvent);
+                this.updateItemColors(tabStripItems[newIndex]);
+            }
+            if (tabStripItems[oldIndex]) {
+                tabStripItems[oldIndex]._emit(TabStripItem.unselectEvent);
+                this.updateItemColors(tabStripItems[oldIndex]);
+            }
+        }
+        this._loadUnloadTabItems(newIndex);
+        super.onSelectedIndexChanged(oldIndex, newIndex);
+    }
+    _loadUnloadTabItems(newIndex) {
+        const items = this.items;
+        if (!items) {
+            return;
+        }
+        const lastIndex = items.length - 1;
+        const offsideItems = this.offscreenTabLimit;
+        const toUnload = [];
+        const toLoad = [];
+        iterateIndexRange(newIndex, offsideItems, lastIndex, (i) => toLoad.push(i));
+        if (this.unloadOnTabChange) {
+            items.forEach((item, i) => {
+                const indexOfI = toLoad.indexOf(i);
+                if (indexOfI < 0) {
+                    toUnload.push(i);
+                }
+            });
+            toUnload.forEach((index) => {
+                const item = items[index];
+                if (items[index]) {
+                    item.unloadView(item.content);
+                }
+            });
+        }
+        const newItem = items[newIndex];
+        const selectedView = newItem && newItem.content;
+        if (selectedView instanceof Frame) {
+            selectedView._pushInFrameStackRecursive();
+        }
+        toLoad.forEach((index) => {
+            const item = items[index];
+            if (this.isLoaded && items[index]) {
+                item.loadView(item.content);
+            }
+        });
+    }
+    onMeasure(widthMeasureSpec, heightMeasureSpec) {
+        const width = Utils.layout.getMeasureSpecSize(widthMeasureSpec);
+        const widthMode = Utils.layout.getMeasureSpecMode(widthMeasureSpec);
+        const height = Utils.layout.getMeasureSpecSize(heightMeasureSpec);
+        const heightMode = Utils.layout.getMeasureSpecMode(heightMeasureSpec);
+        const widthAndState = View.resolveSizeAndState(width, width, widthMode, 0);
+        const heightAndState = View.resolveSizeAndState(height, height, heightMode, 0);
+        this.setMeasuredDimension(widthAndState, heightAndState);
+    }
+    _onViewControllerShown(viewController) {
+        if (this.viewController.viewControllers && this.viewController.viewControllers.containsObject(viewController)) {
+            this.selectedIndex = this.viewController.viewControllers.indexOfObject(viewController);
+        }
+        else {
+        }
+    }
+    getViewController(item) {
+        let newController = item.content ? item.content.viewController : null;
+        if (newController) {
+            item.setViewController(newController, newController.view);
+            return newController;
+        }
+        if (item.content.ios instanceof UIViewController) {
+            newController = item.content.ios;
+            item.setViewController(newController, newController.view);
+        }
+        else if (item.content.ios && item.content.ios.controller instanceof UIViewController) {
+            newController = item.content.ios.controller;
+            item.setViewController(newController, newController.view);
+        }
+        else {
+            newController = IOSHelper.UILayoutViewController.initWithOwner(new WeakRef(item.content));
+            newController.view.addSubview(item.content.nativeViewProtected);
+            item.content.viewController = newController;
+            item.setViewController(newController, item.content.nativeViewProtected);
+        }
+        return newController;
+    }
+    _setCanBeLoaded(index) {
+        const items = this.items;
+        if (!this.items) {
+            return;
+        }
+        const lastIndex = items.length - 1;
+        const offsideItems = this.offscreenTabLimit;
+        iterateIndexRange(index, offsideItems, lastIndex, (i) => {
+            if (items[i]) {
+                items[i].canBeLoaded = true;
+            }
+        });
+    }
+    setViewControllers(items) {
+        const length = items ? items.length : 0;
+        if (length === 0) {
+            this.viewControllers = null;
+            return;
+        }
+        const viewControllers = [];
+        const tabBarItems = [];
+        if (this.tabStrip) {
+            this.tabStrip.setNativeView(this.viewController.tabBar);
+        }
+        const tabStripItems = this.tabStrip && this.tabStrip.items;
+        if (tabStripItems) {
+            if (tabStripItems[this.selectedIndex]) {
+                tabStripItems[this.selectedIndex]._emit(TabStripItem.selectEvent);
+            }
+        }
+        items.forEach((item, i) => {
+            const controller = this.getViewController(item);
+            if (this.tabStrip && this.tabStrip.items && this.tabStrip.items[i]) {
+                const tabStripItem = this.tabStrip.items[i];
+                const tabBarItem = this.createTabBarItem(tabStripItem, i);
+                updateTitleAndIconPositions(tabStripItem, tabBarItem, controller);
+                this.setViewTextAttributes(tabStripItem.label, i === this.selectedIndex);
+                controller.tabBarItem = tabBarItem;
+                tabStripItem._index = i;
+                tabBarItems.push(tabBarItem);
+                tabStripItem.setNativeView(tabBarItem);
+            }
+            item.canBeLoaded = true;
+            viewControllers.push(controller);
+        });
+        this.setItemImages();
+        this.viewControllers = viewControllers;
+        this.tabBarItems = tabBarItems;
+        if (this.viewController && this.viewController.tabBar) {
+            this.viewController.tabBar.items = NSArray.arrayWithArray(this.tabBarItems);
+            this.viewController.tabBar.sizeToFit();
+            this.viewController.tabBar.setSelectedItemAnimated(this.tabBarItems[this.selectedIndex], false);
+        }
+    }
+    onItemsChanged(oldItems, newItems) {
+        this.mNeedsCacheUpdate = true;
+        super.onItemsChanged(oldItems, newItems);
+        if (oldItems) {
+            if (!this.mCanSelectItem) {
+                this.finishTabTransition();
+            }
+            this._setCanBeLoaded(this.selectedIndex);
+            this._loadUnloadTabItems(this.selectedIndex);
+        }
+    }
+    setItemImages() {
+        if (this.mSelectedItemColor || this.mUnSelectedItemColor) {
+            if (this.tabStrip && this.tabStrip.items) {
+                this.tabStrip.items.forEach((item) => {
+                    if (this.mUnSelectedItemColor && item.nativeView) {
+                        item.nativeView.image = this.getIcon(item, this.mUnSelectedItemColor);
+                    }
+                    if (this.mSelectedItemColor && item.nativeView) {
+                        if (this.selectedIndex === item._index) {
+                            item.nativeView.image = this.getIcon(item, this.mSelectedItemColor);
+                        }
+                    }
+                });
+            }
+        }
+    }
+    updateAllItemsColors() {
+        this.mDefaultItemBackgroundColor = null;
+        this.setItemColors();
+        if (this.tabStrip && this.tabStrip.items) {
+            this.tabStrip.items.forEach((tabStripItem) => {
+                this.updateItemColors(tabStripItem);
+            });
+        }
+    }
+    updateItemColors(tabStripItem) {
+        updateBackgroundPositions(this.tabStrip, tabStripItem);
+        this.setIconColor(tabStripItem, true);
+    }
+    createTabBarItem(item, index) {
+        let image;
+        let title;
+        if (item.isLoaded) {
+            image = this.getIcon(item);
+            title = item.label.text;
+            if (!this.tabStrip._hasImage) {
+                this.tabStrip._hasImage = !!image;
+            }
+            if (!this.tabStrip._hasTitle) {
+                this.tabStrip._hasTitle = !!title;
+            }
+        }
+        const tabBarItem = UITabBarItem.alloc().initWithTitleImageTag(title, image, index);
+        return tabBarItem;
+    }
+    getIconRenderingMode() {
+        switch (this.tabStrip && this.tabStrip.iosIconRenderingMode) {
+            case 'alwaysOriginal':
+                return 1;
+            case 'alwaysTemplate':
+                return 2;
+            case 'automatic':
+            default:
+                const hasItemColor = this.mSelectedItemColor || this.mUnSelectedItemColor;
+                return hasItemColor ? 2 : 1;
+        }
+    }
+    getIcon(tabStripItem, color) {
+        const iconSource = tabStripItem.image && tabStripItem.image.src;
+        if (!iconSource) {
+            return null;
+        }
+        const target = tabStripItem.image;
+        const font = target.style.fontInternal || Font.default;
+        if (!color) {
+            color = target.style.color;
+        }
+        const iconTag = [iconSource, font.fontStyle, font.fontWeight, font.fontSize, font.fontFamily, color].join(';');
+        let isFontIcon = false;
+        let image = this.mIconsCache[iconTag];
+        if (!image) {
+            let is;
+            if (Utils.isFontIconURI(iconSource)) {
+                isFontIcon = true;
+                const fontIconCode = iconSource.split('//')[1];
+                is = ImageSource.fromFontIconCodeSync(fontIconCode, font, color);
+            }
+            else {
+                is = ImageSource.fromFileOrResourceSync(iconSource);
+            }
+            if (is && is.ios) {
+                image = is.ios;
+                if (this.tabStrip && this.tabStrip.isIconSizeFixed) {
+                    image = this.getFixedSizeIcon(image);
+                }
+                let renderingMode = 0;
+                if (!isFontIcon) {
+                    renderingMode = this.getIconRenderingMode();
+                }
+                const originalRenderedImage = image.imageWithRenderingMode(renderingMode);
+                this.mIconsCache[iconTag] = originalRenderedImage;
+                image = originalRenderedImage;
+            }
+        }
+        return image;
+    }
+    getFixedSizeIcon(image) {
+        const inWidth = image.size.width;
+        const inHeight = image.size.height;
+        const iconSpecSize = getIconSpecSize({ width: inWidth, height: inHeight });
+        const widthPts = iconSpecSize.width;
+        const heightPts = iconSpecSize.height;
+        UIGraphicsBeginImageContextWithOptions({ width: widthPts, height: heightPts }, false, Utils.layout.getDisplayDensity());
+        image.drawInRect(CGRectMake(0, 0, widthPts, heightPts));
+        const resultImage = UIGraphicsGetImageFromCurrentImageContext();
+        UIGraphicsEndImageContext();
+        return resultImage;
+    }
+    getTabBarBackgroundColor() {
+        return this.viewController.tabBar.barTintColor;
+    }
+    setTabBarBackgroundColor(value) {
+        this.viewController.tabBar.barTintColor = value instanceof Color ? value.ios : value;
+        this.updateAllItemsColors();
+    }
+    setTabBarItemTitle(tabStripItem, value) {
+        const nativeView = tabStripItem.nativeView;
+        if (!nativeView) {
+            return;
+        }
+        nativeView.title = value;
+    }
+    equalUIColor(first, second) {
+        if (!first && !second) {
+            return true;
+        }
+        if (!first || !second) {
+            return false;
+        }
+        const firstComponents = CGColorGetComponents(first.CGColor);
+        const secondComponents = CGColorGetComponents(second.CGColor);
+        return firstComponents[0] === secondComponents[0] && firstComponents[1] === secondComponents[1] && firstComponents[2] === secondComponents[2] && firstComponents[3] === secondComponents[3];
+    }
+    isSelectedAndHightlightedItem(tabStripItem) {
+        return tabStripItem._index === this.selectedIndex && tabStripItem['_visualState'] === 'highlighted';
+    }
+    setTabBarItemBackgroundColor(tabStripItem, value) {
+        if (!this.tabStrip || !tabStripItem || !tabStripItem.nativeView) {
+            return;
+        }
+        const newColor = value instanceof Color ? value.ios : value;
+        const itemSelectedAndHighlighted = this.isSelectedAndHightlightedItem(tabStripItem);
+        if (!this.mDefaultItemBackgroundColor && !itemSelectedAndHighlighted) {
+            this.mDefaultItemBackgroundColor = newColor;
+        }
+        if (itemSelectedAndHighlighted && !this.equalUIColor(this.mDefaultItemBackgroundColor, newColor)) {
+            if (!this.mBackgroundIndicatorColor) {
+                this.mBackgroundIndicatorColor = newColor;
+                this.viewController.tabBar.selectionIndicatorTemplate = new BackgroundIndicatorTemplate();
+                this.viewController.tabBar.tintColor = newColor;
+            }
+        }
+        else {
+            updateBackgroundPositions(this.tabStrip, tabStripItem, newColor);
+        }
+    }
+    setTabBarItemColor(tabStripItem, value) {
+        this.setViewTextAttributes(tabStripItem.label);
+    }
+    setItemColors() {
+        if (this.mSelectedItemColor) {
+            this.viewController.tabBar.setTitleColorForState(this.mSelectedItemColor.ios, 4);
+        }
+        if (this.mUnSelectedItemColor) {
+            this.viewController.tabBar.setTitleColorForState(this.mUnSelectedItemColor.ios, 0);
+        }
+    }
+    setIconColor(tabStripItem, forceReload = false) {
+        const nativeView = tabStripItem.nativeView;
+        if (!nativeView) {
+            return;
+        }
+        if (!forceReload && !this.mSelectedItemColor && !this.mUnSelectedItemColor) {
+            return;
+        }
+        if (this.mSelectedItemColor) {
+            const image = this.getIcon(tabStripItem, this.mSelectedItemColor);
+            nativeView.selectedImage = image;
+        }
+        if (this.mUnSelectedItemColor) {
+            const image = this.getIcon(tabStripItem, this.mUnSelectedItemColor);
+            nativeView.image = image;
+        }
+    }
+    setTabBarIconColor(tabStripItem, value) {
+        this.setIconColor(tabStripItem, true);
+    }
+    setTabBarIconSource(tabStripItem, value) {
+        this.updateItemColors(tabStripItem);
+    }
+    setTabBarItemFontInternal(tabStripItem, value) {
+        this.setViewTextAttributes(tabStripItem.label);
+    }
+    getTabBarFontInternal() {
+        return this.viewController.tabBar.titleFontForState(0);
+    }
+    setTabBarFontInternal() {
+        const defaultTabItemFontSize = 10;
+        const tabItemFontSize = this.tabStrip.style.fontSize || defaultTabItemFontSize;
+        const font = (this.tabStrip.style.fontInternal || Font.default).getUIFont(UIFont.systemFontOfSize(tabItemFontSize));
+        this.viewController.tabBar.setTitleFontForState(font, 0);
+        this.viewController.tabBar.setTitleFontForState(font, 4);
+    }
+    getTabBarColor() {
+        return this.viewController.tabBar.titleColorForState(0);
+    }
+    setTabBarColor(value) {
+        const nativeColor = value instanceof Color ? value.ios : value;
+        this.viewController.tabBar.setTitleColorForState(nativeColor, 4);
+        this.viewController.tabBar.setImageTintColorForState(nativeColor, 4);
+    }
+    getTabBarHighlightColor() {
+        return this.mSelectionIndicatorColor;
+    }
+    setTabBarHighlightColor(value) {
+        this.mSelectionIndicatorColor = value;
+        this.viewController.tabBar.selectionIndicatorStrokeColor = value.ios;
+    }
+    getTabBarSelectedItemColor() {
+        return this.mSelectedItemColor;
+    }
+    setTabBarSelectedItemColor(value) {
+        this.mSelectedItemColor = value;
+        this.updateAllItemsColors();
+    }
+    getTabBarUnSelectedItemColor() {
+        return this.mUnSelectedItemColor;
+    }
+    setTabBarUnSelectedItemColor(value) {
+        this.mUnSelectedItemColor = value;
+        this.updateAllItemsColors();
+    }
+    visitFrames(view, operation) {
+        if (view instanceof Frame) {
+            operation(view);
+        }
+        view.eachChild((child) => {
+            this.visitFrames(child, operation);
+            return true;
+        });
+    }
+    setTabBarRippleColor(value) {
+        this.mRippleColor = value;
+        this.viewController.tabBar.rippleColor = value.ios;
+    }
+    getTabBarRippleColor() {
+        return this.mRippleColor;
+    }
+    [selectedIndexProperty.setNative](value) {
+        if (value > -1) {
+            const item = this.items[value];
+            const controllers = NSMutableArray.alloc().initWithCapacity(1);
+            const itemController = item.__controller;
+            controllers.addObject(itemController);
+            let navigationDirection = 0;
+            if (this.mCurrentNativeSelectedIndex && this.mCurrentNativeSelectedIndex > value) {
+                navigationDirection = 1;
+            }
+            this.mCurrentNativeSelectedIndex = value;
+            this.visitFrames(item, (frame) => (frame._animationInProgress = true));
+            const doneAnimating = () => {
+                this.visitFrames(item, (frame) => (frame._animationInProgress = false));
+                this.finishTabTransition();
+                this._setCanBeLoaded(value);
+                this._loadUnloadTabItems(value);
+            };
+            if (this.mAnimateNextChange) {
+                invokeOnRunLoop(() => {
+                    this.viewController.setViewControllersDirectionAnimatedCompletion(controllers, navigationDirection, this.animationEnabled, (finished) => {
+                        if (finished) {
+                            if (this.animationEnabled) {
+                                invokeOnRunLoop(() => {
+                                    doneAnimating();
+                                });
+                            }
+                            else {
+                                doneAnimating();
+                            }
+                        }
+                    });
+                });
+            }
+            else {
+                this.mAnimateNextChange = true;
+                doneAnimating();
+            }
+            if (this.tabBarItems && this.tabBarItems.length && this.viewController && this.viewController.tabBar) {
+                this.viewController.tabBar.setSelectedItemAnimated(this.tabBarItems[value], this.animationEnabled);
+            }
+        }
+    }
+    [itemsProperty.getDefault]() {
+        return null;
+    }
+    [itemsProperty.setNative](value) {
+        if (value) {
+            value.forEach((item, i) => {
+                item.index = i;
+            });
+        }
+        this.setViewControllers(value);
+        selectedIndexProperty.coerce(this);
+    }
+    [tabStripProperty.getDefault]() {
+        return null;
+    }
+    [tabStripProperty.setNative](value) {
+        this.setViewControllers(this.items);
+        selectedIndexProperty.coerce(this);
+    }
+    [swipeEnabledProperty.getDefault]() {
+        return true;
+    }
+    [swipeEnabledProperty.setNative](value) {
+        if (this.viewController && this.viewController.scrollView) {
+            this.viewController.scrollView.scrollEnabled = value;
+        }
+    }
+    setViewTextAttributes(view, setSelected = false) {
+        if (!view) {
+            return null;
+        }
+        const defaultTabItemFontSize = 10;
+        const tabItemFontSize = view.style.fontSize || defaultTabItemFontSize;
+        const font = (view.style.fontInternal || Font.default).getUIFont(UIFont.systemFontOfSize(tabItemFontSize));
+        this.viewController.tabBar.setTitleFontForState(font, 0);
+        this.viewController.tabBar.setTitleFontForState(font, 4);
+        const tabItemTextColor = view.style.color;
+        const textColor = tabItemTextColor instanceof Color ? tabItemTextColor.ios : null;
+        if (textColor) {
+            this.viewController.tabBar.setTitleColorForState(textColor, 0);
+            this.viewController.tabBar.setImageTintColorForState(textColor, 0);
+            if (setSelected) {
+                this.viewController.tabBar.setTitleColorForState(textColor, 4);
+                this.viewController.tabBar.setImageTintColorForState(textColor, 4);
+            }
+        }
+        if (this.mSelectedItemColor) {
+            this.viewController.tabBar.setTitleColorForState(this.mSelectedItemColor.ios, 4);
+            this.viewController.tabBar.setImageTintColorForState(this.mSelectedItemColor.ios, 4);
+        }
+        if (this.mUnSelectedItemColor) {
+            this.viewController.tabBar.setTitleColorForState(this.mUnSelectedItemColor.ios, 0);
+            this.viewController.tabBar.setImageTintColorForState(this.mUnSelectedItemColor.ios, 4);
+        }
+    }
+}
+iosCustomPositioningProperty.register(TabNavigation);
+//# sourceMappingURL=index.ios.js.map