calendardisplay.as

QS我也没用过

			}

			var ranges:Object = computeRanges(_currentRange,_displayMode);
			

			if(oldVisible.containsRange(ranges._visibleRange))
			{				
				// we're narrowing down
				_animateRemovingDays = true;
				startIndex = indexForDate(ranges._visibleRange.start);
				endIndex = indexForDate(ranges._visibleRange.end) + 1;
				_dayCache.slice(startIndex,endIndex);
				_headerCache.slice(startIndex,endIndex);
				_visibleRange = ranges._visibleRange;
				_computedRange = ranges._computedRange;
				updateDetails();
			}
			else if (ranges._visibleRange.containsRange(oldVisible))
			{
				// we're expanding up
				_animateRemovingDays = false;
				_visibleRange = ranges._visibleRange;
				_computedRange = ranges._computedRange;
				updateDetails();

				var dayCount:int = _tz.rangeDaySpan(_visibleRange);

				startIndex = indexForDate(oldVisible.start);
				_dayCache.unslice(dayCount,startIndex);
				_headerCache.unslice(dayCount,startIndex);
			}
			else
			{
				_animateRemovingDays = false;
				_visibleRange = ranges._visibleRange;
				_computedRange = ranges._computedRange;
				updateDetails();

				dayCount = _tz.rangeDaySpan(_visibleRange);
				_dayCache.count = dayCount;				
				_headerCache.count = dayCount;				
			}			

			
			var tmp:Date = new Date(_visibleRange.start);
			for(var cPos:int = 0;cPos<_columnLength;cPos++)
			{
				for(var rPos:int=0;rPos < _rowLength;rPos++)
				{
					var index:int = rPos + cPos*_rowLength;
					
					var inst:UIComponent = _dayCache.instances[index];
					var header:UIComponent = _headerCache.instances[index];
					if(_computedRange.contains(tmp) == false)//tmp.month != month && _displayMode == "month")
					{
						IDataRenderer(inst).data = null;
						IDataRenderer(header).data = null;
					}
					else
					{
						IDataRenderer(inst).data = new Date(tmp);
						IDataRenderer(header).data = new Date(tmp);
					}
					tmp.date++;					
					
				}
			}			
			
			updateEventData();
			

			
			invalidateDisplayList();
		}

		private function computeRanges(value:DateRange,displayMode:String):Object
		{
			var _visibleRange:DateRange;
			var _computedRange:DateRange;
			
			switch(displayMode)
			{
				case "day":
					_visibleRange = new DateRange(value.start);
					_tz.expandRangeToDays(_visibleRange,true);
					_computedRange = _visibleRange.clone();
					break;
				case "days":
					_visibleRange = value.clone();
					_tz.expandRangeToDays(_visibleRange,true);
					_computedRange = _visibleRange.clone();
					break;
				case "week":
					_visibleRange = new DateRange(value.start);
					_tz.expandRangeToWeeks(_visibleRange);
					_computedRange = _visibleRange.clone();
					break;
				case "weeks":
					_visibleRange = value.clone();
					_tz.expandRangeToDays(_visibleRange,true);
					_computedRange = _visibleRange.clone();
					_tz.expandRangeToWeeks(_visibleRange);
					break;
				case "month":
				default:
					_visibleRange = new DateRange(value.start);
					_tz.expandRangeToMonths(_visibleRange,true);
					_computedRange = _visibleRange.clone();
					_tz.expandRangeToWeeks(_visibleRange);
			}
			
			return {
				_visibleRange: _visibleRange,
				_computedRange: _computedRange				
			};
		}

		private function updateDetails():void
		{

			_border.left = 0;
			_border.right = 0;
			_border.top = 0;
			_border.bottom = 0;

			
			switch(_displayMode)
			{
				case "day":
					_border.left = _hourGrid.gutterWidth;
					_border.right = _scroller.measuredWidth;
					break;
				case "days":
					_border.left = _hourGrid.gutterWidth;
					_border.right = _scroller.measuredWidth;
					break;
				case "week":
				case "weeks":
				case "month":
				default:
					break;					
			}

			_rowLength = Math.min(ROW_LENGTH,_tz.rangeDaySpan(_visibleRange));
			_columnLength = Math.ceil(_tz.rangeDaySpan(_visibleRange)/_rowLength);
			
						 
			_cellWidth = (unscaledWidth - _border.left - _border.right)/_rowLength;
			_cellHeight = (unscaledHeight - _border.top - _border.bottom)/_columnLength;		

			_visibleEvents = _dataProvider.eventsInRange(_visibleRange.start,_visibleRange.end);
			
			_hourHeight = Math.max(MIN_HOUR_HEIGHT,_cellHeight / 24);
		}
		
