calendardisplay.as

QS我也没用过

				var data:EventData = _eventData[aKey];
				for(var i:int=0;i<data.renderers.length;i++)
				{
					var renderer:UIComponent = data.renderers[i];
					renderer.parent.removeChild(renderer);
					var target:LayoutTarget = _animator.releaseTarget(renderer);
					if(target != null)
						target.animate = false;										
				}
			}
			_eventData = new Dictionary();
		}
		private function removeEventData(data:EventData):void
		{
			for(var i:int=0;i<data.renderers.length;i++)
			{
				var renderer:UIComponent = data.renderers[i];
				renderer.parent.removeChild(renderer);
				var target:LayoutTarget = _animator.releaseTarget(renderer);
				if(target != null)
					target.animate = false;										
			}
		}
		
		private function buildEventData(event:CalendarEvent):EventData
		{
			var data:EventData = _eventData[event] = new EventData();
			data.renderers = [];
			data.event = event;
			validateEventData(data);
			return data;
		}

		private function validateEventData(data:EventData):void
		{
			var event:CalendarEvent = data.event;
			data.range = event.range.intersect(_visibleRange);
			
			var weekSpan:int = _tz.rangeWeekSpan(data.range);
			var parent:UIComponent = (event.allDay)? _allDayEventLayer:_eventLayer;
			var sn:String = getStyle("eventStyleName");
			var rendererCount:Number = data.renderers.length;
			
			if(weekSpan > rendererCount)
			{
				for(var i:int = rendererCount;i<weekSpan;i++)
				{				
					var renderer:CalendarEventRenderer = new CalendarEventRenderer();
					renderer.addEventListener(MouseEvent.MOUSE_DOWN,eventDownHandler);
					data.renderers.push(renderer);
					renderer.data = event;
					renderer.styleName = sn;
					parent.addChild(renderer);
					if(data == _dragEventData)
					{
						renderer.filters = [
							_dragFilter
						]									
					}
				}
			}
			else
			{
				for(var i:int = weekSpan;i<rendererCount;i++)
				{
					renderer = data.renderers[i];
					renderer.parent.removeChild(renderer);
				}
				data.renderers.splice(weekSpan,rendererCount-weekSpan);
			}
		}
		
//----------------------------------------------------------------------------------------------------
// click event handlers
//----------------------------------------------------------------------------------------------------

		private function headerClickHandler(e:MouseEvent):void
		{
			var d:Date = IDataRenderer(e.currentTarget).data as Date;
			if(d == null)
				return;
			var newEvent:CalendarDisplayEvent = new CalendarDisplayEvent(CalendarDisplayEvent.HEADER_CLICK);
			newEvent.dateTime = d;
			dispatchEvent(newEvent);
		}

		private function dayClickHandler(e:MouseEvent):void
		{
			var d:Date = IDataRenderer(e.currentTarget).data as Date;
			if(d == null)
				return;
			var newEvent:CalendarDisplayEvent = new CalendarDisplayEvent(CalendarDisplayEvent.DAY_CLICK);
			newEvent.dateTime = d;
			dispatchEvent(newEvent);
		}

