text: import { EventEmitter, Output } from '@angular/core';
  import { isPresent } from '../util/util';
  import { STATE_NEW, STATE_DESTROYED } from './nav-util';
  import { NavParams } from './nav-params';
  /**
   * \@name ViewController
   * \@description
   * Access various features and information about the current view.
   * \@usage
   *  ```ts
   * import { Component } from '\@angular/core';
   * import { ViewController } from 'ionic-angular';
   *
   * \@Component({...})
   * export class MyPage{
   *
   *   constructor(public viewCtrl: ViewController) {}
   *
   * }
   * ```
   */
  export class ViewController {
      /**
       * @param {?=} component
       * @param {?=} data
       * @param {?=} rootCssClass
       */
      constructor(component, data, rootCssClass = DEFAULT_CSS_CLASS) {
          this.component = component;
          this._isHidden = false;
          this._state = STATE_NEW;
          /**
           * Observable to be subscribed to when the current component will become active
           */
          this.willEnter = new EventEmitter();
          /**
           * Observable to be subscribed to when the current component has become active
           */
          this.didEnter = new EventEmitter();
          /**
           * Observable to be subscribed to when the current component will no longer be active
           */
          this.willLeave = new EventEmitter();
          /**
           * Observable to be subscribed to when the current component is no long active
           */
          this.didLeave = new EventEmitter();
          /**
           * Observable to be subscribed to when the current component has been destroyed
           */
          this.willUnload = new EventEmitter();
          /**
           * @hidden
           */
          this.readReady = new EventEmitter();
          /**
           * @hidden
           */
          this.writeReady = new EventEmitter();
          /**
           * @hidden
           */
          this.isOverlay = false;
          /**
           * @hidden
           */
          this._emitter = new EventEmitter();
          // passed in data could be NavParams, but all we care about is its data object
          this.data = (data instanceof NavParams ? data.data : (isPresent(data) ? data : {}));
          this._cssClass = rootCssClass;
      }
      /**
       * @hidden
       * @param {?} componentRef
       * @return {?}
       */
      init(componentRef) {
          (void 0) /* assert */;
          this._cmp = componentRef;
          this.instance = this.instance || componentRef.instance;
          this._detached = false;
      }
      /**
       * @param {?} navCtrl
       * @return {?}
       */
      _setNav(navCtrl) {
          this._nav = navCtrl;
      }
      /**
       * @param {?} instance
       * @return {?}
       */
      _setInstance(instance) {
          this.instance = instance;
      }
      /**
       * @hidden
       * @param {?=} generatorOrNext
       * @return {?}
       */
      subscribe(generatorOrNext) {
          return this._emitter.subscribe(generatorOrNext);
      }
      /**
       * @hidden
       * @param {?=} data
       * @return {?}
       */
      emit(data) {
          this._emitter.emit(data);
      }
      /**
       * Called when the current viewController has be successfully dismissed
       * @param {?} callback
       * @return {?}
       */
      onDidDismiss(callback) {
          this._onDidDismiss = callback;
      }
      /**
       * Called when the current viewController will be dismissed
       * @param {?} callback
       * @return {?}
       */
      onWillDismiss(callback) {
          this._onWillDismiss = callback;
      }
      /**
       * Dismiss the current viewController
       * @param {?=} data
       * @param {?=} role
       * @param {?=} navOptions
       * @return {?}
       */
      dismiss(data, role, navOptions = {}) {
          if (!this._nav) {
              (void 0) /* assert */;
              return Promise.resolve(false);
          }
          if (this.isOverlay && !navOptions.minClickBlockDuration) {
              // This is a Modal being dismissed so we need
              // to add the minClickBlockDuration option
              // for UIWebView
              navOptions.minClickBlockDuration = 400;
          }
          this._dismissData = data;
          this._dismissRole = role;
          const /** @type {?} */ options = Object.assign({}, this._leavingOpts, navOptions);
          return this._nav.removeView(this, options).then(() => data);
      }
      /**
       * @hidden
       * @return {?}
       */
      getNav() {
          return this._nav;
      }
      /**
       * @hidden
       * @param {?} direction
       * @return {?}
       */
      getTransitionName(direction) {
          return this._nav && this._nav.config.get('pageTransition');
      }
      /**
       * @hidden
       * @return {?}
       */
      getNavParams() {
          return new NavParams(this.data);
      }
      /**
       * @hidden
       * @param {?} opts
       * @return {?}
       */
      setLeavingOpts(opts) {
          this._leavingOpts = opts;
      }
      /**
       * Check to see if you can go back in the navigation stack.
       * @return {?}
       */
      enableBack() {
          // update if it's possible to go back from this nav item
          if (!this._nav) {
              return false;
          }
          // the previous view may exist, but if it's about to be destroyed
          // it shouldn't be able to go back to
          const /** @type {?} */ previousItem = this._nav.getPrevious(this);
          return !!(previousItem);
      }
      /**
       * @hidden
       * @return {?}
       */
      get name() {
          return (this.component ? this.component.name : '');
      }
      /**
       * Get the index of the current component in the current navigation stack.
       * @return {?}
       */
      get index() {
          return (this._nav ? this._nav.indexOf(this) : -1);
      }
      /**
       * @return {?}
       */
      isFirst() {
          return (this._nav ? this._nav.first() === this : false);
      }
      /**
       * @return {?}
       */
      isLast() {
          return (this._nav ? this._nav.last() === this : false);
      }
      /**
       * @hidden
       * DOM WRITE
       * @param {?} shouldShow
       * @param {?} renderer
       * @return {?}
       */
      _domShow(shouldShow, renderer) {
          // using hidden element attribute to display:none and not render views
          // _hidden value of '' means the hidden attribute will be added
          // _hidden value of null means the hidden attribute will be removed
          // doing checks to make sure we only update the DOM when actually needed
          // if it should render, then the hidden attribute should not be on the element
          if (this._cmp && shouldShow === this._isHidden) {
              this._isHidden = !shouldShow;
              let /** @type {?} */ value = (shouldShow ? null : '');
              // ******** DOM WRITE ****************
              renderer.setElementAttribute(this.pageRef().nativeElement, 'hidden', value);
          }
      }
      /**
       * @hidden
       * @return {?}
       */
      getZIndex() {
          return this._zIndex;
      }
      /**
       * @hidden
       * DOM WRITE
       * @param {?} zIndex
       * @param {?} renderer
       * @return {?}
       */
      _setZIndex(zIndex, renderer) {
          if (zIndex !== this._zIndex) {
              this._zIndex = zIndex;
              const /** @type {?} */ pageRef = this.pageRef();
              if (pageRef) {
                  // ******** DOM WRITE ****************
                  renderer.setElementStyle(pageRef.nativeElement, 'z-index', ((zIndex)));
              }
          }
      }
      /**
       * @return {?}
       */
      pageRef() {
          return this._cmp && this._cmp.location;
      }
      /**
       * @param {?} directive
       * @return {?}
       */
      _setContent(directive) {
          this._cntDir = directive;
      }
      /**
       * @return {?}
       */
      getContent() {
          return this._cntDir;
      }
      /**
       * @param {?} elementRef
       * @return {?}
       */
      _setContentRef(elementRef) {
          this._cntRef = elementRef;
      }
      /**
       * @return {?}
       */
      contentRef() {
          return this._cntRef;
      }
      /**
       * @param {?} content
       * @return {?}
       */
      _setIONContent(content) {
          this._setContent(content);
          this._ionCntDir = content;
      }
      /**
       * @hidden
       * @return {?}
       */
      getIONContent() {
          return this._ionCntDir;
      }
      /**
       * @param {?} elementRef
       * @return {?}
       */
      _setIONContentRef(elementRef) {
          this._setContentRef(elementRef);
          this._ionCntRef = elementRef;
      }
      /**
       * @hidden
       * @return {?}
       */
      getIONContentRef() {
          return this._ionCntRef;
      }
      /**
       * @param {?} directive
       * @return {?}
       */
      _setHeader(directive) {
          this._hdrDir = directive;
      }
      /**
       * @hidden
       * @return {?}
       */
      getHeader() {
          return this._hdrDir;
      }
      /**
       * @param {?} directive
       * @return {?}
       */
      _setFooter(directive) {
          this._ftrDir = directive;
      }
      /**
       * @hidden
       * @return {?}
       */
      getFooter() {
          return this._ftrDir;
      }
      /**
       * @param {?} directive
       * @return {?}
       */
      _setNavbar(directive) {
          this._nb = directive;
      }
      /**
       * @hidden
       * @return {?}
       */
      getNavbar() {
          return this._nb;
      }
      /**
       * Find out if the current component has a NavBar or not. Be sure
       * to wrap this in an `ionViewWillEnter` method in order to make sure
       * the view has rendered fully.
       * @return {?}
       */
      hasNavbar() {
          return !!this._nb;
      }
      /**
       * Change the title of the back-button. Be sure to call this
       * after `ionViewWillEnter` to make sure the  DOM has been rendered.
       * @param {?} val
       * @return {?}
       */
      setBackButtonText(val) {
          this._nb && this._nb.setBackButtonText(val);
      }
      /**
       * Set if the back button for the current view is visible or not. Be sure to call this
       * after `ionViewWillEnter` to make sure the  DOM has been rendered.
       * @param {?} shouldShow
       * @return {?}
       */
      showBackButton(shouldShow) {
          if (this._nb) {
              this._nb.hideBackButton = !shouldShow;
          }
      }
      /**
       * @return {?}
       */
      _preLoad() {
          (void 0) /* assert */;
          this._lifecycle('PreLoad');
      }
      /**
       * @hidden
       * The view has loaded. This event only happens once per view will be created.
       * This event is fired before the component and his children have been initialized.
       * @return {?}
       */
      _willLoad() {
          (void 0) /* assert */;
          this._lifecycle('WillLoad');
      }
      /**
       * @hidden
       * The view has loaded. This event only happens once per view being
       * created. If a view leaves but is cached, then this will not
       * fire again on a subsequent viewing. This method is a good place
       * to put your setup code for the view; however, it is not the
       * recommended method to use when a view becomes active.
       * @return {?}
       */
      _didLoad() {
          (void 0) /* assert */;
          this._lifecycle('DidLoad');
      }
      /**
       * @hidden
       * The view is about to enter and become the active view.
       * @return {?}
       */
      _willEnter() {
          (void 0) /* assert */;
          if (this._detached && this._cmp) {
              // ensure this has been re-attached to the change detector
              this._cmp.changeDetectorRef.reattach();
              this._detached = false;
          }
          this.willEnter.emit(null);
          this._lifecycle('WillEnter');
      }
      /**
       * @hidden
       * The view has fully entered and is now the active view. This
       * will fire, whether it was the first load or loaded from the cache.
       * @return {?}
       */
      _didEnter() {
          (void 0) /* assert */;
          this._nb && this._nb.didEnter();
          this.didEnter.emit(null);
          this._lifecycle('DidEnter');
      }
      /**
       * @hidden
       * The view is about to leave and no longer be the active view.
       * @param {?} willUnload
       * @return {?}
       */
      _willLeave(willUnload) {
          this.willLeave.emit(null);
          this._lifecycle('WillLeave');
          if (willUnload && this._onWillDismiss) {
              this._onWillDismiss(this._dismissData, this._dismissRole);
              this._onWillDismiss = null;
          }
      }
      /**
       * @hidden
       * The view has finished leaving and is no longer the active view. This
       * will fire, whether it is cached or unloaded.
       * @return {?}
       */
      _didLeave() {
          this.didLeave.emit(null);
          this._lifecycle('DidLeave');
          // when this is not the active page
          // we no longer need to detect changes
          if (!this._detached && this._cmp) {
              this._cmp.changeDetectorRef.detach();
              this._detached = true;
          }
      }
      /**
       * @hidden
       * @return {?}
       */
      _willUnload() {
          this.willUnload.emit(null);
          this._lifecycle('WillUnload');
          this._onDidDismiss && this._onDidDismiss(this._dismissData, this._dismissRole);
          this._onDidDismiss = null;
          this._dismissData = null;
          this._dismissRole = null;
      }
      /**
       * @hidden
       * DOM WRITE
       * @param {?} renderer
       * @return {?}
       */
      _destroy(renderer) {
          (void 0) /* assert */;
          if (this._cmp) {
              if (renderer) {
                  // ensure the element is cleaned up for when the view pool reuses this element
                  // ******** DOM WRITE ****************
                  var /** @type {?} */ cmpEle = this._cmp.location.nativeElement;
                  renderer.setElementAttribute(cmpEle, 'class', null);
                  renderer.setElementAttribute(cmpEle, 'style', null);
              }
              // completely destroy this component. boom.
              this._cmp.destroy();
          }
          this._nav = this._cmp = this.instance = this._cntDir = this._cntRef = this._leavingOpts = this._hdrDir = this._ftrDir = this._nb = this._onDidDismiss = this._onWillDismiss = null;
          this._state = STATE_DESTROYED;
      }
      /**
       * @hidden
       * @param {?} lifecycle
       * @return {?}
       */
      _lifecycleTest(lifecycle) {
          const /** @type {?} */ instance = this.instance;
          const /** @type {?} */ methodName = 'ionViewCan' + lifecycle;
          if (instance && instance[methodName]) {
              try {
                  var /** @type {?} */ result = instance[methodName]();
                  if (result === false) {
                      return false;
                  }
                  else if (result instanceof Promise) {
                      return result;
                  }
                  else {
                      return true;
                  }
              }
              catch (e) {
                  console.error(`${this.name} ${methodName} error: ${e.message}`);
                  return false;
              }
          }
          return true;
      }
      /**
       * @param {?} lifecycle
       * @return {?}
       */
      _lifecycle(lifecycle) {
          const /** @type {?} */ instance = this.instance;
          const /** @type {?} */ methodName = 'ionView' + lifecycle;
          if (instance && instance[methodName]) {
              try {
                  instance[methodName]();
              }
              catch (e) {
                  console.error(`${this.name} ${methodName} error: ${e.message}`);
              }
          }
      }
  }
  ViewController.propDecorators = {
      '_emitter': [{ type: Output },],
  };
  function ViewController_tsickle_Closure_declarations() {
      /** @type {?} */
      ViewController.propDecorators;
      /** @type {?} */
      ViewController.prototype._cntDir;
      /** @type {?} */
      ViewController.prototype._cntRef;
      /** @type {?} */
      ViewController.prototype._ionCntDir;
      /** @type {?} */
      ViewController.prototype._ionCntRef;
      /** @type {?} */
      ViewController.prototype._hdrDir;
      /** @type {?} */
      ViewController.prototype._ftrDir;
      /** @type {?} */
      ViewController.prototype._isHidden;
      /** @type {?} */
      ViewController.prototype._leavingOpts;
      /** @type {?} */
      ViewController.prototype._nb;
      /** @type {?} */
      ViewController.prototype._onDidDismiss;
      /** @type {?} */
      ViewController.prototype._onWillDismiss;
      /** @type {?} */
      ViewController.prototype._dismissData;
      /** @type {?} */
      ViewController.prototype._dismissRole;
      /** @type {?} */
      ViewController.prototype._detached;
      /** @type {?} */
      ViewController.prototype._cmp;
      /** @type {?} */
      ViewController.prototype._nav;
      /** @type {?} */
      ViewController.prototype._zIndex;
      /** @type {?} */
      ViewController.prototype._state;
      /** @type {?} */
      ViewController.prototype._cssClass;
      /**
       * Observable to be subscribed to when the current component will become active
       * @type {?}
       */
      ViewController.prototype.willEnter;
      /**
       * Observable to be subscribed to when the current component has become active
       * @type {?}
       */
      ViewController.prototype.didEnter;
      /**
       * Observable to be subscribed to when the current component will no longer be active
       * @type {?}
       */
      ViewController.prototype.willLeave;
      /**
       * Observable to be subscribed to when the current component is no long active
       * @type {?}
       */
      ViewController.prototype.didLeave;
      /**
       * Observable to be subscribed to when the current component has been destroyed
       * @type {?}
       */
      ViewController.prototype.willUnload;
      /**
       * @hidden
       * @type {?}
       */
      ViewController.prototype.readReady;
      /**
       * @hidden
       * @type {?}
       */
      ViewController.prototype.writeReady;
      /**
       * @hidden
       * @type {?}
       */
      ViewController.prototype.data;
      /**
       * @hidden
       * @type {?}
       */
      ViewController.prototype.instance;
      /**
       * @hidden
       * @type {?}
       */
      ViewController.prototype.id;
      /**
       * @hidden
       * @type {?}
       */
      ViewController.prototype.isOverlay;
      /**
       * @hidden
       * @type {?}
       */
      ViewController.prototype._emitter;
      /** @type {?} */
      ViewController.prototype.component;
  }
  /**
   * @param {?} viewCtrl
   * @return {?}
   */
  export function isViewController(viewCtrl) {
      return !!(viewCtrl && ((viewCtrl))._didLoad && ((viewCtrl))._willUnload);
  }
  const /** @type {?} */ DEFAULT_CSS_CLASS = 'ion-page';
  //# sourceMappingURL=view-controller.js.map