//----------------------------------------------------------------------------------------------------
// Layout functions
//----------------------------------------------------------------------------------------------------

		private function generateLayout():void
		{								
			if( _displayMode == "day" || _displayMode == "days" )							
			{
				layoutDays();
			}
			else
			{
				layoutMonth();
			}
		}

		private function localToDateTime(pt:Point):Date
		{
			var result:Date = new Date(_visibleRange.start);
			if(_displayMode == "day" || _displayMode == "days")
			{
				var dayIndex:Number = (pt.x - _border.left)/_cellWidth;				
				dayIndex = Math.floor(Math.max(dayIndex,0));

				var hourCount:Number = (pt.y + _scroller.scrollPosition - _allDayAreaHeight)/_hourHeight;
				hourCount = Math.round(hourCount*2)/2;
				hourCount = Math.max(0,Math.min(24,hourCount));
				result.date += dayIndex;
				result.milliseconds = result.seconds = result.minutes = 0;
				result.hours = Math.floor(hourCount);
				result.minutes = (hourCount - result.hours)*60;
				if(result > _visibleRange.end)
				{
					result.fullYear = _visibleRange.end.fullYear;
					result.month = _visibleRange.end.month;
					result.date = _visibleRange.end.date;
				}
			}
			else
			{
				var rowPos:Number = Math.floor((pt.x - _border.left)/_cellWidth);
				var collPos:Number = Math.floor((pt.y - _border.top)/_cellHeight);
				
				dayIndex = collPos * _rowLength + rowPos;
				result.date += dayIndex;				
				if(result > _visibleRange.end)
				{
					result.fullYear = _visibleRange.end.fullYear;
					result.month = _visibleRange.end.month;
					result.date = _visibleRange.end.date;
				}
			}
			return result;
		}

		private function layoutCells():void
		{		
				for(var cPos:int = 0;cPos<_columnLength;cPos++)
				{
					for(var rPos:int=0;rPos < _rowLength;rPos++)
					{
						var index:int = rPos + cPos*_rowLength;
						var inst:UIComponent = _dayCache.instances[index];
						var header:UIComponent = _headerCache.instances[index];
	
						var target:LayoutTarget = _animator.targetFor(inst);
						target.unscaledHeight = _cellHeight;
						target.unscaledWidth = _cellWidth;
						target.x = _border.left + rPos * _cellWidth;
						target.y = _border.top + cPos * _cellHeight;
	
						target = _animator.targetFor(header);
						target.unscaledHeight = header.measuredHeight;
						target.unscaledWidth = _cellWidth;
						target.x = _border.left + rPos * _cellWidth;
						target.y = _border.top + cPos * _cellHeight;
					}
				}
		}
		

		private function layoutDays():void
		{
			var startOfDay:Date = dateForIndex(0);
			var endOfDay:Date = dateForIndex(1);
			var openEventsDict: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 event:CalendarEvent;
			var header:UIComponent;
			var openingEvents:Array;
			var i:int;
			_allDayAreaHeight = 0;

			// lay out the days
			layoutCells();

			target = _animator.targetFor(_scroller);
			target.initializeFunction = setupScrollbar;
			target.x = unscaledWidth - _scroller.measuredWidth;
			target.y = _border.top;
			target.unscaledWidth = _scroller.measuredWidth;
			target.unscaledHeight = _cellHeight;
			target.alpha = 1;


			// first, extract all the all-day events
			var allDayEvents:Array = [];
			for(i=events.length-1;i>=0;i--)
			{
				event = events[i];
				if(event.allDay) // || event.range.daySpan > 1)
				{
					allDayEvents.unshift(events.splice(i,1)[0]);
				}
			}
			// now place them			
			for(rPos=0;rPos < _rowLength;rPos++)
			{
				var index:int = rPos;
				header = _headerCache.instances[index];

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

				if(allDayEvents.length > 0)
				{
					openingEvents = [];
						
					while(allDayEvents.length > 0 && allDayEvents[0].start.getTime() < endOfDay.getTime())
					{
						data = _eventData[allDayEvents.shift()];
						openEventsDict[data] = true;
						openingEvents.push(data);
					}
					renderTop = header.measuredHeight;
					
					var allDayBorderThickness:Number = getStyle("allDayDividerThickness");
					if(isNaN(allDayBorderThickness))
						allDayBorderThickness = 0;
						
					for(i=0;i<openingEvents.length;i++)
					{
						data = openingEvents[i];
						var reservation:int = reservations.reserve(data);
						renderer = data.renderers[0];
						ICalendarEventRenderer(renderer).displayMode = "line";
						target = layoutSingleEvent(data,renderer,
							_border.left + rPos * _cellWidth + EVENT_INSET,
							_border.top + renderTop + renderer.measuredHeight * reservation,
							_cellWidth * Math.max(1,_tz.rangeDaySpan(data.range)) - 2*EVENT_INSET,
							renderer.measuredHeight
						);
						_allDayAreaHeight = Math.max(_allDayAreaHeight,target.y + target.unscaledHeight + 2 + allDayBorderThickness);
					}
				}				
				startOfDay.date = startOfDay.date+1;
				endOfDay.date = endOfDay.date+1;														
			}
			
			startOfDay = dateForIndex(0);
			endOfDay = dateForIndex(1);
			
			
			_allDayAreaHeight = Math.max(_allDayAreaHeight,_border.top + header.measuredHeight);
			
			_dayAreaHeight = unscaledHeight - _border.bottom - _allDayAreaHeight;
			_scroller.setScrollProperties(_dayAreaHeight,0,_hourHeight * 24 - _dayAreaHeight,1);
			if(isNaN(_scrollHour))
			{
				_scrollHour = computeScrollHourToDisplayEvents(_visibleEvents);
			}
			if(_scrollHour * _hourHeight > _hourHeight * 24 - _dayAreaHeight)
				_scrollHour = 24-_dayAreaHeight/_hourHeight;
				
			_scroller.scrollPosition = _scrollHour * _hourHeight;
			
			_eventLayer.mask = _eventMask; 
			_eventMask.graphics.clear();
			_eventMask.graphics.beginFill(0);
			_eventMask.graphics.drawRect(0, _allDayAreaHeight,unscaledWidth - _border.right,_dayAreaHeight+1);
			_eventMask.graphics.endFill();

			target = _animator.targetFor(_hourGrid);
			target.initializeFunction = setupScrollbar;
			target.releaseFunction = releaseGrid;
			target.x = 0;
			target.y = _allDayAreaHeight - _scroller.scrollPosition;
			target.unscaledWidth = unscaledWidth - _border.right;
			target.unscaledHeight = 24 * _hourHeight;
			target.alpha = 1;

			target = _animator.targetFor(_allDayEventBorder);
			target.x = _border.left+1;
			target.y = _border.top + header.measuredHeight+1;
			target.unscaledWidth = unscaledWidth - _border.left - _border.right - 1;
			target.unscaledHeight = _allDayAreaHeight - target.y - 1;

			

			var daysEvents:Array = null;
			for(rPos=0;rPos < _rowLength;rPos++)
			{
				daysEvents = null;
				for(i=0;i<events.length;i++)
				{
					if(events[i].start.getTime() >= endOfDay.getTime())
					{
						daysEvents = events.splice(0,i);
						break;
					}
				}
				if(daysEvents == null)
					daysEvents = events;
				layoutSingleDay(daysEvents,_border.left + rPos * _cellWidth,_allDayAreaHeight,_cellWidth,_cellHeight - header.measuredHeight);

				index = rPos;
				header = _headerCache.instances[index];

				for(anEvent in openEventsDict)
				{
					if(anEvent.event.end < startOfDay)
					{
						delete openEventsDict[anEvent];