//----------------------------------------------------------------------------------------------------
// event dragging behavior
//----------------------------------------------------------------------------------------------------

		private function eventDownHandler(e:MouseEvent):void
		{
			var tracking:Boolean = false;
			_dragRenderer = UIComponent(e.currentTarget);
			var event:CalendarEvent = CalendarEvent(IDataRenderer(_dragRenderer).data);
			_dragEventData = _eventData[event];			
			_dragDownPt = new Point(mouseX,mouseY);
			
			systemManager.addEventListener(MouseEvent.MOUSE_MOVE,eventOverHandler,true);
			systemManager.addEventListener(MouseEvent.MOUSE_UP,eventUpHandler,true);
		}

		private function eventOverHandler(mdEvent:MouseEvent):void
		{
			if(_dragType == null)
			{
			
				if(Math.abs(_dragDownPt.x - mouseX) <= 2 && Math.abs(_dragDownPt.y - mouseY) <= 2)
					return;						
				initDrag(_dragRenderer,mdEvent);
				return;
			}

			if(_dragType == "grow")
			{				
				dragOver(_dragEventData.event,_dragEventData,_dragOffset);
			}
		}
		
		private function eventUpHandler(e:MouseEvent):void
		{
			systemManager.removeEventListener(MouseEvent.MOUSE_MOVE,eventOverHandler,true);
			systemManager.removeEventListener(MouseEvent.MOUSE_UP,eventUpHandler,true);

			if(_dragType == "grow")
				dragUp(_dragEventData);
			else if (_dragType == null)
			{
				var ce:CalendarDisplayEvent = new CalendarDisplayEvent(CalendarDisplayEvent.ITEM_CLICK);
				ce.event = _dragEventData.event;
				dispatchEvent(ce);
			}
							
			_dragType = null;
			_dragEventData = null;
			_dragDownPt = null;
			_dragRenderer = null;
		}
		
		private function initDrag(renderer:UIComponent,mouseEvent:MouseEvent):void
		{
			var event:CalendarEvent = CalendarEvent(IDataRenderer(renderer).data);
			var data:EventData = _eventData[event];
			var changeDayOnly:Boolean = (_displayMode == "weeks" || _displayMode == "week" || _displayMode == "month" || event.allDay);
			_dragType = (changeDayOnly == false && (renderer.height - renderer.mouseY) < 10)?
							"grow":"move";
			var offset:Point = new Point(0,(_dragType == "grow")? (renderer.mouseY-renderer.height):renderer.mouseY);
			
			
			var newTime:Date = localToDateTime(new Point(mouseX,mouseY));

			var changeDayOnly:Boolean = (_displayMode == "weeks" || _displayMode == "week" || _displayMode == "month" || event.allDay);

			if(changeDayOnly)
				_dragOffset = (_tz.toDays(newTime) - _tz.toDays(event.start))*DateUtils.MILLI_IN_DAY;
			else
				_dragOffset = (_tz.toHours(newTime) - _tz.toHours(event.start))*DateUtils.MILLI_IN_HOUR;
			

			for(var i:int = 0;i<data.renderers.length;i++)
			{
				var r:UIComponent = data.renderers[i];
				r.parent.setChildIndex(r,r.parent.numChildren-1);
			}
			
			_dragEventData = data;
			
			if(_dragType == "move")
			{			
				var ds:DragSource = new DragSource();
				ds.addData(event,"event");
				ds.addData(data,"event.data");
				ds.addData(_dragOffset,"event.dragOffset");
				ds.addData(event.range.clone(),"event.originalRange");				
				var dragImageClass:Class = getStyle("eventDragSkin");
				var icon:IFlexDisplayObject = new dragImageClass();
				DragManager.doDrag(this,ds,mouseEvent, icon,-mouseX,-mouseY,.8);
			}

			for(var i:int = 0;i<data.renderers.length;i++)
			{
				var r:UIComponent = data.renderers[i];
				r.filters = [_dragFilter];						
			}
		}

		private function dragEnterHandler(e:DragEvent):void
		{
	    	DragManager.acceptDragDrop(this);
			e.action = DragManager.LINK;
			DragManager.showFeedback(DragManager.LINK);

			var data:EventData = EventData(e.dragSource.dataForFormat("event.data"));
			var dragOffset:Number = Number(e.dragSource.dataForFormat("event.dragOffset"));
			var event:CalendarEvent = CalendarEvent(e.dragSource.dataForFormat("event"));

			for(var i:int = 0;i<data.renderers.length;i++)
			{
				var r:UIComponent = data.renderers[i];
				r.filters = [_dragFilter];						
			}
			dragOver(event,data,dragOffset);
		}
		
		private function dragOver(event:CalendarEvent,data:EventData,dragOffset:Number):void
		{
			var changeDayOnly:Boolean = (_displayMode == "weeks" || _displayMode == "week" || _displayMode == "month" || event.allDay);
			
			var newTime:Date = localToDateTime(new Point(mouseX,mouseY));

			if(_dragType == "move")
				newTime.milliseconds -= dragOffset;
			
			var r:DateRange = event.range;
			if(changeDayOnly)
			{
				newTime.hours = r.start.hours;
				newTime.minutes = r.start.minutes;
				newTime.seconds = r.start.seconds;
				newTime.milliseconds = r.start.milliseconds;					
				r.moveTo(newTime);
			}
			else
			{
				if(_dragType == "grow")
				{
					newTime.setTime(Math.max(newTime.getTime(),r.start.getTime() + DateUtils.MILLI_IN_HOUR/2) - 1);
					r.end = newTime;
				}
				else
					r.moveTo(newTime);
			}
				
			event.range = r;
			data.range = r.intersect(_visibleRange);

			_animator.invalidateLayout();
		}

		private function dragOverHandler(e:DragEvent):void
		{
	    	DragManager.acceptDragDrop(this);
			e.action = DragManager.LINK;
			DragManager.showFeedback(DragManager.LINK);

			var dragOffset:Number = Number(e.dragSource.dataForFormat("event.dragOffset"));
			var event:CalendarEvent = CalendarEvent(e.dragSource.dataForFormat("event"));
			var data:EventData = EventData(e.dragSource.dataForFormat("event.data"));

			dragOver(event,data,dragOffset);
		}

		private function dragExitHandler(e:DragEvent):void
		{
	    	DragManager.acceptDragDrop(this);
			e.action = DragManager.LINK;
			DragManager.showFeedback(DragManager.LINK);

			var event:CalendarEvent = CalendarEvent(e.dragSource.dataForFormat("event"));
			var data:EventData = EventData(e.dragSource.dataForFormat("event.data"));
			var originalRange:DateRange = DateRange(e.dragSource.dataForFormat("event.originalRange"));
			
			dragUp(data);

			event.range = originalRange.clone();
			data.range = originalRange.intersect(_visibleRange);

			_animator.invalidateLayout();
		}

		private function dragUp(data:EventData):void
		{
			_dragEventData = null;
			_removeAllEventData = false;
			for(var i:int = 0;i<data.renderers.length;i++)
			{
				var r:UIComponent = data.renderers[i];
				r.filters = [];						
			}
			invalidateProperties();
		}
		private function dragDropHandler(e:DragEvent):void
		{
			var data:EventData = EventData(e.dragSource.dataForFormat("event.data"));

	    	DragManager.acceptDragDrop(this);
			e.action = DragManager.LINK;
			DragManager.showFeedback(DragManager.LINK);
			
			dragUp(data);

		}
		
