SectionsController.as

Go to the documentation of this file.

import mx.utils.Delegate;

import gugga.application.ISectionsController;
import gugga.application.Section;
import gugga.application.SectionsTransition;
import gugga.application.TransitionInfo;
import gugga.collections.HashTable;
import gugga.common.EventDescriptor;
import gugga.components.ISectionLoader;
import gugga.components.SectionAttacher;
import gugga.components.SectionLoader;
import gugga.debug.Assertion;
import gugga.sequence.ExecuteAsyncMethodTask;
import gugga.sequence.FictiveTask;
import gugga.sequence.TaskManager;
import gugga.utils.Listener;
import gugga.utils.Locker;

[Event("currentSectionPathChanged")]

class gugga.application.SectionsController extends Section implements ISectionsController
{
        private var mSectionsInitializationStartTask : FictiveTask;
        private var mSectionsInitializationEndTask : FictiveTask;
        private var mSectionsControllerInitializingSequence : TaskManager;
        //private var mSubSectionsInitializationSequence : TaskSequence;

        private var mSections : HashTable;

        private var mMouseEventsLocker : Locker;

        private var mLazySectionLoaders : HashTable;
        private var mDetachAfterCloseSections : HashTable;

        private var mTransition : SectionsTransition;

        private var mTargetSectionID : String;
        
        private var mCurrentSection : Section;
        public function get CurrentSection() : Section { return mCurrentSection; }
        
        private var mCurrentSectionID : String;
        public function get CurrentSectionID() : String { return mCurrentSectionID; }

        private var mCurrentSectionPath : String;
        public function get CurrentSectionPath() : String { return mCurrentSectionPath; }

        private var mIsTransitingSections : Boolean = false;
        public function get IsTransitingSections() : Boolean { return mIsTransitingSections; }
        public /*protected*/ function set IsTransitingSections(aValue:Boolean) : Void { mIsTransitingSections = aValue; }

        private var mDisableNavigationWhenTransiting : Boolean = false;
        public function get DisableNavigationWhenTransiting() : Boolean { return mDisableNavigationWhenTransiting; }
        public function set DisableNavigationWhenTransiting(aValue:Boolean) : Void { mDisableNavigationWhenTransiting = aValue; }

        private var mSectionSwfsLoadingPart : Number = 70;
        public function get SectionSwfsLoadingPart() : Number { return mSectionSwfsLoadingPart; }
        public function set SectionSwfsLoadingPart(aValue:Number) : Void { mSectionSwfsLoadingPart = aValue; }

        function SectionsController()
        {
                mSections = new HashTable();
                mMouseEventsLocker = new Locker();
                
                mLazySectionLoaders = new HashTable();
                mDetachAfterCloseSections = new HashTable();
        }
        
        private function initUI() : Void
        {
                super.initUI();
                
                createSectionInitializationSequence();
        }

        private function getSectionID(aSection:Section) : String
        {
                for(var key:String in mSections)
                {
                        if(mSections[key] == aSection)
                        {
                                return key;
                        }
                }
                
                return null;
                //Assertion.warning(aSection + " not found", this, arguments);
        }

        public function getCurrentSectionPath() : String
        {
                return CurrentSectionPath;
        }       
        
        private function harvestCurrentSectionPath() : Void
        {
                var sectionPath : String = CurrentSectionID;

                if(mCurrentSection instanceof ISectionsController)
                {
                        sectionPath += "." + ISectionsController(mCurrentSection).getCurrentSectionPath();
                }
                
                mCurrentSectionPath = sectionPath;
                dispatchEvent({type: "currentSectionPathChanged", target: this});
        }
        
