yui/core/YuiFrameworkController.as

/*
* Copyright 2004-2010 the Seasar Foundation and the Others.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*/
package org.seasar.akabana.yui.framework.core
{
    CONFIG::FP10{
        import __AS3__.vec.Vector;
    }
    
    CONFIG::UNCAUGHT_ERROR_GLOBAL{
        import flash.events.UncaughtErrorEvent;
    }
    
    import flash.events.Event;
    import flash.errors.IllegalOperationError;
    import flash.system.Capabilities;
    import flash.display.DisplayObjectContainer;
    import flash.display.DisplayObject;
    import flash.utils.Dictionary;
    
    import mx.core.UIComponent;
    import mx.events.FlexEvent;
    import mx.managers.ISystemManager;
    import mx.managers.SystemManager;
    import mx.managers.CursorManager;
    import mx.managers.PopUpManager;
    import mx.managers.DragManager;
    import mx.styles.IStyleManager2;
    import mx.styles.CSSStyleDeclaration;
    
    import org.seasar.akabana.yui.core.Environment;
    import org.seasar.akabana.yui.core.yui_internal;
    
    import org.seasar.akabana.yui.framework.YuiFrameworkGlobals;
    import org.seasar.akabana.yui.framework.core.event.FrameworkEvent;
    import org.seasar.akabana.yui.framework.customizer.IComponentCustomizer;
    import org.seasar.akabana.yui.framework.customizer.IViewCustomizer;
    import org.seasar.akabana.yui.framework.customizer.IElementCustomizer;
    import org.seasar.akabana.yui.framework.error.YuiFrameworkContainerError;
    import org.seasar.akabana.yui.framework.util.UIComponentUtil;
    import org.seasar.akabana.yui.framework.util.StyleManagerUtil;
    import org.seasar.akabana.yui.framework.core.event.RuntimeErrorEvent;
    import org.seasar.akabana.yui.framework.logging.debug;
    import org.seasar.akabana.yui.framework.logging.dump;
    import org.seasar.akabana.yui.framework.logging.Logging;
    
    use namespace yui_internal;
    
    [ExcludeClass]
    public final class YuiFrameworkContainer extends YuiFrameworkContainerBase
    {   
        {
            CursorManager;
            PopUpManager;
            DragManager;
        }
        
        private static var _container:IYuiFrameworkContainer;
        
        public static function get yuicontainer():IYuiFrameworkContainer{
            return _container;
        }
        
        public function YuiFrameworkContainer(){
            super();
            if( _container == null ){
                _container = this;
            } else {
                throw new YuiFrameworkContainerError("container is already created.");
            }            
        }
        
        public function addExternalSystemManager(sm:ISystemManager ):void{
            addRootDisplayObject(sm as DisplayObject);
        }
        
        public function removeExternalSystemManager(sm:ISystemManager ):void{
            removeRootDisplayObject(sm as DisplayObject);
        }
        
        public override function customizeView( container:DisplayObjectContainer ):void{
            var view:UIComponent = container as UIComponent;
            if( !view.initialized ){   
                CONFIG::DEBUG {         
                    debug(this,"customizeView:"+view+" is not initialize.");
                }
                return;
            }
            CONFIG::DEBUG{
                debug(this,"customizeView:"+view+",owner:"+view.owner);
            }
            var viewcustomizer_:IViewCustomizer; 
            for each( var customizer_:IElementCustomizer in _customizers ){
                viewcustomizer_ = customizer_ as IViewCustomizer;
                if( viewcustomizer_ != null ){
                    viewcustomizer_.customizeView( view );
                }
            }
        }
        
        public override function uncustomizeView( container:DisplayObjectContainer ):void{
            var view:UIComponent = container as UIComponent;
            if( !view.initialized ){     
                CONFIG::DEBUG {
                    debug(this,"customizeView:"+view+" is not initialize.");       
                }
                return;
            }
            CONFIG::DEBUG{
                debug(this,"uncustomizeView:"+view+",owner:"+view.owner);
            }
            var numCustomizers:int = customizers.length;
            var viewcustomizer_:IViewCustomizer;
            for( var i:int = numCustomizers-1; i >= 0; i-- ){
                viewcustomizer_ = customizers[i] as IViewCustomizer;
                if( viewcustomizer_ != null ){
                    viewcustomizer_.uncustomizeView( view );
                }
            }
        }
        
        public override function customizeComponent( container:DisplayObjectContainer, child:DisplayObject ):void{
            var view:UIComponent = container as UIComponent;
            var component:UIComponent = child as UIComponent;
            if( !view.initialized || !component.initialized){     
                CONFIG::DEBUG{
                    debug(this,"customizeComponent:"+view+" is not initialize.");       
                }
                return;
            }
            CONFIG::DEBUG{
                debug(this,"customizeComponent:start, "+child+",owner:"+container);
            }
            var componentcustomizer_:IComponentCustomizer;
            for each( var customizer_:IElementCustomizer in _customizers ){
                componentcustomizer_ = customizer_ as IComponentCustomizer;
                if( componentcustomizer_ != null ){
                    componentcustomizer_.customizeComponent( view, component );
                }
            }
            CONFIG::DEBUG{
                debug(this,"customizeComponent:end, "+child+",owner:"+container);
            }
        }
        
        public override function uncustomizeComponent( container:DisplayObjectContainer, child:DisplayObject ):void{
            var view:UIComponent = container as UIComponent;
            var component:UIComponent = child as UIComponent;
            if( !view.initialized ){     
                CONFIG::DEBUG{       
                    debug(this,"uncustomizeComponent:"+view+" is not initialize.");
                }
                return;
            }
            CONFIG::DEBUG{
                debug(this,"uncustomizeComponent:start, "+child+",owner:"+container);
            }
            var numCustomizers:int = customizers.length;
            var componentcustomizer_:IComponentCustomizer;
            for( var i:int = numCustomizers-1; i >= 0; i-- ){
                componentcustomizer_ = customizers[i] as IComponentCustomizer;
                if( componentcustomizer_ != null ){
                    componentcustomizer_.uncustomizeComponent( view, component );
                }
            }
            CONFIG::DEBUG{
                debug(this,"uncustomizeComponent:end, "+child+",owner:"+container);
            }
        }        
        
        private function applicationInitCompleteHandler( event:Event ):void{
            Logging.initialize();
            CONFIG::DEBUG_EVENT{
                dump(this,event);
            }
        }
        
        private function applicationPreloaderDoneHandler( event:Event ):void{
            CONFIG::DEBUG_EVENT{
                dump(this,event);
            }
            if( event.currentTarget is ISystemManager ){
                var sm:ISystemManager = event.currentTarget as ISystemManager;
                super.yui_internal::systemManagerMonitoringStart(sm as DisplayObject);
            } else {
                throw new IllegalOperationError("Illegal SystemManager"+event.currentTarget);
            }
            YuiFrameworkGlobals.initNamingConvention();
            CONFIG::DEBUG{
                debug(this,getMessage("ApplicationConventions",YuiFrameworkGlobals.public::namingConvention.conventions.toString()));
            }            
        }
        
        private function applicationCompleteHandler( event:FlexEvent ):void{
            CONFIG::DEBUG_EVENT{
                dump(this,event);
            }
            applicationMonitoringStop(event.currentTarget as DisplayObject);            
        }
        
        private function creationCompleteHandler(event:FlexEvent):void{
            CONFIG::DEBUG_EVENT{
                dump(this,event);
            }            
            doAssembleComponent(event.target as DisplayObject);
        }
        
        protected override function doRegisterComponent( target:DisplayObject ):void{
            var component:UIComponent = target as UIComponent;
            super.doRegisterComponent(component);
        }
        
        protected override function doUnregisterComponent(target:DisplayObject):void{
            var component:UIComponent = target as UIComponent;
            if( isView(component)){
                super.doUnregisterComponent(component);
            } else if(isComponent(component)){
                var document:UIComponent = component.document as UIComponent;
                if( document != null && document.initialized && isView(document)){
                    processDisassembleViewChild(document,component);
                }
            }
        }
        
        protected override function doAssembleComponent( target:DisplayObject ):void{
            var component:UIComponent = target as UIComponent;
            if( component == null || !component.initialized ){
                return;
            }
            if( isView(component)){
                processAssembleView(component);
            } else if(isComponent(component)){
                var document:UIComponent = component.document as UIComponent;
                if( document != null && document.initialized && isView(document)){
                    processAssembleViewChild(document,component);
                }
            }
        }
        
        protected override function processApplicationStart():void{
            const app:UIComponent = YuiFrameworkGlobals.public::frameworkBridge.application as UIComponent;
            const rootView:DisplayObjectContainer = YuiFrameworkGlobals.public::frameworkBridge.rootView as DisplayObjectContainer;
            app.setVisible(true,true);
            super.processApplicationStart();
            
            var allView:Dictionary = ViewComponentRepository.allView;
            var fevent:FrameworkEvent;
            for each (var view:UIComponent in allView) 
            {
                if( view === rootView ){
                    continue;
                }
                if( view.hasEventListener(FrameworkEvent.APPLICATION_START)){
                    fevent = new FrameworkEvent(FrameworkEvent.APPLICATION_START);
                    view.dispatchEvent( fevent );
                }
            }
        }
        
        protected override function getDefaultCustomizerClasses():Array{
            const styleManager:IStyleManager2 = StyleManagerUtil.getStyleManager();
            const customizersDef:CSSStyleDeclaration = styleManager.getStyleDeclaration(".customizers");
            const defaultFactory:Function = customizersDef.defaultFactory;
            
            const result:Array = [];
            const keys:Array = [];
            
            var customizers:Object = {};
            if (defaultFactory != null)
            {
                defaultFactory.prototype = {};
                customizers = new defaultFactory();
            }
            
            var customizer:Class;
            for( var key:String in customizers ){
                keys.push(key);
            }
            keys.sort();
            for( var i:int = 0; i < keys.length; i++ ){                
                customizer = customizers[keys[i]] as Class;
                result.push(customizer);
            }
            CONFIG::DEBUG{
                debug(this,"default customizers is "+result);
            }
            return result;
        }

        yui_internal override function applicationInitialize():void{
            if( _customizers == null ){
                _customizers = getDefaultCustomizers();
            }
            CONFIG::DEBUG{
                debug(this,getMessage("ViewComponentAssembleStart"));
            }
            
            var allView:Dictionary = ViewComponentRepository.allView;
            var view:UIComponent;
            for ( var viewName:String in allView ){
                CONFIG::DEBUG{
                    debug(this,getMessage("ViewComponentAssembleing",viewName));
                }
                view = ViewComponentRepository.getComponent(viewName) as UIComponent;
                if( view != null && view.initialized ){
                    processAssembleView(view);
                }
                CONFIG::DEBUG{
                    debug(this,getMessage("ViewComponentAssembled",viewName));
                }
            }
            
            CONFIG::DEBUG{
                debug(this,getMessage("ViewComponentAssembleEnd"));
            }
            _isApplicationStarted = true;
            callLater( processApplicationStart );
        }
        
        yui_internal override function isView(component:DisplayObject):Boolean{
            if( component == null || !(component is UIComponent)){
                return false;
            }
            if( YuiFrameworkGlobals.public::frameworkBridge.isContainer(component)){
                return YuiFrameworkGlobals.public::namingConvention.isViewClassName( getCanonicalName(component) );
            } else {
                return false;
            }
        }
        
        yui_internal override function isComponent( target:DisplayObject ):Boolean{
            var component:UIComponent = target as UIComponent;
            if( component == null || component.id == null || !(component is UIComponent)){
                return false;
            }
            return YuiFrameworkGlobals.public::frameworkBridge.isComponent(component);            
        }
        
        yui_internal override function applicationMonitoringStart(root:DisplayObject):void{
            root.addEventListener(
                FlexEvent.CREATION_COMPLETE,
                creationCompleteHandler,
                true,
                int.MAX_VALUE
            );
            super.yui_internal::applicationMonitoringStart(root);
        }
        
        yui_internal override function applicationMonitoringStop(root:DisplayObject):void{
            root.removeEventListener(
                FlexEvent.APPLICATION_COMPLETE,
                applicationCompleteHandler,
                false
            );
            
            root.removeEventListener(
                FlexEvent.INIT_COMPLETE,
                applicationInitCompleteHandler,
                true
            );
            
            root.removeEventListener(
                FlexEvent.PRELOADER_DONE,
                applicationPreloaderDoneHandler,
                true
            );
            super.applicationMonitoringStop(root);
        }
        
        yui_internal override function systemManagerMonitoringStart( root:DisplayObject ):void{
            root.addEventListener(
                FlexEvent.INIT_COMPLETE,
                applicationInitCompleteHandler,
                true,
                int.MAX_VALUE
            );
            
            root.addEventListener(
                FlexEvent.PRELOADER_DONE,
                applicationPreloaderDoneHandler,
                true,
                int.MAX_VALUE
            );
            
            root.addEventListener(
                FlexEvent.APPLICATION_COMPLETE,
                applicationCompleteHandler,
                false,
                int.MAX_VALUE
            );
        }
        
        yui_internal override function systemManagerMonitoringStop(root:DisplayObject):void{
            const application_:DisplayObjectContainer = YuiFrameworkGlobals.public::frameworkBridge.application;
            if( application_ != null ){
                root.removeEventListener(
                    FlexEvent.CREATION_COMPLETE,
                    creationCompleteHandler,
                    true
                );
            }
            super.yui_internal::systemManagerMonitoringStop(root);
        }
    }
}
1	e1arkw	404	/*
2	e1arkw	1316	* Copyright 2004-2010 the Seasar Foundation and the Others.
3			*
4			* Licensed under the Apache License, Version 2.0 (the "License");
5			* you may not use this file except in compliance with the License.
6			* You may obtain a copy of the License at
7			*
8			* http://www.apache.org/licenses/LICENSE-2.0
9			*
10			* Unless required by applicable law or agreed to in writing, software
11			* distributed under the License is distributed on an "AS IS" BASIS,
12			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
13			* either express or implied. See the License for the specific language
14			* governing permissions and limitations under the License.
15			*/
16	e1arkw	404	package org.seasar.akabana.yui.framework.core
17			{
18	e1arkw	1316	CONFIG::FP10{
19			import __AS3__.vec.Vector;
20			}
21
22			CONFIG::UNCAUGHT_ERROR_GLOBAL{
23			import flash.events.UncaughtErrorEvent;
24			}
25
26	e1arkw	404	import flash.events.Event;
27	e1arkw	1475	import flash.errors.IllegalOperationError;
28	e1arkw	863	import flash.system.Capabilities;
29	e1arkw	1316	import flash.display.DisplayObjectContainer;
30			import flash.display.DisplayObject;
31	e1arkw	1477	import flash.utils.Dictionary;
32	e1arkw	1316
33	e1arkw	404	import mx.core.UIComponent;
34			import mx.events.FlexEvent;
35	e1arkw	716	import mx.managers.ISystemManager;
36	e1arkw	1316	import mx.managers.SystemManager;
37	e1arkw	1475	import mx.managers.CursorManager;
38			import mx.managers.PopUpManager;
39			import mx.managers.DragManager;
40			import mx.styles.IStyleManager2;
41			import mx.styles.CSSStyleDeclaration;
42	e1arkw	1316
43	e1arkw	760	import org.seasar.akabana.yui.core.Environment;
44			import org.seasar.akabana.yui.core.yui_internal;
45	e1arkw	1316
46	e1arkw	955	import org.seasar.akabana.yui.framework.YuiFrameworkGlobals;
47	e1arkw	828	import org.seasar.akabana.yui.framework.core.event.FrameworkEvent;
48	e1arkw	404	import org.seasar.akabana.yui.framework.customizer.IComponentCustomizer;
49	e1arkw	1264	import org.seasar.akabana.yui.framework.customizer.IViewCustomizer;
50			import org.seasar.akabana.yui.framework.customizer.IElementCustomizer;
51	e1arkw	683	import org.seasar.akabana.yui.framework.error.YuiFrameworkContainerError;
52	e1arkw	1264	import org.seasar.akabana.yui.framework.util.UIComponentUtil;
53	e1arkw	1316	import org.seasar.akabana.yui.framework.util.StyleManagerUtil;
54	e1arkw	1264	import org.seasar.akabana.yui.framework.core.event.RuntimeErrorEvent;
55	e1arkw	1431	import org.seasar.akabana.yui.framework.logging.debug;
56	e1arkw	1475	import org.seasar.akabana.yui.framework.logging.dump;
57	e1arkw	1431	import org.seasar.akabana.yui.framework.logging.Logging;
58	e1arkw	1316
59			use namespace yui_internal;
60
61	e1arkw	1034	[ExcludeClass]
62	e1arkw	903	public final class YuiFrameworkContainer extends YuiFrameworkContainerBase
63	e1arkw	1316	{
64			{
65			CursorManager;
66			PopUpManager;
67			DragManager;
68	e1arkw	1303	}
69
70	e1arkw	1468	private static var _container:IYuiFrameworkContainer;
71	e1arkw	1316
72	e1arkw	903	public static function get yuicontainer():IYuiFrameworkContainer{
73	e1arkw	834	return _container;
74	e1arkw	683	}
75	e1arkw	1316
76	e1arkw	560	public function YuiFrameworkContainer(){
77	e1arkw	834	super();
78			if( _container == null ){
79			_container = this;
80			} else {
81			throw new YuiFrameworkContainerError("container is already created.");
82	e1arkw	1316	}
83	e1arkw	404	}
84	e1arkw	1316
85			public function addExternalSystemManager(sm:ISystemManager ):void{
86			addRootDisplayObject(sm as DisplayObject);
87	e1arkw	903	}
88	e1arkw	1264
89	e1arkw	1316	public function removeExternalSystemManager(sm:ISystemManager ):void{
90			removeRootDisplayObject(sm as DisplayObject);
91			}
92
93			public override function customizeView( container:DisplayObjectContainer ):void{
94			var view:UIComponent = container as UIComponent;
95	e1arkw	1336	if( !view.initialized ){
96			CONFIG::DEBUG {
97	e1arkw	1431	debug(this,"customizeView:"+view+" is not initialize.");
98	e1arkw	1336	}
99	e1arkw	1316	return;
100			}
101	e1arkw	1264	CONFIG::DEBUG{
102	e1arkw	1431	debug(this,"customizeView:"+view+",owner:"+view.owner);
103	e1arkw	1264	}
104			var viewcustomizer_:IViewCustomizer;
105	e1arkw	1206	for each( var customizer_:IElementCustomizer in _customizers ){
106	e1arkw	1264	viewcustomizer_ = customizer_ as IViewCustomizer;
107			if( viewcustomizer_ != null ){
108	e1arkw	1316	viewcustomizer_.customizeView( view );
109	e1arkw	1264	}
110	e1arkw	903	}
111			}
112	e1arkw	1316
113			public override function uncustomizeView( container:DisplayObjectContainer ):void{
114			var view:UIComponent = container as UIComponent;
115			if( !view.initialized ){
116	e1arkw	1336	CONFIG::DEBUG {
117	e1arkw	1431	debug(this,"customizeView:"+view+" is not initialize.");
118	e1arkw	1336	}
119	e1arkw	1316	return;
120			}
121			CONFIG::DEBUG{
122	e1arkw	1431	debug(this,"uncustomizeView:"+view+",owner:"+view.owner);
123	e1arkw	1316	}
124	e1arkw	903	var numCustomizers:int = customizers.length;
125	e1arkw	1264	var viewcustomizer_:IViewCustomizer;
126	e1arkw	903	for( var i:int = numCustomizers-1; i >= 0; i-- ){
127	e1arkw	1213	viewcustomizer_ = customizers[i] as IViewCustomizer;
128	e1arkw	1264	if( viewcustomizer_ != null ){
129	e1arkw	1316	viewcustomizer_.uncustomizeView( view );
130	e1arkw	1264	}
131	e1arkw	903	}
132			}
133	e1arkw	1264
134	e1arkw	1316	public override function customizeComponent( container:DisplayObjectContainer, child:DisplayObject ):void{
135			var view:UIComponent = container as UIComponent;
136			var component:UIComponent = child as UIComponent;
137			if( !view.initialized \|\| !component.initialized){
138	e1arkw	1336	CONFIG::DEBUG{
139	e1arkw	1431	debug(this,"customizeComponent:"+view+" is not initialize.");
140	e1arkw	1336	}
141	e1arkw	1316	return;
142			}
143			CONFIG::DEBUG{
144	e1arkw	1431	debug(this,"customizeComponent:start, "+child+",owner:"+container);
145	e1arkw	1316	}
146	e1arkw	1264	var componentcustomizer_:IComponentCustomizer;
147			for each( var customizer_:IElementCustomizer in _customizers ){
148			componentcustomizer_ = customizer_ as IComponentCustomizer;
149			if( componentcustomizer_ != null ){
150	e1arkw	1316	componentcustomizer_.customizeComponent( view, component );
151	e1arkw	1264	}
152			}
153	e1arkw	1346	CONFIG::DEBUG{
154	e1arkw	1431	debug(this,"customizeComponent:end, "+child+",owner:"+container);
155	e1arkw	1346	}
156	e1arkw	1264	}
157
158	e1arkw	1316	public override function uncustomizeComponent( container:DisplayObjectContainer, child:DisplayObject ):void{
159			var view:UIComponent = container as UIComponent;
160			var component:UIComponent = child as UIComponent;
161	e1arkw	1336	if( !view.initialized ){
162			CONFIG::DEBUG{
163	e1arkw	1431	debug(this,"uncustomizeComponent:"+view+" is not initialize.");
164	e1arkw	1336	}
165	e1arkw	1316	return;
166			}
167			CONFIG::DEBUG{
168	e1arkw	1431	debug(this,"uncustomizeComponent:start, "+child+",owner:"+container);
169	e1arkw	1316	}
170	e1arkw	1264	var numCustomizers:int = customizers.length;
171			var componentcustomizer_:IComponentCustomizer;
172			for( var i:int = numCustomizers-1; i >= 0; i-- ){
173			componentcustomizer_ = customizers[i] as IComponentCustomizer;
174			if( componentcustomizer_ != null ){
175	e1arkw	1316	componentcustomizer_.uncustomizeComponent( view, component );
176	e1arkw	1264	}
177			}
178	e1arkw	1346	CONFIG::DEBUG{
179	e1arkw	1431	debug(this,"uncustomizeComponent:end, "+child+",owner:"+container);
180	e1arkw	1346	}
181	e1arkw	1316	}
182
183	e1arkw	1125	private function applicationInitCompleteHandler( event:Event ):void{
184	e1arkw	1475	Logging.initialize();
185	e1arkw	1316	CONFIG::DEBUG_EVENT{
186	e1arkw	1475	dump(this,event);
187	e1arkw	1316	}
188	e1arkw	1125	}
189	e1arkw	1316
190	e1arkw	1125	private function applicationPreloaderDoneHandler( event:Event ):void{
191	e1arkw	1316	CONFIG::DEBUG_EVENT{
192	e1arkw	1475	dump(this,event);
193	e1arkw	903	}
194	e1arkw	1477	if( event.currentTarget is ISystemManager ){
195			var sm:ISystemManager = event.currentTarget as ISystemManager;
196			super.yui_internal::systemManagerMonitoringStart(sm as DisplayObject);
197			} else {
198			throw new IllegalOperationError("Illegal SystemManager"+event.currentTarget);
199			}
200	e1arkw	1316	YuiFrameworkGlobals.initNamingConvention();
201			CONFIG::DEBUG{
202	e1arkw	1431	debug(this,getMessage("ApplicationConventions",YuiFrameworkGlobals.public::namingConvention.conventions.toString()));
203	e1arkw	1316	}
204	e1arkw	903	}
205	e1arkw	1316
206			private function applicationCompleteHandler( event:FlexEvent ):void{
207			CONFIG::DEBUG_EVENT{
208	e1arkw	1475	dump(this,event);
209	e1arkw	1264	}
210	e1arkw	1316	applicationMonitoringStop(event.currentTarget as DisplayObject);
211	e1arkw	903	}
212	e1arkw	1303
213	e1arkw	1316	private function creationCompleteHandler(event:FlexEvent):void{
214			CONFIG::DEBUG_EVENT{
215	e1arkw	1475	dump(this,event);
216	e1arkw	1316	}
217			doAssembleComponent(event.target as DisplayObject);
218	e1arkw	1303	}
219
220	e1arkw	1316	protected override function doRegisterComponent( target:DisplayObject ):void{
221			var component:UIComponent = target as UIComponent;
222			super.doRegisterComponent(component);
223	e1arkw	1303	}
224
225	e1arkw	1316	protected override function doUnregisterComponent(target:DisplayObject):void{
226			var component:UIComponent = target as UIComponent;
227			if( isView(component)){
228			super.doUnregisterComponent(component);
229			} else if(isComponent(component)){
230			var document:UIComponent = component.document as UIComponent;
231			if( document != null && document.initialized && isView(document)){
232			processDisassembleViewChild(document,component);
233	e1arkw	472	}
234	e1arkw	404	}
235	e1arkw	424	}
236	e1arkw	1264
237	e1arkw	1316	protected override function doAssembleComponent( target:DisplayObject ):void{
238			var component:UIComponent = target as UIComponent;
239			if( component == null \|\| !component.initialized ){
240			return;
241			}
242	e1arkw	1206	if( isView(component)){
243	e1arkw	1316	processAssembleView(component);
244	e1arkw	1240	} else if(isComponent(component)){
245	e1arkw	1264	var document:UIComponent = component.document as UIComponent;
246			if( document != null && document.initialized && isView(document)){
247	e1arkw	1316	processAssembleViewChild(document,component);
248	e1arkw	1264	}
249			}
250	e1arkw	842	}
251	e1arkw	1316
252			protected override function processApplicationStart():void{
253	e1arkw	1373	const app:UIComponent = YuiFrameworkGlobals.public::frameworkBridge.application as UIComponent;
254	e1arkw	1477	const rootView:DisplayObjectContainer = YuiFrameworkGlobals.public::frameworkBridge.rootView as DisplayObjectContainer;
255	e1arkw	1316	app.setVisible(true,true);
256	e1arkw	1373	super.processApplicationStart();
257	e1arkw	1477
258			var allView:Dictionary = ViewComponentRepository.allView;
259			var fevent:FrameworkEvent;
260			for each (var view:UIComponent in allView)
261			{
262			if( view === rootView ){
263			continue;
264			}
265			if( view.hasEventListener(FrameworkEvent.APPLICATION_START)){
266			fevent = new FrameworkEvent(FrameworkEvent.APPLICATION_START);
267			view.dispatchEvent( fevent );
268			}
269			}
270	e1arkw	1303	}
271
272	e1arkw	1316	protected override function getDefaultCustomizerClasses():Array{
273			const styleManager:IStyleManager2 = StyleManagerUtil.getStyleManager();
274			const customizersDef:CSSStyleDeclaration = styleManager.getStyleDeclaration(".customizers");
275			const defaultFactory:Function = customizersDef.defaultFactory;
276
277			const result:Array = [];
278			const keys:Array = [];
279
280			var customizers:Object = {};
281			if (defaultFactory != null)
282			{
283			defaultFactory.prototype = {};
284			customizers = new defaultFactory();
285	e1arkw	1264	}
286	e1arkw	1316
287			var customizer:Class;
288			for( var key:String in customizers ){
289			keys.push(key);
290	e1arkw	424	}
291	e1arkw	1316	keys.sort();
292			for( var i:int = 0; i < keys.length; i++ ){
293			customizer = customizers[keys[i]] as Class;
294			result.push(customizer);
295			}
296			CONFIG::DEBUG{
297	e1arkw	1431	debug(this,"default customizers is "+result);
298	e1arkw	1316	}
299			return result;
300	e1arkw	404	}
301	e1arkw	1409
302	e1arkw	1317	yui_internal override function applicationInitialize():void{
303	e1arkw	1316	if( _customizers == null ){
304			_customizers = getDefaultCustomizers();
305			}
306			CONFIG::DEBUG{
307	e1arkw	1431	debug(this,getMessage("ViewComponentAssembleStart"));
308	e1arkw	1316	}
309
310	e1arkw	1445	var allView:Dictionary = ViewComponentRepository.allView;
311	e1arkw	1316	var view:UIComponent;
312	e1arkw	1445	for ( var viewName:String in allView ){
313	e1arkw	1316	CONFIG::DEBUG{
314	e1arkw	1431	debug(this,getMessage("ViewComponentAssembleing",viewName));
315	e1arkw	404	}
316	e1arkw	1316	view = ViewComponentRepository.getComponent(viewName) as UIComponent;
317			if( view != null && view.initialized ){
318			processAssembleView(view);
319			}
320			CONFIG::DEBUG{
321	e1arkw	1431	debug(this,getMessage("ViewComponentAssembled",viewName));
322	e1arkw	1316	}
323	e1arkw	404	}
324	e1arkw	1316
325			CONFIG::DEBUG{
326	e1arkw	1431	debug(this,getMessage("ViewComponentAssembleEnd"));
327	e1arkw	468	}
328	e1arkw	1316	_isApplicationStarted = true;
329			callLater( processApplicationStart );
330	e1arkw	432	}
331	e1arkw	1264
332	e1arkw	1316	yui_internal override function isView(component:DisplayObject):Boolean{
333			if( component == null \|\| !(component is UIComponent)){
334			return false;
335	e1arkw	1264	}
336	e1arkw	1316	if( YuiFrameworkGlobals.public::frameworkBridge.isContainer(component)){
337			return YuiFrameworkGlobals.public::namingConvention.isViewClassName( getCanonicalName(component) );
338			} else {
339			return false;
340	e1arkw	404	}
341	e1arkw	468	}
342	e1arkw	1264
343	e1arkw	1316	yui_internal override function isComponent( target:DisplayObject ):Boolean{
344			var component:UIComponent = target as UIComponent;
345			if( component == null \|\| component.id == null \|\| !(component is UIComponent)){
346			return false;
347	e1arkw	1264	}
348	e1arkw	1316	return YuiFrameworkGlobals.public::frameworkBridge.isComponent(component);
349	e1arkw	1264	}
350	e1arkw	1316
351	e1arkw	1317	yui_internal override function applicationMonitoringStart(root:DisplayObject):void{
352			root.addEventListener(
353			FlexEvent.CREATION_COMPLETE,
354			creationCompleteHandler,
355			true,
356			int.MAX_VALUE
357			);
358			super.yui_internal::applicationMonitoringStart(root);
359			}
360
361	e1arkw	1316	yui_internal override function applicationMonitoringStop(root:DisplayObject):void{
362			root.removeEventListener(
363			FlexEvent.APPLICATION_COMPLETE,
364			applicationCompleteHandler,
365			false
366			);
367
368			root.removeEventListener(
369			FlexEvent.INIT_COMPLETE,
370			applicationInitCompleteHandler,
371			true
372			);
373
374			root.removeEventListener(
375			FlexEvent.PRELOADER_DONE,
376			applicationPreloaderDoneHandler,
377			true
378			);
379			super.applicationMonitoringStop(root);
380	e1arkw	842	}
381	e1arkw	1316
382			yui_internal override function systemManagerMonitoringStart( root:DisplayObject ):void{
383			root.addEventListener(
384			FlexEvent.INIT_COMPLETE,
385			applicationInitCompleteHandler,
386			true,
387			int.MAX_VALUE
388			);
389
390			root.addEventListener(
391			FlexEvent.PRELOADER_DONE,
392			applicationPreloaderDoneHandler,
393			true,
394			int.MAX_VALUE
395			);
396
397			root.addEventListener(
398			FlexEvent.APPLICATION_COMPLETE,
399			applicationCompleteHandler,
400			false,
401			int.MAX_VALUE
402			);
403			}
404
405			yui_internal override function systemManagerMonitoringStop(root:DisplayObject):void{
406			const application_:DisplayObjectContainer = YuiFrameworkGlobals.public::frameworkBridge.application;
407			if( application_ != null ){
408			root.removeEventListener(
409			FlexEvent.CREATION_COMPLETE,
410			creationCompleteHandler,
411			true
412			);
413	e1arkw	1071	}
414	e1arkw	1316	super.yui_internal::systemManagerMonitoringStop(root);
415	e1arkw	1071	}
416	e1arkw	404	}
417			}