forked from Jibo-Revival-Group/JiboOs
633 lines
29 KiB
JavaScript
633 lines
29 KiB
JavaScript
/**
|
|
* Callback given to view process methods, called once process completes successfully.
|
|
* @callback jibo.face.views~ViewCallback
|
|
* @param [view] {jibo.face.views.View} View associated with view process, not all view processes return a View.
|
|
* @param [done] {Function} ONLY used for the onLoaded callback within [changeView()]{@link jibo.face.views#changeView}.
|
|
* Not specifying this parameter on the onLoaded callback makes it synchronous.
|
|
* Specifying makes the callback asynchronous and requires that `done()` be called at some point within the method.
|
|
*/
|
|
|
|
/**
|
|
* @interface jibo.face.views~ChangeOptions
|
|
* @description Interface for changing view process options.
|
|
* @prop {Boolean} [remove] - `true` to remove current element.
|
|
* This is exclusive from the other `remove*` methods, with the order of override: `removeAll > removeTo > removeToInclude > remove`
|
|
* @prop {Boolean} [removeAll] - `true` to remove all views down to root.
|
|
* This is exclusive from the other `remove*` methods, with the order of override: `removeAll > removeTo > removeToInclude > remove`
|
|
* @prop {String} [options.removeTo] - Id of a view within the stack, all views above it will be removed.
|
|
* This is exclusive from the other `remove*` methods, with the order of override: `removeAll > removeTo > removeToInclude > remove`
|
|
* @prop {String} [options.removeToInclude] - Id of a view within the stack, that view and all views above it will be removed.
|
|
* This is exclusive from the other `remove*` methods, with the order of override: `removeAll > removeTo > removeToInclude > remove`
|
|
* @prop {Boolean} [leaveEmpty] - `true` to prevent next view in stack from opening and leaving the display empty.
|
|
* Setting to `true` overrides `addView`.
|
|
* @prop {String|jibo.face.views.View|any} [addView] - Add view, can specify a path to config file, instantiated View, or view config Object.
|
|
* @prop {jibo.face.views.PauseOverlay#PauseOptions} [pause] - If when adding the next view the current view should be paused. If so, how.
|
|
* @prop {String} [transitionClose] - Type of transition the current View should use to close.
|
|
* @prop {String} [transitionOpen] - Type of transition the next View should use to open.
|
|
*/
|
|
|
|
/**
|
|
* @interface jibo.face.views~AssetDescriptor
|
|
* @description Interface for asset description objects, used in conjunction with [loader]{@link jibo.loader}.
|
|
* @prop {String} id - Id of asset, should be unique within cache.
|
|
* @prop {String} type - Type of asset, for valid types refer to [loader]{@link jibo.loader}.
|
|
* @prop {String} src - URI of asset.
|
|
* @prop {Boolean} [upload] - If `true` will also load to GPU.
|
|
* @prop {String} [cache] - Cache asset is associated with. Will use the loader's currently default cache unless otherwise specified.
|
|
*/
|
|
|
|
/**
|
|
* @typedef jibo.face.views~STACK_DIRECTION
|
|
* @description Enum - For use with `View.addTransition` & `View.applyTransitions`
|
|
* to define transitions by the way the view stack will change.
|
|
* @prop 1 ADD
|
|
* @prop 2 REMOVE
|
|
* @prop 3 SWAP
|
|
*/
|
|
|
|
/**
|
|
* @typedef jibo.face.views~TRANSITION
|
|
* @description Static class with static members that describe possible transitions for views.
|
|
* @prop UP Transition type for view to move up.
|
|
* @prop DOWN Transition type for view to move down.
|
|
* @prop LEFT Transition type for view to move left.
|
|
* @prop RIGHT Transition type for view to move right.
|
|
* @prop IN Transition type for view to fade and scale in from center of screen.
|
|
* @prop OUT Transition type for view to fade and scale out from center of screens.
|
|
* @prop EYE Transition type for view to or from eye.
|
|
* @prop NONE Transition type for no transition.
|
|
*/
|
|
|
|
/**
|
|
* @class ViewManager
|
|
* @description Everything in this class is now accessible as part of {@link jibo.face.views}.
|
|
* Please update your code to use the `face.views` namespace instead of the `ViewManager` class.
|
|
* @memberof jibo.face.views
|
|
* @deprecated Since 7.4.1
|
|
* @see jibo.face.views
|
|
*/
|
|
|
|
/**
|
|
* Manages the creation and transition of the GUI.
|
|
* @namespace jibo.face.views
|
|
*/
|
|
|
|
/**
|
|
* Default duration, in milliseconds, of open and close view transitions.
|
|
* @type {number}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Top level container.
|
|
* @name jibo.face.views#stage
|
|
* @type {PIXI.Container}
|
|
*/
|
|
|
|
/**
|
|
* If the view manager is disabled, in which case all view changes will fail immediately.
|
|
* This will only be used when the WebGL context is lost.
|
|
* @name jibo.face.views#disabled
|
|
* @type {boolean}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* If movement should be disabled due to screen taps - don't want to move around once the GUI
|
|
* has begun to be used.
|
|
* @name jibo.face.views#_disableMovement
|
|
* @type {boolean}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Array of ViewStates in order of the view hierarchy.
|
|
* @name jibo.face.views#_viewStates
|
|
* @type {Array<jibo.face.views.ViewState>}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Class to assist in creation of Views and Components.
|
|
* @name jibo.face.views#_creator
|
|
* @type {jibo.face.views.ComponentCreator}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Class to manage interactions.
|
|
* @name jibo.face.views#_interactionManager
|
|
* @type {jibo.face.views.TouchManager}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Handle to the Menu attention mode pushed with a GUI view.
|
|
* @name jibo.face.views#_menuMode
|
|
* @type {jibo.attention.AttentionModeHandle}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Event dispatched when the View is going to close because of a 'back' command.
|
|
* Currently closing a View and going back to the previous view is triggered by a swipe down.
|
|
* The same constant is statically accessible via `View.BACK`, but duplicated here for convenience.
|
|
* @type {string}
|
|
* @name jibo.face.views#BACK
|
|
* @constant
|
|
* @readOnly
|
|
*/
|
|
|
|
/**
|
|
* Option for setting custom transitions.
|
|
* Use with `View.addTransition` for transitions to be used when opening from or closing to an empty screen.
|
|
* The same constant is statically accessible via `View.EMPTY`, but duplicated here for convenience.
|
|
* @type {string}
|
|
* @name jibo.face.views.EMPTY
|
|
* @readOnly
|
|
*/
|
|
|
|
/**
|
|
* Option for setting custom transitions.
|
|
* Use with `View.addTransition` for transitions to be used when opening over a paused view or closing while being paused.
|
|
* The same constant is statically accessible via `View.PAUSED`, but duplicated here for convenience.
|
|
* @type {string}
|
|
* @name jibo.face.views.PAUSED
|
|
* @readOnly
|
|
*/
|
|
|
|
/**
|
|
* Current top-level view.
|
|
* @name jibo.face.views#currentView
|
|
* @type {jibo.face.views.View}
|
|
* @readOnly
|
|
*/
|
|
|
|
/**
|
|
* Class to assist in creation of Views and Components.
|
|
* @name jibo.face.views#creator
|
|
* @type {jibo.face.views.ComponentCreator}
|
|
* @readOnly
|
|
*/
|
|
|
|
/**
|
|
* Maintains view processes.
|
|
* @name jibo.face.views#_viewProcess
|
|
* @type {jibo.face.views.ViewProcess}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Source for global events related to GUI processes.
|
|
* @name jibo.face.views#_events
|
|
* @type {jibo.face.views.ViewGlobalEvents}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Black gradient border at edge of screen, layered above ViewManager stage.
|
|
* @name jibo.face.views#_border
|
|
* @type {PIXI.Container}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Image that exist above all displays and the border, there can only be one watermark at a time.
|
|
* Use for things like remote mode indication.
|
|
* @name jibo.face.views#_waterMark
|
|
* @type {PIXI.Container}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Flag to keep track of visibility of border.
|
|
* @name jibo.face.views#_borderVisibility
|
|
* @type {Boolean}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Visibility of border.
|
|
* @name jibo.face.views#borderVisible
|
|
* @param {Boolean} visible Determines border's visibility
|
|
*/
|
|
|
|
/**
|
|
* Will return the total number of views in the view stack.
|
|
* @name jibo.face.views#viewStackLength
|
|
* @type {number}
|
|
* @readOnly
|
|
*/
|
|
|
|
/**
|
|
* Determines if views are currently in process.
|
|
* @name jibo.face.views#viewsInProcess
|
|
* @type {boolean}
|
|
* @readOnly
|
|
*/
|
|
|
|
/**
|
|
* Create a View by specifying the class and the configuration.
|
|
* @method jibo.face.views#createView
|
|
* @param {Object|String} [viewDeterminer] Can be the Class or name of Class of the the view to create.
|
|
* @param {Object} [config] Config can be an Object or a string of the path to the JSON file for the config.
|
|
* @param {Boolean} [open=false] If true continue process of adding and opening the view.
|
|
* @param {jibo.face.views~ViewCallback} [onOpenComplete] Callback for when View has finished opening, will only be used if the open flag is set to true.
|
|
* @param {String} [openTransition=TRANSITION.UP] Type of transition to open view.
|
|
* @param {String} [closeTransition=TRANSITION.UP] Type of transition to close view.
|
|
* @return {jibo.face.views.View} The View created.
|
|
*/
|
|
|
|
/**
|
|
* Create a View from only the View's configuration path.
|
|
* Unlike the the createView method, this method does not require the view class to be specified,
|
|
* instead the view class is derived from the configuration file.
|
|
* This method does not return the View directly, but rather through the provided callback.
|
|
* If the open flag is set to true the callback will be fire when the View is created, and opened,
|
|
* if not the callback is fire as soon as the View class is created.
|
|
* @method jibo.face.views#createViewFromConfigPath
|
|
* @param {String} configPath Path to the configuration for the view.
|
|
* @param {Boolean} [open=false] If true continue process of adding and opening the view, callback will be fired after View finishes opening.
|
|
* @param {jibo.face.views~ViewCallback} callback Callback that returns the View
|
|
* @param {String} [openTransition=TRANSITION.UP] Type of transition to open view.
|
|
* @param {String} [closeTransition=TRANSITION.UP] Type of transition to close view.
|
|
*/
|
|
|
|
/**
|
|
* Add the view that is at the top of the stack.
|
|
* This is generally used when there is no current view present
|
|
* (i.e. to create the first eye view, or when a view was removed to empty)
|
|
* @method jibo.face.views#addViewNextInStack
|
|
* @param {jibo.face.views~ViewCallback} callback Callback that returns the View
|
|
* @param {String} [openTransition=TRANSITION.UP] Type of transition to open view.
|
|
* @param {String} [closeTransition=TRANSITION.UP] Type of transition to close view.
|
|
* @param {Function} [onFailure] Callback for if process does not complete
|
|
*/
|
|
|
|
/**
|
|
* Passes {@link jibo.face.views.ActionData} to the current {@link jibo.face.views.View} and its children.
|
|
* @method jibo.face.views#actionEnactor
|
|
* @param {jibo.face.views.ActionData} action - The action to be passed.
|
|
* @return {boolean} `true` if action is acted on by the current View or any of its ComponentGroup children.
|
|
*/
|
|
|
|
/**
|
|
* Process for changing views, takes a config that defines process particulars.
|
|
* @example
|
|
* <caption>Option examples</caption>
|
|
*
|
|
* 'Example of closing all views and leave display empty'
|
|
* {
|
|
* removeAll: true,
|
|
* leaveEmpty: true,
|
|
* }
|
|
*
|
|
* 'Example of opening view lower in the view stack and having it fade in'
|
|
* {
|
|
* removeTo: 'myView',
|
|
* transitionOpen: "trans_in"
|
|
* }
|
|
*
|
|
* 'Example of closing current view and leaving display empty'
|
|
* {
|
|
* remove: true,
|
|
* leaveEmpty: true
|
|
* }
|
|
*
|
|
* 'Example of opening a new view while pausing the view beneath it but fully hiding it using standard overlay tween'
|
|
* {
|
|
* addView: "resources/views/myViewConfig.json",
|
|
* pause:{
|
|
* "alpha": 1,
|
|
* }
|
|
* }
|
|
*
|
|
* 'Example of removing all views above a particular view in the stack and then opening that view, using view's id'
|
|
* {
|
|
* removeTo: "myView"
|
|
* }
|
|
*
|
|
* 'Example of removing a particular view and all views above it in the stack, then adding a new view.'
|
|
* {
|
|
* removeToInclude: "myView",
|
|
* addView: "resources/views/myViewConfig.json"
|
|
* }
|
|
*
|
|
* @method jibo.face.views#changeView
|
|
* @param {jibo.face.views~ChangeOptions} options - Options for view change process.
|
|
* @param {jibo.face.views~ViewCallback} [onComplete] Callback when process completes, gives the current view as a parameter.
|
|
* @param {Function} [onFailure] Callback for if process does not complete.
|
|
* @param {jibo.face.views~ViewCallback} [onLoaded] Callback when next view has loaded, use to augment view prior to it opening.
|
|
*/
|
|
|
|
/**
|
|
* Add a new {@link jibo.face.views.View} to the hierarchy.
|
|
* Adding process involves disposing of or pausing current view and storing its state.
|
|
* @method jibo.face.views#addView
|
|
* @param {jibo.face.views.View | string} view - Info for the view to load, can pass the View class directly,
|
|
* or pass a string that is the path to the config file defining the View.
|
|
* @param {jibo.face.views~ViewCallback} [onAdded] Callback when process completes, gives the current view as a parameter.
|
|
* @param {String} [openTransition = TRANSITION.UP] Type of transition the next View should use to open.
|
|
* @param {String} [closeTransition = TRANSITION.UP] Type of transition the current View should use to close.
|
|
* @param {Function} [onFailure] Callback for if process does not complete.
|
|
*/
|
|
|
|
/**
|
|
* Remove current {@link jibo.face.views.View} and open the View beneath it in the stack.
|
|
* Removal process involves disposing of current view and recreating prior View using its stored ViewState.
|
|
* If top most view was pausing the previous view then we don't need to recreate it, only un-pause it.
|
|
* @method jibo.face.views#removeView
|
|
* @param {jibo.face.views~ViewCallback} [onRemoved] Callback when process completes, gives the current view as a parameter.
|
|
* @param {String} [openTransition = TRANSITION.DOWN] Type of transition the next View should use to open.
|
|
* @param {String} [closeTransition = TRANSITION.DOWN] Type of transition the current View should use to close.
|
|
* @param {Function} [onFailure] Callback for if process does not complete.
|
|
*/
|
|
|
|
/**
|
|
* Force open the eye view and clear the view stack.
|
|
* @method jibo.face.views#forceEyeView
|
|
* @param {jibo.face.views~ViewCallback} [onOpenCallback] called once eyeView is opened or if it is already open, returns the EyeView as a parameter.
|
|
* @param {Function} [onPressCallback] handler for when EyeView is pressed, if nothing is specified will remove any existing callbacks.
|
|
* @param {String} [openTransition=TRANSITION.IN] Type of transition to open view.
|
|
* @param {String} [closeTransition=TRANSITION.UP] Type of transition to close view.
|
|
* @param {Function} [onFailure] Callback for if process does not complete.
|
|
*/
|
|
|
|
/**
|
|
* If there is an active process attempting to make the EyeView the current view we want to try not to interrupt that process as it has the same purpose as forceEyeView.
|
|
* We determine if that is the state of the process if a closing view is defined (so we know that the EyeView is not what the process may be closing)
|
|
* AND the current view (which is an EyeView) has a status indicating it is going to open, basically that it is loaded but not yet open.
|
|
*/
|
|
|
|
/**
|
|
* Clear the view stack, if current view is of category EYE leave the eye as the current view,
|
|
* if any other category remove call views and leave the current view empty.
|
|
* @method jibo.face.views#viewStackCleanup
|
|
* @param {jibo.face.views~TRANSITION} [closeTransition=TRANSITION.DOWN] Type of transition to close the current view.
|
|
* @returns {Promise<void>}
|
|
*/
|
|
|
|
/**
|
|
* Check if a view exists with a given ID, and can be used as `removeTo` or `removeToInclude`
|
|
* in [changeView]{@link jibo.face.views#changeView}.
|
|
* @method jibo.face.views#hasView
|
|
* @param {String} id View ID to look for.
|
|
* @returns {Boolean} `true` if a View exists with the given ID.
|
|
*/
|
|
|
|
/**
|
|
* Resets the TRANS_TIME to default, or transTime if specified
|
|
* @method jibo.face.views#resetTransTime
|
|
* @param {number} [transTime] Optional time in milliseconds to set the TRANS_TIME to
|
|
*/
|
|
|
|
/**
|
|
* Handles process failure or interruption.
|
|
* Cleans up current process. and queue stack.
|
|
* If queue has members, start process for top most member and clean up any below it.
|
|
* @method jibo.face.views#viewProcessFailure
|
|
* @param {jibo.face.views.ViewProcess} process Active view process
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* This allows us to more logically recover from an interruption in the case where the interrupting process will remove the current view.
|
|
* Interrupting a process normally destroys the current view involved immediately, which would skip it's close transition.
|
|
* In the case where the interrupting process will attempt to remove the current view,
|
|
* we want to allow it to do so, so we prevent the process fail from destroying the current view so that the next process can close and destroy it naturally.
|
|
*/
|
|
|
|
/**
|
|
* Add a new {@link jibo.face.views.View} to the view hierarchy and display.
|
|
* Adding process involves disposing of or pausing current view and storing its state.
|
|
* @method jibo.face.views#add
|
|
* @param {jibo.face.views.ViewProcess} process Active view process.
|
|
* @param {jibo.face.views.View} nextView - View to add and make current.
|
|
* @param {jibo.face.views.PauseOverlay#PauseOptions} [pauseOptions] - Pause options, defined within change view options.ß
|
|
* @param {String} [openTransition = TRANSITION.UP] Type of transition the next View should use to open.
|
|
* @param {String} [closeTransition = TRANSITION.UP] Type of transition the current View should use to close.
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Remove current {@link jibo.face.views.View} from the hierarchy and display.
|
|
* @method jibo.face.views#remove
|
|
* @param {jibo.face.views.ViewProcess} process Active view process.
|
|
* @param {jibo.face.views.View} [nextView] - View to add after current view is closed.
|
|
* @param {boolean} leaveEmpty - If next view in stack should be opened after current view closes, if 'true' display is left empty.
|
|
* @param {String} [openTransition = TRANSITION.UP] Type of transition the next View should use to open.
|
|
* @param {String} [closeTransition = TRANSITION.UP] Type of transition the current View should use to close.
|
|
* @returns {Promise<View>}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Close all currently active views and open the 'root' view ({@link jibo.face.views.EyeView}).
|
|
* @method jibo.face.views#removeToRoot
|
|
* @param {jibo.face.views.ViewProcess} process Active view process.
|
|
* @param {jibo.face.views.View} [nextView] - View to add above root view after current views and stack have been cleared.
|
|
* @param {boolean} leaveEmpty - If root View should be opened after close completes, if 'true' display is left empty.
|
|
* @param {String} [closeTransition = TRANSITION.DOWN] Type of transition the current View should use to close.
|
|
* @param {String} [openTransition = TRANSITION.DOWN] Type of transition the next View should use to open.
|
|
* @returns {Promise<View>}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Close all currently active views and open the 'root' view ({@link jibo.face.views.EyeView}).
|
|
* @method jibo.face.views#removeToRoot
|
|
* @param {jibo.face.views.ViewProcess} process Active view process.
|
|
* @param {jibo.face.views.View} [nextView] - View to add above root view after current views and stack have been cleared.
|
|
* @param {boolean} leaveEmpty - If root View should be opened after close completes, if 'true' display is left empty.
|
|
* @param {String} [closeTransition = TRANSITION.DOWN] Type of transition the current View should use to close.
|
|
* @param {String} [openTransition = TRANSITION.DOWN] Type of transition the next View should use to open.
|
|
* @returns {Promise<View>}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Load and open View.
|
|
* @param {jibo.face.views.ViewProcess} process Active view process.
|
|
* @method jibo.face.views#openView
|
|
* @param {jibo.face.views.View}view - View to open.
|
|
* @param {string} openTransition - Type of transition view will open with.
|
|
* @returns {Promise<jibo.face.views.View>}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Close and destroy View.
|
|
* Does not take into account any paused Views that may be associated with the given view.
|
|
* @method jibo.face.views#closeView
|
|
* @param {jibo.face.views.ViewProcess} process Active view process.
|
|
* @param {jibo.face.views.View} view - View to close.
|
|
* @param {string} [closeTransition] - Type of transition view will close with.
|
|
* @param {boolean} [addToStack = false] - if 'true' closed views are added to the view stack.
|
|
* @param {boolean} [destroyViews = true] - if 'true' views will be destroyed.
|
|
* @param {boolean} [toPaused = false] - if view is closing over a paused if 'true' views will be destroyed.
|
|
* @returns {Promise<jibo.face.views.View>}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Close and open separate views.
|
|
* Supports async behavior, making sure the view being opened has been fully loaded and prepped before opening.
|
|
* @method jibo.face.views#closeAndOpenViews
|
|
* @param {jibo.face.views.ViewProcess} process Active view process.
|
|
* @param {jibo.face.views.View} nextView - View to open.
|
|
* @param {jibo.face.views.View} closeView - View to close.
|
|
* @param {string} [openTransition] - Type of transition next view will open with.
|
|
* @param {string} [closeTransition] - Type of transition closing view will close with.
|
|
* @param {boolean} [addToStack = false] - if 'true' closed views are added to the view stack.
|
|
* @returns {Promise<jibo.face.views.View>}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Close and destroy given view and all paused views beneath it, and open next view.
|
|
* Supports async behavior, making sure the view being opened has been fully loaded and prepped before opening.
|
|
* method jibo.face.views#closeWithPausedAndOpenViews
|
|
* @param {jibo.face.views.ViewProcess} process Active view process.
|
|
* @param {jibo.face.views.View} nextView - View to open.
|
|
* @param {jibo.face.views.View} closeView - View to close.
|
|
* @param {string} [openTransition] - Type of transition next view will open with.
|
|
* @param {string} [closeTransition] - Type of transition closing view will close with.
|
|
* @param {boolean} [addToStack = false] - if 'true' closed views are added to the view stack.
|
|
* @param {jibo.face.views~STACK_DIRECTION} [stackDirection] - Specifies the stack direction associated with the transition, if undefined does not take stack direction into account
|
|
* STACK_DIRECTION.UP indicates view is being added to stack.
|
|
* STACK_DIRECTION.DOWN indicates view is being removed.
|
|
* STACK_DIRECTION.SWAP indicates the views are being swapped and there is no change to the stack size.
|
|
* @returns {Promise<jibo.face.views.View>}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Close and destroy given view's paused views.
|
|
* method jibo.face.views#closePaused
|
|
* @param {jibo.face.views.ViewProcess} process Active view process.
|
|
* @param {jibo.face.views.View} view - View whose paused views to close.
|
|
* @param {string} [closeTransition] - Type of transition Views will open with.
|
|
* @param {boolean} [addToStack = false] - if 'true' closed views are added to the view stack.
|
|
* @param {boolean} [destroyViews = true] - if 'true' views will be destroyed.
|
|
* @returns {Promise<jibo.face.views.View>}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Close and destroy given view and all paused views beneath it.
|
|
* method jibo.face.views#closeViewWithPaused
|
|
* @param {jibo.face.views.ViewProcess} process Active view process.
|
|
* @param {jibo.face.views.View} view - View to close.
|
|
* @param {string} [closeTransition] - Type of transition Views will open with.
|
|
* @param {boolean} [addToStack = false] - if 'true' closed views are added to the view stack.
|
|
* @param {boolean} [destroyViews = true] - if 'true' views will be destroyed.
|
|
* @returns {Promise<jibo.face.views.View>}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Close a list of views.
|
|
* Generally used to close a view and the pause chain beneath it.
|
|
* @method jibo.face.views#closeGroup
|
|
* @param {jibo.face.views.ViewProcess} process Active view process.
|
|
* @param {jibo.face.views.View[]} closingViews - Array of Views to close in order of stack, with lowest at 0.
|
|
* @param {string} [closeTransition] - Type of transition Views will open with.
|
|
* @param {boolean} [addToStack = false] - if 'true' closed views are added to the view stack.
|
|
* @param {boolean} [destroyViews = true] - if 'true' views will be destroyed.
|
|
* @returns {Promise<jibo.face.views.View>}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Pause current view and open next above it.
|
|
* method jibo.face.views#pauseThenOpen
|
|
* @param {jibo.face.views.ViewProcess} process Active view process.
|
|
* @param {jibo.face.views.View} nextView - View to open.
|
|
* @param {jibo.face.views.View} pausingView - View to pause.
|
|
* @param {jibo.face.views.PauseOverlay#PauseOptions} [pauseOptions] - Specific pause options, if undefined falls back to nextView.pauseOptions.
|
|
* @param {string} [openTransition] - Type of transition nextView will open with.
|
|
* @returns {Promise<jibo.face.views.View>}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Helper to sets transitions for opening and closing views.
|
|
* @param {jibo.face.views.views.View} nextView - View that will be opening
|
|
* @param {jibo.face.views.views.View} closingView - View that will be closing.
|
|
* @param {jibo.face.views~STACK_DIRECTION} [stackDirection] - Specifies the stack direction associated with the transition, if undefined does not take stack direction into account
|
|
* STACK_DIRECTION.UP indicates view is being added to stack.
|
|
* STACK_DIRECTION.DOWN indicates view is being removed.
|
|
* STACK_DIRECTION.SWAP indicates the views are being swapped and there is no change to the stack size.
|
|
*/
|
|
|
|
/**
|
|
* Returns the View from the top of the stack of ViewStates.
|
|
* @method jibo.face.views#popViewFromStack
|
|
* @return {jibo.face.views.View}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Converts given View to ViewState and adds to top of the stack of ViewStates.
|
|
* Given View must be in acceptable state to be converted to ViewState, otherwise it will not be added to stack.
|
|
* @method jibo.face.views#pushViewToStack}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Converts given View and its paused View chain to ViewStates and adds them to the stack of ViewStates in the right order.
|
|
* Views must be in acceptable state to be converted to ViewState, otherwise they will not be added to stack.
|
|
* @method jibo.face.views#pushViewWithPausedToStack
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Clear view stack so only root ViewState remains.
|
|
* If the currentView given is an EyeView remove all view states,
|
|
* otherwise leave EyeView ViewState as the only view state in view stack.
|
|
* @method jibo.face.views#clearViewStack
|
|
* @param {jibo.face.views.View} [currentView] - The view that is or will be the current view.
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Update the attention mode, ensuring that it is a Menu mode when a GUI view is active, and
|
|
* deactivating our Menu mode if it is no longer a GUI.
|
|
* @method jibo.face.views#updateAttentionMode
|
|
* @param {jibo.face.views.View} [view] - The view that is or will be the current view.
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Set PIXI's texture garbage collection to auto garbage collect or manually collect. only run when an Eye view is active.
|
|
* @method jibo.face.views#setTextureGC
|
|
* @param {boolean} [autoOn] - If `true` texture garbage collection is set to auto, if 'false' it is set to manual
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Using supplied assets creates a border around the screen.
|
|
* Placed above ViewManager.stage so that everything created within ViewManager will be beneath it.
|
|
* @method jibo.face.views#createBorder
|
|
* @param {PIXI.Texture} cornerTexture - asset for corner
|
|
* @param {PIXI.Texture} edgeTexture - asset for edge
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Register default GUI classes.
|
|
* @method jibo.face.views#registerDefaults
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Check if given views are in a valid state (e.g. not destroyed)
|
|
* @method jibo.face.views#checkViewsValid
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Log view process and view status events, useful for debugging.
|
|
* @method jibo.face.views#logEvents
|
|
* @private
|
|
*/ |