        private function createSectionInitializationSequence() : Void
        {
                var initializingSequence : TaskManager = new TaskManager();
                mSectionsInitializationStartTask = new FictiveTask();
                mSectionsInitializationEndTask = new FictiveTask();
                
                initializingSequence.addStartingTasks([mSectionsInitializationStartTask]);
                                
                initializingSequence.addTaskWithPredecessor(mSectionsInitializationEndTask, mSectionsInitializationStartTask);
                initializingSequence.setFinalTask(mSectionsInitializationEndTask);
                
                //sub sections initialization
                //mSubSectionsInitializationSequence = new TaskSequence();
                
                //initializingSequence.addTaskWithPredecessor(mSubSectionsInitializationSequence, mSectionsInitializationStartTask);
                //initializingSequence.addTaskPredecessor(mSectionsInitializationEndTask, mSubSectionsInitializationSequence);
                
                //register
                mSectionsControllerInitializingSequence = initializingSequence;
                registerInitializingTask(initializingSequence);
        }
                
        public function registerSection(aSectionInstance:Section, aID:String)
        {
                Assertion.failIfEmpty(aID, "aID is empty", this, arguments);                    
                Assertion.failIfNotNull(mSections[aID], "mSections[" + aID + "] already exists", this, arguments);      
                Assertion.failIfNull(aSectionInstance, "aSectionInstance is null", this, arguments);                            
                                
                mSections[aID] = aSectionInstance;
                
                if(aSectionInstance instanceof ISectionsController)
                {
                        ISectionsController(aSectionInstance).addEventListener(
                                "currentSectionPathChanged", Delegate.create(this, onSubControllerSectionPathChanged));
                }
                
                var initializeSectionTask : ExecuteAsyncMethodTask = ExecuteAsyncMethodTask.createBasic(
                        "initialized", aSectionInstance, aSectionInstance.initialize);
                        
                mSectionsControllerInitializingSequence.addTaskWithPredecessor(initializeSectionTask, mSectionsInitializationStartTask);
                mSectionsControllerInitializingSequence.addTaskPredecessor(mSectionsInitializationEndTask, initializeSectionTask);
        }
        
        public function registerChildSection(aSectionInstanceName:String, aID:String)
        {
                registerSection(this[aSectionInstanceName], aID);
                return this[aSectionInstanceName];
        }
        
        public function registerLazyLoadSection(aSectionLoader:SectionLoader, aSectionSwfPath:String, aID:String, aDetachAfterClose:Boolean)
        {
                Assertion.failIfEmpty(aSectionSwfPath, "aSectionSwfPath is empty", this, arguments);                            
                
                aSectionLoader.ContentPath = aSectionSwfPath;
                registerLazySection(aSectionLoader, aID, aDetachAfterClose);
        }
        
        public function registerLazyAttachSection(aSectionAttacher:SectionAttacher, aSectionLinkage:String, aID:String, aDetachAfterClose:Boolean)
        {
                Assertion.failIfEmpty(aSectionLinkage, "aSectionLinkage is empty", this, arguments);
                
                aSectionAttacher.SectionLinkage = aSectionLinkage;
                registerLazySection(aSectionAttacher, aID, aDetachAfterClose);
        }
        
        public function registerLazySection(aSectionLoader:ISectionLoader, aID:String, aDetachAfterClose:Boolean)
        {
                Assertion.failIfEmpty(aID, "aID is empty", this, arguments);                    
                Assertion.failIfNotNull(mSections[aID], "mSections[" + aID + "] is already exists", this, arguments);   
                
                aSectionLoader.addEventListener("sectionAvailable", Delegate.create(this, onLazySubSectionAvailable));
                
                mLazySectionLoaders[aID] = aSectionLoader;
                mDetachAfterCloseSections[aID] = aDetachAfterClose;
        }
        
        //TODO: can be done in onLazyTargetSectionInitialized()
        private function onLazySubSectionAvailable(ev) : Void
        {
                var section : Section = ev["section"];
                
                if(section instanceof ISectionsController)
                {
                        ISectionsController(section).addEventListener(
                                "currentSectionPathChanged", Delegate.create(this, onSubControllerSectionPathChanged));
                }
        }
                
        private function isSectionIDRegistered(aSectionID:String) : Boolean
        {
                if(mSections.containsKey(aSectionID))
                {
                        return true;
                }
                else if(mLazySectionLoaders.containsKey(aSectionID))
                {
                        return true;
                }
                else
                {
                        return false;
                }
        }               
                
