calendardisplay.as

QS我也没用过

						reservations.release(anEvent);
					}
				}

				startOfDay.date = startOfDay.date+1;
				endOfDay.date = endOfDay.date+1;														
			}
		}

		private function layoutSingleDay(events:Array, cellLeft:Number,cellTop:Number,_cellWidth:Number,_cellHeight:Number):void
		{
			var openEvents:Array = [];
			var data:EventData;
			var reservations:ReservationAgent = new ReservationAgent();
			var pendingEvents:Array = [];
			var maxOpenEvents:int = 0;
			var renderer:UIComponent;
			var i:int;
			var target:LayoutTarget;
			
			while(1)
			{
				if(events.length == 0 && openEvents.length == 0)
					break;
				
				while(events.length > 0 && (openEvents.length == 0 || events[0].start.getTime() <= openEvents[0].end.getTime()))
				{
					var nextEvent:CalendarEvent = events.shift();
					data = _eventData[nextEvent];
					data.lane = reservations.reserve(nextEvent);

					for(i=0;i<openEvents.length;i++)
					{
						if(nextEvent.end.getTime() < openEvents[i].end.getTime())
						{
							openEvents.splice(i,0,nextEvent);
							nextEvent = null;
							break;
						}
					}
					if(nextEvent != null)
						openEvents.push(nextEvent);
					maxOpenEvents = Math.max(maxOpenEvents,openEvents.length);
				}

				while(openEvents.length > 0 && (events.length == 0 || openEvents[0].end.getTime() < events[0].start.getTime()))
				{
					var closingEvent:CalendarEvent = openEvents.shift();
					pendingEvents.push(closingEvent);
					reservations.release(closingEvent);

					if(openEvents.length == 0)
					{
						var laneWidth:Number = _cellWidth/maxOpenEvents;
						for(i=0;i<pendingEvents.length;i++)
						{
							data = _eventData[pendingEvents[i]];
							renderer = data.renderers[0];
							ICalendarEventRenderer(renderer).displayMode = "box";
							target = layoutSingleEvent(data,renderer,
								cellLeft + EVENT_INSET + data.lane * laneWidth,
								-_scroller.scrollPosition + _hourHeight * ((data.range.start.getTime() - _tz.startOfDay(data.range.start).getTime()) / DateUtils.MILLI_IN_HOUR) + cellTop,
								laneWidth - 2*EVENT_INSET,
								_hourHeight * (data.range.end.getTime() - data.range.start.getTime()) / DateUtils.MILLI_IN_HOUR
							);
							target.animate = true;
							renderer.visible = true;					
						}
						maxOpenEvents = 0;
						pendingEvents = [];
					}
				}

			}

		}


		private function layoutMonth():void
		{
			var startOfDay:Date = dateForIndex(0);
			var endOfDay:Date = dateForIndex(1);
			var openEvents:Dictionary = new Dictionary();
			var reservations:ReservationAgent = new ReservationAgent();
			var events:Array = _visibleEvents.concat();
			var renderTop:int;
			var data:EventData;
			var renderer:UIComponent;
			var target:LayoutTarget;
			var rPos:int;
			var cPos:int;
			var i:int;
			var openingEvents:Array;
			var aboveBottom:Boolean;
			
			layoutCells();
			_eventLayer.mask = null; 
			_eventMask.visible = false;

			target = _animator.releaseTarget(_scroller);
			if(target != null)
				target.animate = false;
			
			target = _animator.releaseTarget(_hourGrid);
			if(target != null)
				target.animate = false;
			
			target = _animator.releaseTarget(_allDayEventBorder);
			if(target != null)
				target.animate = false;

			for(cPos = 0;cPos<_columnLength;cPos++)
			{
				for(rPos=0;rPos < _rowLength;rPos++)
				{
					var index:int = rPos + cPos*_rowLength;
					var header:UIComponent = _headerCache.instances[index];

					for(var anEvent:* in openEvents)
					{
						if(anEvent.event.end < startOfDay)
						{
							delete openEvents[anEvent];
							reservations.release(anEvent);
						}
					}
					

					if(events.length > 0)
					{
						openingEvents = [];
							
						while(events.length > 0 && events[0].start.getTime() < endOfDay.getTime())
						{
							data = _eventData[events.shift()];
							openEvents[data] = true;
							openingEvents.push(data);
						}
						renderTop = header.measuredHeight;
						
						for(i=0;i<openingEvents.length;i++)
						{
							data = openingEvents[i];
							var reservation:int = reservations.reserve(data);
							if(_tz.rangeWeekSpan(data.range) == 1)
							{
								renderer = data.renderers[0];
								ICalendarEventRenderer(renderer).displayMode = "line";
								target = layoutSingleEvent(data,renderer,
									_border.left + rPos * _cellWidth + EVENT_INSET,
									_border.top + cPos * _cellHeight + renderTop + renderer.measuredHeight * reservation,
									_cellWidth * Math.max(1,_tz.rangeDaySpan(data.range)) - 2*EVENT_INSET,
									renderer.measuredHeight
								);
								aboveBottom = (target.y + target.unscaledHeight <= _border.top + (cPos+1) * _cellHeight)
								target.animate = aboveBottom;
								renderer.visible = aboveBottom;
							}
							else
							{
								var weekSpan:int = _tz.rangeWeekSpan(data.range);
								var daysRemaining:int = _tz.rangeDaySpan(data.range);
								var rendererStart:int = rPos;
								for(var j:int = 0;j<weekSpan;j++)
								{
									renderer = data.renderers[j];
									ICalendarEventRenderer(renderer).displayMode = "line";
									var currentDaySpan:int = Math.min(daysRemaining, 7 - rendererStart);
									target = layoutSingleEvent(data,renderer,
										_border.left + rendererStart * _cellWidth + EVENT_INSET,
										_border.top + (cPos + j) * _cellHeight + renderTop + renderer.measuredHeight * reservation,
										_cellWidth * currentDaySpan - 2*EVENT_INSET,
										renderer.measuredHeight
									);
									aboveBottom = (target.y + target.unscaledHeight <= _border.top + (cPos+j+1) * _cellHeight)
									target.animate = aboveBottom;
									renderer.visible = aboveBottom;

									daysRemaining -= currentDaySpan;
									rendererStart  = 0;
								}
							}
							
						}
					}
					
					startOfDay.date = startOfDay.date+1;
					endOfDay.date = endOfDay.date+1;														
				}
			}
		}

		
		private function layoutSingleEvent(eventData:EventData, renderer:UIComponent,x:Number,y:Number,w:Number,h:Number):LayoutTarget
		{
			var target:LayoutTarget = _animator.targetFor(renderer);
			target.initializeFunction = setupNewEventTarget;
			target.alpha = 1;
						
			if(_dragEventData == eventData)
			{
				
				if (_dragType != "grow")
				{
					if(_displayMode == "day" || _displayMode == "days")
					{
						if(eventData.event.allDay)
						{
							target.x = x;							
							target.y = y;
						}
						else
						{
							var availableWidth:Number = unscaledWidth - _border.left - _border.right;
							target.x = x;							
							target.y = y;
						}
					}
					else
					{
						target.x = x;
						target.y = y;
					}
					target.alpha = .5;
				}
				else
				{
					target.x = x;
					target.y = y;
				}
			}
			else
			{
				target.x = x;
				target.y = y;
			}

			target.unscaledHeight = h;
			target.unscaledWidth = w
			return target;
		}




		
		
