SectionsTransition.as

Go to the documentation of this file.

import gugga.events.EventDispatcher;
import mx.utils.Delegate;

import gugga.application.ISectionsController;
import gugga.application.Section;
import gugga.application.TransitionInfo;
import gugga.common.EventDescriptor;
import gugga.common.IProgressiveTask;
import gugga.common.ITask;
import gugga.components.ISectionLoader;
import gugga.components.SectionAttacher;
import gugga.components.SectionLoader;
import gugga.sequence.FictiveTask;
import gugga.sequence.PreconditionsTask;
import gugga.sequence.ProgressMonitor;
import gugga.utils.DoLaterUtil;
import gugga.utils.Listener;

[Event("lazyTargetSectionAvailable")]
[Event("lazyTargetSectionUIInitialized")]
[Event("lazyTargetSectionInitialized")]

[Event("targetSectionActivate")]
[Event("targetSectionOpen")]

[Event("currentSectionDestroyed")]
[Event("currentSectionClose")]
[Event("currentSectionDestroy")]

[Event("setNavigationLock")]
[Event("clearNavigationLock")]

[Event("sectionsSwapped")]

[Event("disposed")]

class gugga.application.SectionsTransition 
        extends EventDispatcher 
        implements ITask 
{
        private var mOpenTargetSectionPreconditions : PreconditionsTask;
        private var mDisposePreconditions : PreconditionsTask;
        
        private var mDoLoadTargetSection : Boolean;
        private var mDetachCurrentSectionAfterClose : Boolean;
        private var mSectionPathRest : String;
        
        private var mChildSectionsTransition : SectionsTransition;
        
        private var mIsRunning : Boolean = false;
        private var mIsInterrupting : Boolean = false;
        
        private var mTargetSectionInitializedTask : FictiveTask;
                
        private var mPreOpenProgressMonitor : ProgressMonitor;
        public function get PreOpenProgressMonitor() : ProgressMonitor { return mPreOpenProgressMonitor; }
        
        private var mSectionsController : ISectionsController;
        public function get SectionsController() : ISectionsController { return mSectionsController; }
        
        private var mCurrentSection : Section;
        public function get CurrentSection() : Section { return mCurrentSection; }
        
        private var mTargetSection : Section;
        public function get TargetSection() : Section { return mTargetSection; }
        
        private var mTargetSectionLoader : ISectionLoader;
        public function get TargetSectionLoader() : ISectionLoader { return mTargetSectionLoader; }
        
        public function SectionsTransition(aTransitionInfo:TransitionInfo) 
        {
                mSectionsController = aTransitionInfo.SectionsController;
                mCurrentSection = aTransitionInfo.CurrentSection;
                mDetachCurrentSectionAfterClose = aTransitionInfo.DetachCurrentSectionAfterClose;
                mTargetSection = aTransitionInfo.TargetSection;
                mTargetSectionLoader = aTransitionInfo.TargetSectionLoader;
                mDoLoadTargetSection = aTransitionInfo.DoLoadTargetSection;
                mSectionPathRest = aTransitionInfo.SectionPathRest;
                
                mTargetSectionInitializedTask = new FictiveTask();
                
                mPreOpenProgressMonitor = new ProgressMonitor();
                mOpenTargetSectionPreconditions = new PreconditionsTask();
                
                mDisposePreconditions = new PreconditionsTask();
                mDisposePreconditions.add(new EventDescriptor(this, "readyToDispose"));
                
                Listener.createSingleTimeListener(
                        new EventDescriptor(mDisposePreconditions, "completed"),
                        Delegate.create(this, onDisposePreconditionsMet)
                );
                
                mOpenTargetSectionPreconditions.add(new EventDescriptor(mPreOpenProgressMonitor, "completed"));
                
                Listener.createSingleTimeListener(
                        new EventDescriptor(mOpenTargetSectionPreconditions, "completed"),
                        Delegate.create(this, onOpenTargetSectionPreconditionsMet)
                );
        }
         
        public function start() : Void 
        {
                mIsRunning = true;
                mIsInterrupting = false;
                
                closeCurrentSectionIfNeeded();
        
                if(mDoLoadTargetSection)
                {
                        openLazySection();
                }
                else
                {
                        openInitializedSection();
                }
        }
        
        private function closeCurrentSectionIfNeeded() : Void
        {
                if(mCurrentSection && !mCurrentSection.IsClosed)
                {
                        closeCurrentSection();
                }
        }       
        
        private function closeCurrentSection() : Void
        {
                mOpenTargetSectionPreconditions.add(new EventDescriptor(mCurrentSection, "closed"));
                        
                Listener.createSingleTimeListener(
                        new EventDescriptor(mCurrentSection, "closed"), 
                        Delegate.create(this, onCurrentSectionClosed)
                );
                
                if(!mCurrentSection.IsClosing)
                {
                        triggerCurrentSectionClose();
                }
        }
        
        public function isRunning() : Boolean 
        {
                return mIsRunning || mChildSectionsTransition.isRunning();
        }
        
        public function isInterrupting() : Boolean 
        {
                return mIsInterrupting || mChildSectionsTransition.isInterrupting();
        }

        public function canInterrupt() : Boolean
        {
                return true && (!mChildSectionsTransition || mChildSectionsTransition.canInterrupt());
        }

        public function isImmediatelyInterruptable() : Boolean 
        {
                var result =  
                (!mChildSectionsTransition || (mChildSectionsTransition && mChildSectionsTransition.isImmediatelyInterruptable())) &&
                //(!mCurrentSection.IsClosing || (mCurrentSection.IsClosing && mCurrentSection.isClosingImmediatelyInterruptable())) &&
                (!mTargetSection.IsInitializing || (mTargetSection.IsInitializing && mTargetSection.isInitializationImmediatelyInterruptable())) &&
                (!mTargetSection.IsActivating || (mTargetSection.IsActivating && mTargetSection.isActivationImmediatelyInterruptable())) &&
                (!mTargetSection.IsOpening || (mTargetSection.IsOpening && mTargetSection.isOpeningImmediatelyInterruptable()));
                
                return result;
        }

        public function interrupt() : Void 
        {
                mIsInterrupting = true;
                
                //just in case. can be removed. defence is put in trigger...() methods
                mOpenTargetSectionPreconditions.interrupt();
                
                var interuptedPreconditions : PreconditionsTask = new PreconditionsTask();
                var newCurrentSection : Section = getNewCurrentSectionAfterInterruption();
                
                /*
                if(mCurrentSection.IsClosing)
                {
                        DebugUtils.traceContext("--------- interruptClose", this, arguments);
                        
                        interuptedPreconditions.add(new EventDescriptor(mCurrentSection, "closeInterrupted"));
                        mCurrentSection.interruptClose();
                }
                 * 
                 */
                                
                if(mTargetSection && mTargetSection.IsInitializing)
                {
                        interuptedPreconditions.add(new EventDescriptor(mCurrentSection, "initializationInterrupted"));
                        mTargetSection.interruptInitialization();
                }
                
                if(mTargetSection && mTargetSection.IsActivating)
                {
                        interuptedPreconditions.add(new EventDescriptor(mTargetSection, "activationInterrupted"));
                        mTargetSection.interruptActivation();
                }
                
                if(mTargetSection && mTargetSection.IsOpening)
                {
                        interuptedPreconditions.add(new EventDescriptor(mTargetSection, "openInterrupted"));
                        mTargetSection.interruptOpen();
                }
                
                if(mChildSectionsTransition && mChildSectionsTransition.isRunning())
                {
                        interuptedPreconditions.add(new EventDescriptor(mChildSectionsTransition, "interrupted"));
                        mChildSectionsTransition.interrupt(); 
                }
                
                Listener.createSingleTimeMergingListener(
                        new EventDescriptor(interuptedPreconditions, "completed"), 
                        Delegate.create(this, onInterrupted),
                        {newCurrentSection: newCurrentSection}
                );
                
                interuptedPreconditions.start();
                
                if(!mDisposePreconditions.isRunning())
                {
                        mDisposePreconditions.start();
                }
        }
        
        private function getNewCurrentSectionAfterInterruption() : Section
        {
                var result : Section = mCurrentSection;
                
                if(mTargetSection.IsOpening)
                {
                        result = mTargetSection;
                }
                
                return result;
        }
        
        private function onInterrupted(ev) : Void 
        {
                mIsInterrupting = false;
                mIsRunning = false;
                
                dispatchEvent({type: "interrupted", target: this, newCurrentSection: ev.newCurrentSection});
                dispatchEvent({type: "readyToDispose", target: this});
        }
        
        private function triggerTargetSectionActivate() : Void
        {
                if(mIsRunning && !mIsInterrupting)
                {
                        dispatchEvent({type: "targetSectionActivate", target: this}); 
                        mTargetSection.activate();
                }
        }

        private function triggerTargetSectionOpen() : Void
        {
                dispatchEvent({type: "sectionsSwapped", target: this});
                
                if(mIsRunning && !mIsInterrupting)
                {
                        dispatchEvent({type: "targetSectionOpen", target: this});
                        mTargetSection.open();
                }
        }

        private function triggerCurrentSectionClose() : Void
        {
                //TODO: this check should be revised, maybe removed
                if(mIsRunning && !mIsInterrupting)
                {
                        dispatchEvent({type: "currentSectionClose", target: this});
                        mCurrentSection.close();
                }
        }

        private function triggerCurrentSectionDestroy() : Void
        {
                //just trigger without check, because if the section is closed 
                //and we should deatach it, it must be done regardless of the 
                //transition's state
                dispatchEvent({type: "currentSectionDestroy", target: this});
                mCurrentSection.destroy();
        }
        
        private function triggerSectionsControllerOpenSection(aSectionsController : ISectionsController, 
                aSectionPath : String) : SectionsTransition
        {
                //TODO: aSectionsController should be informed that it should prepare to open a new section
                //before it is initialized
                mChildSectionsTransition = aSectionsController.openSection(aSectionPath);
                return mChildSectionsTransition;
        }       
        
        private function openLazySection() : Void
        {
                Listener.createSingleTimeListener(
                        new EventDescriptor(mTargetSectionLoader, "sectionAvailable"), 
                        Delegate.create(this, onLazyTargetSectionAvailable)
                );

                Listener.createSingleTimeListener(
                        new EventDescriptor(mTargetSectionLoader, "sectionUIInitialized"), 
                        Delegate.create(this, onLazyTargetSectionUIInitialized)
                );

                Listener.createSingleTimeListener(
                        new EventDescriptor(mTargetSectionLoader, "sectionInitialized"), 
                        Delegate.create(this, onLazyTargetSectionInitialized)
                );
                
                if(mTargetSectionLoader instanceof SectionLoader)
                {
                        openLazyLoadSection();
                }
                else if(mTargetSectionLoader instanceof SectionAttacher)
                {
                        openLazyAttachSection();
                }
        }
        
        private function openLazyLoadSection() : Void
        {
                mPreOpenProgressMonitor.addFixedPartItem(mTargetSectionInitializedTask, 0);
                
                var targetSectionLoader : SectionLoader = SectionLoader(mTargetSectionLoader);
                mPreOpenProgressMonitor.addItem(targetSectionLoader);
                
                mTargetSectionLoader.start();
        }

        private function openLazyAttachSection() : Void
        {
                mPreOpenProgressMonitor.addFixedPartItem(mTargetSectionInitializedTask, 0);
                
                mTargetSectionLoader.start();
        }
        
        private function openInitializedSection() : Void
        {
                getAndMonitorTargetSectionPreOpenProgress();
                triggerTargetSectionActivate();
                
                openAndMonitorTargetSubSection();
                
                startMonitoringPreOpenProgress();
                startMonitoringOpenTargetSectionPreconditions();
        }
        
        private function onLazyTargetSectionAvailable(ev) : Void 
        {
                mTargetSection = ev.section;
                dispatchEvent({type: "lazyTargetSectionAvailable", target: this, section: ev.section});
        }

        private function onLazyTargetSectionUIInitialized(ev) : Void 
        {
                dispatchEvent({type: "lazyTargetSectionUIInitialized", target: this, section: ev.section});
                
                getAndMonitorTargetSectionPreOpenProgress();
                startMonitoringPreOpenProgress();
        }

        private function onLazyTargetSectionInitialized(ev) : Void 
        {
                dispatchEvent({type: "lazyTargetSectionInitialized", target: this, section: ev.section});
                triggerTargetSectionActivate();

                openAndMonitorTargetSubSection();
                startMonitoringOpenTargetSectionPreconditions();
                
                mTargetSectionInitializedTask.start();
        }
        
        private function startMonitoringOpenTargetSectionPreconditions() : Void
        {
                mOpenTargetSectionPreconditions.start();
        }

        private function startMonitoringPreOpenProgress() : Void
        {
                mPreOpenProgressMonitor.start();
        }

        private function getAndMonitorTargetSectionPreOpenProgress() : Void
        {
                var sectionPreOpenProgressMonitoringTask : IProgressiveTask = mTargetSection.getPreOpenProgressMonitoringTask();
                
                if(sectionPreOpenProgressMonitoringTask)
                {       
                        monitorTargetSectionPreOpenProgress(sectionPreOpenProgressMonitoringTask);
                }
        }
        
        private function monitorTargetSectionPreOpenProgress(aSectionPreOpenProgressMonitoringTask : IProgressiveTask) : Void
        {
                mPreOpenProgressMonitor.addItem(aSectionPreOpenProgressMonitoringTask);
        }
        
        private function openAndMonitorTargetSubSection() : Void
        {               
                if((mTargetSection instanceof ISectionsController) && (mSectionPathRest != "" && mSectionPathRest != null && mSectionPathRest != undefined))
                {
                        var childSectionsTransition : SectionsTransition = 
                                triggerSectionsControllerOpenSection(ISectionsController(mTargetSection), mSectionPathRest);
                        
                        if(childSectionsTransition)
                        {
                                monitorSubTransition(childSectionsTransition);
                                mDisposePreconditions.add(new EventDescriptor(childSectionsTransition, "disposed"));
                        }
                }       
                
                mDisposePreconditions.start();
        }

        private function monitorSubTransition(aSubTransition:SectionsTransition) : Void
        {       
                monitorSubTransitionPreOpenProgress(aSubTransition.PreOpenProgressMonitor);
        }
        
        private function monitorSubTransitionPreOpenProgress(aChildSectionsPreOpenMonitor:IProgressiveTask) : Void
        {               
                mPreOpenProgressMonitor.addItem(aChildSectionsPreOpenMonitor);
        }
        
        public function addOpenTargetSectionPrecondition(aEventDescriptor:EventDescriptor) : Void
        {
                mOpenTargetSectionPreconditions.add(aEventDescriptor);
        }
        
        private function onOpenTargetSectionPreconditionsMet(ev) : Void
        {
                Listener.createSingleTimeListener(
                        new EventDescriptor(mTargetSection, "opened"), 
                        Delegate.create(this, onTargetSectionOpened)
                );
                
                triggerTargetSectionOpen();
        }
        
        private function onCurrentSectionClosed(ev) : Void
        {
                if(mDetachCurrentSectionAfterClose)
                {
                        Listener.createSingleTimeListener(
                                new EventDescriptor(mCurrentSection, "destroyed"),
                                Delegate.create(this, onCurrentSectionDestroyed)
                        );
                        
                        mDisposePreconditions.add(
                                new EventDescriptor(this, "currentSectionDestroyed"));
                
                        //TODO: revise. Why should we do it later
                        DoLaterUtil.doLater(this, triggerCurrentSectionDestroy, null, 1);
                }
        }
        
        private function onCurrentSectionDestroyed(ev) : Void
        {
                dispatchEvent({type: "currentSectionDestroyed", target: this, section : mCurrentSection});
        }
        
        private function onTargetSectionOpened(ev) : Void
        {
                completed();
        }
                
        private function completed() : Void
        {
                mIsRunning = false;
                mIsInterrupting = false;
                
                dispatchEvent({type: "completed", target: this});
        
                //dispose
                dispatchEvent({type: "readyToDispose", target: this});
        }

        private function onDisposePreconditionsMet() : Void 
        {
                //finish current frame's code and dispose
                DoLaterUtil.doLater(this, dispose, null, 1);
        }
        
        private function dispose() : Void
        {
                dispatchEvent({type: "disposed", target: this});
                removeAllEventListeners();
        }
}

---