        private function isLazySection(aSectionID:String) : Boolean
        {
                return mLazySectionLoaders.containsKey(aSectionID);
        }
        
        private function isDetachAfterCloseSection(aSectionID:String) : Boolean
        {
                if(mDetachAfterCloseSections.containsKey(aSectionID))
                {
                        return mDetachAfterCloseSections[aSectionID];
                }
                else
                {
                        return false;
                }
        }
        
        private function needLazyLoad(aSectionID:String) : Boolean
        {
                if(mSections.containsKey(aSectionID))
                {
                        return false;
                }
                else if(mLazySectionLoaders.containsKey(aSectionID))
                {
                        return true;
                }
                else
                {
                        Assertion.fail("Invalid section ID", this, arguments);
                }
        }
        
        //TODO: Can be ranamed to generateTransitionInfo()
        private function getTransitionInfo(aSectionID:String, aSectionPathRest:String) : TransitionInfo
        {
                var transitionInfo : TransitionInfo = new TransitionInfo();
                
                transitionInfo.SectionsController = this;
                
                transitionInfo.CurrentSection = mCurrentSection;
                transitionInfo.TargetSection = mSections[aSectionID];
                
                if(isLazySection(aSectionID))
                {
                        transitionInfo.TargetSectionLoader = mLazySectionLoaders[aSectionID];
                        transitionInfo.DoLoadTargetSection = needLazyLoad(aSectionID);
                }
                
                transitionInfo.DetachCurrentSectionAfterClose = isDetachAfterCloseSection(aSectionID);
                transitionInfo.SectionPathRest = aSectionPathRest;
                
                return transitionInfo; 
        }       
        
        //TODO: Can be ranamed to generateTransition()
        private function getTransition(aSectionID:String, aSectionPathRest:String) : SectionsTransition
        {
                var transitionInfo : TransitionInfo = getTransitionInfo(aSectionID, aSectionPathRest);
        
                var transition : SectionsTransition = new SectionsTransition(transitionInfo);   
                return transition;
        }
        
        private function startTransition(aTransition:SectionsTransition) : Void
        {
                //TODO: Listener should be destroyed after transition is destroyed
                Listener.createSingleTimeListener(
                        new EventDescriptor(aTransition, "lazyTargetSectionInitialized"), 
                        Delegate.create(this, onLazyTargetSectionInitialized)
                );
                
                Listener.createSingleTimeListener(
                        new EventDescriptor(aTransition, "sectionsSwapped"), 
                        Delegate.create(this, onSectionsSwapped)
                );
                
                Listener.createSingleTimeListener(
                        new EventDescriptor(aTransition, "currentSectionDestroyed"), 
                        Delegate.create(this, onCurrentSectionDestroyed)
                );
                
                Listener.createSingleTimeListener(
                        new EventDescriptor(aTransition, "completed"), 
                        Delegate.create(this, onTransitionCompleted)
                );
                
                //TODO: Listener should be destroyed after transition is destroyed
                Listener.createSingleTimeListener(
                        new EventDescriptor(aTransition, "interrupted"), 
                        Delegate.create(this, onTransitionInterrupted)
                );
                
                Listener.createSingleTimeListener(
                        new EventDescriptor(aTransition, "disposed"), 
                        Delegate.create(this, onTransitionDisposed)
                );
                
                aTransition.start();
        }
        