//----------------------------------------------------------------------------------------------------
// scrolling
//----------------------------------------------------------------------------------------------------

		private function scrollHandler(event:ScrollEvent):void
		{
			_scrollHour = _scroller.scrollPosition / _hourHeight;
			_animator.invalidateLayout(false);
			_animator.updateLayoutWithoutAnimation();
		}

		private function get lastVisibleHour():Number
		{
			return _scrollHour + Math.floor(_dayAreaHeight / _hourHeight*2)/2;
		}

		private function guaranteeEventsAreVisible(events:Array):void
		{
			
			if(events.length == 0)
				return;
				
			var sortedHours:Array = events.concat();
			sortedHours.sortOn("start",Array.NUMERIC);
			if(sortedHours[0].start.hours < _scrollHour)
			{
				_scrollHour = sortedHours[0].start.hours;
			}
			sortedHours.sortOn("end",Array.NUMERIC | Array.DESCENDING);

			if(sortedHours[0].end.hours + sortedHours[0].end.minutes/60 > lastVisibleHour)
			{
				_scrollHour = lastVisibleHour - sortedHours[0].range.milliSpan / DateUtils.MILLI_IN_HOUR;
			}
		}
		
		private function computeScrollHourToDisplayEvents(events:Array):Number
		{
			if(events.length == 0)
				return 8;
				
			var hoursSortedByStartTime:Array = events.concat();
			hoursSortedByStartTime.sort(function(lhs:CalendarEvent, rhs:CalendarEvent):Number
			{
				var ltime:Number = _tz.timeOnly(lhs.start);
				var rtime:Number = _tz.timeOnly(rhs.end);
				return (rhs.allDay || ltime < rtime)? -1:
					   (lhs.allDay || ltime > rtime)? 1:
					   					0;
			}
			);
			return hoursSortedByStartTime[0].allDay? 8:hoursSortedByStartTime[0].start.hours;
		}
		

