mdimanager.as

来自「flex的一些小例子」· AS 代码 · 共 1,077 行 · 第 1/3 页

					this.tile(false, this.tilePadding);
				break;
				
				case(CONTEXT_MENU_LABEL_TILE_FILL):
					this.tile(true, this.tilePadding);
				break;
				
				case(CONTEXT_MENU_LABEL_CASCADE):
					this.cascade();
				break;
				
				case(CONTEXT_MENU_LABEL_SHOW_ALL):
					this.showAllWindows();
				break;
			}
		}
		
		private function windowEventProxy(event:Event):void
		{
			if(event is MDIWindowEvent && !event.isDefaultPrevented())
			{
				var winEvent:MDIWindowEvent = event as MDIWindowEvent;
				var mgrEvent:MDIManagerEvent = new MDIManagerEvent(windowToManagerEventMap[winEvent.type], winEvent.window, this);
				
				switch(winEvent.type)
				{
					case MDIWindowEvent.MINIMIZE:
						
						mgrEvent.window.saveStyle();
						
						var maxTiles:int = Math.floor(this.container.width / (this.tileMinimizeWidth + this.tilePadding));
						var xPos:Number = getLeftOffsetPosition(this.tiledWindows.length, maxTiles, this.tileMinimizeWidth, this.minTilePadding);
						var yPos:Number = this.container.height - getBottomTilePosition(this.tiledWindows.length, maxTiles, mgrEvent.window.minimizeHeight, this.minTilePadding);
						var minimizePoint:Point = new Point(xPos, yPos);
						
						mgrEvent.effect = this.effects.getWindowMinimizeEffect(mgrEvent.window, this, minimizePoint);
					break;
					
					case MDIWindowEvent.RESTORE:
						mgrEvent.window.restoreStyle();
						mgrEvent.effect = this.effects.getWindowRestoreEffect(winEvent.window, this, winEvent.window.savedWindowRect);
					break;
					
					case MDIWindowEvent.MAXIMIZE:
						mgrEvent.window.restoreStyle();
						mgrEvent.effect = this.effects.getWindowMaximizeEffect(winEvent.window, this);
					break;
					
					case MDIWindowEvent.CLOSE:
						mgrEvent.effect = this.effects.getWindowCloseEffect(mgrEvent.window, this);
					break;
					
					case MDIWindowEvent.FOCUS_START:
						mgrEvent.effect = this.effects.getWindowFocusStartEffect(winEvent.window, this);
					break;
					
					case MDIWindowEvent.FOCUS_END:
						mgrEvent.effect = this.effects.getWindowFocusEndEffect(winEvent.window, this);
					break;
		
					case MDIWindowEvent.DRAG_START:
						mgrEvent.effect = this.effects.getWindowDragStartEffect(winEvent.window, this);
					break;
		
					case MDIWindowEvent.DRAG:
						mgrEvent.effect = this.effects.getWindowDragEffect(winEvent.window, this);
					break;
		
					case MDIWindowEvent.DRAG_END:
						mgrEvent.effect = this.effects.getWindowDragEndEffect(winEvent.window, this);
					break;
					
					case MDIWindowEvent.RESIZE_START:
						mgrEvent.effect = this.effects.getWindowResizeStartEffect(winEvent.window, this);
					break;
					
					case MDIWindowEvent.RESIZE:
						mgrEvent.effect = this.effects.getWindowResizeEffect(winEvent.window, this);
					break;
					
					case MDIWindowEvent.RESIZE_END:
						mgrEvent.effect = this.effects.getWindowResizeEndEffect(winEvent.window, this);
					break;
				}
				
				dispatchEvent(mgrEvent);
			}			
		}
		
		public function executeDefaultBehavior(event:Event):void
		{
			if(event is MDIManagerEvent && !event.isDefaultPrevented())
			{
				var mgrEvent:MDIManagerEvent = event as MDIManagerEvent;
				
				switch(mgrEvent.type)
				{					
					case MDIManagerEvent.WINDOW_ADD:
						// get the effect here because this doesn't pass thru windowEventProxy()
						mgrEvent.effect = this.effects.getWindowAddEffect(mgrEvent.window, this);
						mgrEvent.effect.play();
					break;
					
					case MDIManagerEvent.WINDOW_MINIMIZE:						
						mgrEvent.effect.addEventListener(EffectEvent.EFFECT_END, onMinimizeEffectEnd);
						mgrEvent.effect.play();
					break;
					
					case MDIManagerEvent.WINDOW_RESTORE:
						removeTileInstance(mgrEvent.window);
						mgrEvent.effect.play();
					break;
					
					case MDIManagerEvent.WINDOW_MAXIMIZE:
						removeTileInstance(mgrEvent.window);
						maximizeWindow(mgrEvent.window);
					break;
					
					case MDIManagerEvent.WINDOW_CLOSE:
						removeTileInstance(mgrEvent.window);
						mgrEvent.effect.addEventListener(EffectEvent.EFFECT_END, onCloseEffectEnd);
						mgrEvent.effect.play();
					break;
					
					case MDIManagerEvent.WINDOW_FOCUS_START:
						mgrEvent.window.hasFocus = true;
						mgrEvent.window.validateNow();
						container.setChildIndex(mgrEvent.window, container.numChildren - 1);
						mgrEvent.effect.play();
					break;
					
					case MDIManagerEvent.WINDOW_FOCUS_END:
						mgrEvent.window.hasFocus = false;
						mgrEvent.window.validateNow();
						mgrEvent.effect.play();
					break;
		
					case MDIManagerEvent.WINDOW_DRAG_START:
						mgrEvent.effect.play();
					break;
		
					case MDIManagerEvent.WINDOW_DRAG:
						mgrEvent.effect.play();
					break;
		
					case MDIManagerEvent.WINDOW_DRAG_END:
						mgrEvent.effect.play();
					break;
					
					case MDIManagerEvent.WINDOW_RESIZE_START:
						mgrEvent.effect.play();
					break;
					
					case MDIManagerEvent.WINDOW_RESIZE:
						mgrEvent.effect.play();
					break;
					
					case MDIManagerEvent.WINDOW_RESIZE_END:
						mgrEvent.effect.play();
					break;
					
					case MDIManagerEvent.CASCADE:
						// get the effect here because this doesn't pass thru windowEventProxy()
						mgrEvent.effect = this.effects.getCascadeEffect(mgrEvent.effectItems, this);
						mgrEvent.effect.play();
					break;
					
					case MDIManagerEvent.TILE:
						// get the effect here because this doesn't pass thru windowEventProxy()
						mgrEvent.effect = this.effects.getTileEffect(mgrEvent.effectItems, this);
						mgrEvent.effect.play();
					break;
				}
			}			
		}
		
		private function onMinimizeEffectEnd(event:EffectEvent):void
		{
			// if this was a composite effect (almost definitely is), we make sure a target was defined on it
			// since that is optional, we look in its first child if we don't find one
			var targetWindow:MDIWindow = event.effectInstance.target as MDIWindow;
			
			if(targetWindow == null && event.effectInstance is CompositeEffectInstance)
			{
				var compEffect:CompositeEffect = event.effectInstance.effect as CompositeEffect;
				targetWindow = Effect(compEffect.children[0]).target as MDIWindow;
			}			
			
			tiledWindows.addItem(targetWindow);
			reTileWindows();
		}
		
		private function onCloseEffectEnd(event:EffectEvent):void
		{
			remove(event.effectInstance.target as MDIWindow);
		}
				
		
		/**
		 * Handles resizing of container to reposition elements
		 * 
		 *  @param event The ResizeEvent object from event dispatch
		 * 
		 * */
		private function containerResizeHandler(event:ResizeEvent):void
		{	
			//repositions any minimized tiled windows to bottom left in their rows
			reTileWindows();
		}
		
		
		/**
		 * Gets the left placement of a tiled window
		 * 
		 *  @param tileIndex The index value of the current tile instance we're placing
		 * 
		 *  @param maxTiles The maximum number of tiles that can be placed horizontally across the container given the minimimum width of each tile
		 * 
		 *  @param minWinWidth The width of the window tile when minimized
		 * 
		 *  @param padding The padding accordance to place between minimized tile window instances
		 * 
		 * */
		private function getLeftOffsetPosition(tileIndex:int, maxTiles:int, minWinWidth:Number, padding:Number):Number
		{
			var tileModPos:int = tileIndex % maxTiles;
			if(tileModPos == 0)
				return padding;
			else
				return (tileModPos * minWinWidth) + ((tileModPos + 1) * padding);
		}
		
		
		/**
		 * Gets the bottom placement of a tiled window
		 * 
		 *  @param maxTiles The maximum number of tiles that can be placed horizontally across the container given the minimimum width of each tile
		 * 
		 *  @param minWinHeight The height of the window tile instance when minimized -- probably the height of the titleBar instance of the Panel
		 * 
		 * 	@param padding The padding accordance to place between minimized tile window instances
		 * 
		 * */
		private function getBottomTilePosition(tileIndex:int, maxTiles:int, minWindowHeight:Number, padding:Number):Number
		{
			var numRows:int = Math.floor(tileIndex / maxTiles);
			if(numRows == 0)
				return minWindowHeight + padding;
			else
				return ((numRows + 1) * minWindowHeight) + ((numRows + 1) * padding);
		}
		
		
		/**
		 * Gets the height accordance for tiled windows along bottom to be used in the maximizing of other windows -- leaves space at bottom of maximize height so tiled windows still show
		 * 
		 *  @param maxTiles The maximum number of tiles that can be placed horizontally across the container given the minimimum width of each tile
		 * 
		 *  @param minWinHeight The height of the window tile instance when minimized -- probably the height of the titleBar instance of the Panel
		 * 
		 * 	@param padding The padding accordance to place between minimized tile window instances
		 * 
		 * */
		private function getBottomOffsetHeight(maxTiles:int, minWindowHeight:Number, padding:Number):Number
		{
			var numRows:int = Math.ceil(this.tiledWindows.length / maxTiles);
			//if we have some rows get their combined heights... if not, return 0 so maximized window takes up full height of container
			if(this.tiledWindows.length != 0)
				return ((numRows) * minWindowHeight) + ((numRows + 1) * padding);
			else
				return 0;
		}
		
		/**
		 * Retiles the remaining minimized tile instances if one of them gets restored or maximized
		 * 
		 * */
		private function reTileWindows():void
		{
			var maxTiles:int = Math.floor(this.container.width / (this.tileMinimizeWidth + this.tilePadding));
			
			//we've just removed/added a row from the tiles, so we tell any maximized windows to change their height
			
			if(this.tiledWindows.length % maxTiles == 0 || (this.tiledWindows.length - 1) % maxTiles == 0)
			{
				var openWins:Array = getOpenWindowList();
				for(var winIndex:int = 0; winIndex < openWins.length; winIndex++)
				{
					if(MDIWindow(openWins[winIndex]).maximized)
						maximizeWindow(MDIWindow(openWins[winIndex]));
				}
			}
			
			for(var i:int = 0; i < tiledWindows.length; i++)
			{
				var currentWindow:MDIWindow = tiledWindows.getItemAt(i) as MDIWindow;
				var xPos:Number = getLeftOffsetPosition(i, maxTiles, this.tileMinimizeWidth, this.minTilePadding);
				var yPos:Number = this.container.height - getBottomTilePosition(i, maxTiles, currentWindow.minimizeHeight, this.minTilePadding);
				var movePoint:Point = new Point(xPos, yPos);
				this.effects.reTileMinWindowsEffect(currentWindow, this, movePoint).play();
			}	
		}
		
	
		
		/**
		 * Maximizing of Window
		 * 
		 * @param window MDIWindowinstance to maximize
		 * 
		 **/
		private function maximizeWindow(window:MDIWindow):void
		{
			var maxTiles:int = this.container.width / this.tileMinimizeWidth;
			if(showMinimizedTiles)
			{
				this.effects.getWindowMaximizeEffect(window, this, getBottomOffsetHeight(maxTiles, window.minimizeHeight, this.minTilePadding)).play();
			}
			else
			{
				this.effects.getWindowMaximizeEffect(window, this).play();
			}
		}
		

		
		/**
		 * Removes the closed window from the ArrayCollection of tiled windows
		 * 
		 *  @param event MDIWindowEvent instance containing even type and window instance that is being handled
		 * 
		 * */
		private function removeTileInstance(window:MDIWindow):void
		{
			for(var i:int = 0; i < tiledWindows.length; i++)
			{
				if(tiledWindows.getItemAt(i) == window)
				{
					this.tiledWindows.removeItemAt(i);
					reTileWindows();
				}
			}
		}


		
		public function addCenter(window:MDIWindow):void
		{
			this.add(window);
			this.center(window);
		}
		
		
		/**
		 * Brings a window to the front of the screen. 
		 * 
		 *  @param win Window to bring to front
		 * */
		public function bringToFront(window:MDIWindow):void