        public function openSection(aSectionPath:String) : SectionsTransition
        {
                Assertion.failIfEmpty(aSectionPath, "Argument aPath is empty", this, arguments);
                Assertion.failIfNotNull(mTransition, "Old transition is still alive", this, arguments);
                Assertion.failIfTrue(mTransition.isRunning(), "Old transition is still running", this, arguments);
        
                var pathArray:Array = aSectionPath.split(".");
                var sectionID:String = pathArray[0];
                var sectionPathRest:String; 
                
                mTargetSectionID = sectionID;
                
                Assertion.failIfReturnsFalse(
                        this, isSectionIDRegistered, [sectionID], 
                        "Section ID '" + sectionID + "' is not registered", this, arguments);
                
                if(pathArray.length > 1)
                {
                        var sectionPathRestArray:Array = pathArray.slice(1);
                        sectionPathRest = sectionPathRestArray.join(".");
                }
        
                if(mCurrentSectionID == sectionID)
                {
                        var currentSection : Section = Section(mSections[mCurrentSectionID]);
                        
                        if(currentSection)
                        {
                                if((currentSection instanceof ISectionsController) && sectionPathRest)
                                {
                                        var openChildSectionsTransition : SectionsTransition = 
                                                ISectionsController(currentSection).openSection(sectionPathRest);
                                        
                                        return openChildSectionsTransition;
                                }                       
                                else
                                {
                                        return null;
                                }
                        }
                }
        
                //-------------- actual section opening
                
                mIsTransitingSections = true;
                
                /*
                if(mDisableNavigationWhenTransiting)
                {
                        setNavigationLock("DisableNavigationWhenTransitingLock_" + this);
                }
                 */
                
                mTransition = getTransition(sectionID, sectionPathRest);
                
                if(mTransition)
                {
                        startTransition(mTransition);
                }
                
                return mTransition;
        }
        
        private function isSectionClosing(aSectionPath:String) : Boolean
        {
                var pathArray:Array = aSectionPath.split(".");
                var sectionID:String = pathArray[0];
                var section:Section = mSections[sectionID];
                
                if(section instanceof SectionsController)
                {
                        var sectionPathRest:String = ""; 
                        
                        if(pathArray.length > 1)
                        {
                                var sectionPathRestArray:Array = pathArray.slice(1);
                                sectionPathRest = sectionPathRestArray.join(".");
                        }
                        
                        return SectionsController(section).isSectionClosing(sectionPathRest);
                }
                else
                {
                        return section.IsClosing;
                }
        }
        
        private function onLazyTargetSectionInitialized(ev) : Void 
        {
                var section : Section = ev.section;
                mSections[mTargetSectionID] = section;
        }
        
        private function onCurrentSectionDestroyed(ev) : Void
        {
                var sectionID : String = getSectionID(ev.section);
                if(mLazySectionLoaders.containsKey(sectionID))
                {
                        var sectionLoader : ISectionLoader = mLazySectionLoaders[sectionID];
                        sectionLoader.unloadData();
                }
                
                mSections[sectionID] = null;
        }
        
        private function onSectionsSwapped(ev) : Void 
        {
                mCurrentSectionID = mTargetSectionID;
                mCurrentSection = mSections[mCurrentSectionID];
                
                harvestCurrentSectionPath();
        }
        
        private function onSubControllerSectionPathChanged(ev) : Void 
        {
                harvestCurrentSectionPath();
        }
        
        private function onTransitionCompleted(ev) : Void 
        {
                mTargetSectionID = null;
                mIsTransitingSections = false;

                //clearNavigationLock("DisableNavigationWhenTransitingLock_" + this);
        }
        
        private function onTransitionInterrupted(ev) : Void 
        {
                mTargetSectionID = null;
                mIsTransitingSections = false;
                
                mCurrentSection = ev.newCurrentSection;
                mCurrentSectionID = getSectionID(mCurrentSection);

                //clearNavigationLock("DisableNavigationWhenTransitingLock_" + this);
        }
        
        private function onTransitionDisposed(ev) : Void 
        {
                delete mTransition;
        }
        
        public function enableBoundingBoxMouseEvents() : Void
        {
                mMouseEventsLocker.clearAllLocks();
                super.enableBoundingBoxMouseEvents();
        }
        
        public function setMouseEventsLock(aLockID:String) : String
        {
                disableBoundingBoxMouseEvents();
                return mMouseEventsLocker.setLock(aLockID);
        }
        
        public function clearMouseEventsLock(aLockID:String) : Void
        {
                mMouseEventsLocker.clearLock(aLockID);
                
                if(!mMouseEventsLocker.isLocked())
                {
                        super.enableBoundingBoxMouseEvents();
                }
        }       
}

---