//----------------------------------------------------------------------------------------------------
// animation callbacks
//----------------------------------------------------------------------------------------------------

		private function setupNewEventTarget(target:LayoutTarget):void
		{
			if(_dragEventData != null && IDataRenderer(target.item).data == _dragEventData.event)
			{
				target.item.setActualSize(target.unscaledWidth,target.unscaledHeight);
				target.item.x = target.x;
				target.item.y = target.y;
				var m:Matrix = DisplayObject(target.item).transform.matrix;
				m.a = m.d = 1;
				DisplayObject(target.item).transform.matrix = m;
			}
			else
			{
				target.item.setActualSize(target.unscaledWidth,target.unscaledHeight);
				target.item.x = target.x + target.unscaledWidth/2;
				target.item.y = target.y + target.unscaledHeight/2;
				var m:Matrix = DisplayObject(target.item).transform.matrix;
				m.a = m.d = 0;
				DisplayObject(target.item).transform.matrix = m;
			}
		}

		private function setupScrollbar(target:LayoutTarget):void
		{
			target.item.setActualSize(target.unscaledWidth,target.unscaledHeight);
			target.item.x = target.x;
			target.item.y = target.y;
			target.item.alpha = 0;
		}
		private function releaseGrid(target:LayoutTarget):void
		{
			target.alpha = 0;
			target.unscaledHeight = target.item.height;
			target.unscaledWidth  = target.item.width;
			target.x = target.item.x;
			target.y = target.item.y;						
		}
		
		
//----------------------------------------------------------------------------------------------------
// managing event data
//----------------------------------------------------------------------------------------------------

		private function updateEventData():void
		{
			if(false && _removeAllEventData)
			{
				removeAllEventData();
				for(var i:int = 0;i<_visibleEvents.length;i++)
				{
					var event:CalendarEvent = _visibleEvents[i];
					buildEventData(event);
				}
			}
			else
			{
				var oldEventData:Dictionary = _eventData;
				_eventData = new Dictionary();
				
				for(i = 0;i<_visibleEvents.length;i++)
				{
					event = _visibleEvents[i];
					var ed:EventData = oldEventData[event];
					if(ed == null)
					{
						buildEventData(event);
					}
					else
					{
						_eventData[event] = ed;
						validateEventData(ed);
						delete oldEventData[event];
					}
				}
				for(var anEvent:* in oldEventData)
				{
					removeEventData(oldEventData[anEvent]);
				}			
			}
			
		}
		private function removeAllEventData():void
		{
			for(var aKey:* in _eventData)
			{