//----------------------------------------------------------------------------------------------------
// child initialization callbacks
//----------------------------------------------------------------------------------------------------
		
		private function dayChildCreated(instance:UIComponent,idx:int):void
		{
			instance.styleName = getStyle("dayStyleName");
			_dayLayer.addChild(instance);
			instance.addEventListener(MouseEvent.CLICK,dayClickHandler);
		}
		private function headerChildCreated(instance:UIComponent,idx:int):void
		{
			instance.styleName = getStyle("dayHeaderStyleName");
			_headerLayer.addChild(instance);
			instance.addEventListener(MouseEvent.CLICK,headerClickHandler);
		}
		
		override protected function updateDisplayList(unscaledWidth:Number, unscaledHeight:Number):void
		{
			updateDetails();
			if(_animated)
				_animator.invalidateLayout(true);
			else
			{
				_animator.invalidateLayout();
				_animator.updateLayoutWithoutAnimation();
			}			
		}
		
		override public function styleChanged(styleProp:String):void
		{
			var sn:String;
			var len:Number;
			var i:Number;
			
			if(styleProp == "hourStyleName" || styleProp == null)
			{
				_hourGrid.styleName = getStyle("hourStyleName");
			}
			if(styleProp == "dayStyleName" || styleProp == null)
			{
				sn = getStyle("dayStyleName");
				len = _dayCache.instances.length;
				for(i = 0;i<len;i++)
				{
					_dayCache.instances[i].styleName = sn;
				}
			}
			if(styleProp == "dayHeaderStyleName" || styleProp == null)
			{
				sn = getStyle("dayHeaderStyleName");
				len = _headerCache.instances.length;
				for(i = 0;i<len;i++)
				{
					_headerCache.instances[i].styleName = sn;
				}
			}
			if(styleProp == "eventStyleName" || styleProp == null)
			{
				sn = getStyle("eventStyleName");
				for (var key:* in _eventData)
				{
					var data:EventData = _eventData[key];
					len = data.renderers.length;
					for(i=0;i<len;i++)
					{
						data.renderers[i].styleName = sn;
					}
				}
			}
		}
	}
}


import qs.calendar.CalendarEvent;
import mx.core.UIComponent;
import qs.utils.DateRange;
	

class EventData
{
	public var event:CalendarEvent;
	public var renderers:Array;
	public var range:DateRange;
	public var lane:int;
}