////////////////////////////////////////////////////////////////////////////////
//
//  Licensed to the Apache Software Foundation (ASF) under one or more
//  contributor license agreements.  See the NOTICE file distributed with
//  this work for additional information regarding copyright ownership.
//  The ASF licenses this file to You 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 mx.controls
{

import flash.display.DisplayObject;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.geom.Point;
import flash.text.TextLineMetrics;
import flash.ui.Keyboard;
import flash.utils.describeType;
import flash.utils.getQualifiedClassName;

import mx.core.IFlexDisplayObject;
import mx.core.IFlexModuleFactory;
import mx.core.IFontContextComponent;
import mx.core.IUITextField;
import mx.core.UIComponent;
import mx.core.UITextField;
import mx.core.mx_internal;
import mx.events.CalendarLayoutChangeEvent;
import mx.events.DateChooserEvent;
import mx.events.DateChooserEventDetail;
import mx.managers.IFocusManagerComponent;
import mx.skins.halo.DateChooserIndicator;
import mx.styles.ISimpleStyleClient;

use namespace mx_internal;

//--------------------------------------
//  Styles
//--------------------------------------

include "../styles/metadata/GapStyles.as"
include "../styles/metadata/LeadingStyle.as"
include "../styles/metadata/PaddingStyles.as"
include "../styles/metadata/TextStyles.as"

/**
 *  Number of pixels between the component's top border
 *  and the top edge of its content area.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name="paddingTop", type="Number", format="Length", inherit="no")]

/**
 *  Number of pixels between the component's bottom border
 *  and the bottom edge of its content area.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name="paddingBottom", type="Number", format="Length", inherit="no")]

/**
 *  Name of the skin for the <code>rollOverIndicator</code>.
 *  It can be customized to some other shape other than rectangular.
 *  If you want to change just the color,
 *  use the <code>rollOverColor</code> instead.
 *  The default value is the DateChooserRollOverIndicator class.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name="rollOverIndicatorSkin", type="Class", inherit="no")]

/**
 *  Name of the skin for <code>selectionIndicator</code>.
 *  It can customized to some other shape other than rectangular.
 *  If one just needs to change color,
 *  use the <code>selectionColor</code> instead.
 *  The default value is the DateChooserSelectionIndicator class.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name="selectionIndicatorSkin", type="Class", inherit="no")]

/**
 *  Color of the background of today's date.
 *  The default value is <code>0x818181</code>.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name="todayColor", type="uint", format="Color", inherit="yes")]

/**
 *  Name of the skin for <code>todayIndicator</code> style property. It can be customized
 *  to some other shape other than rectangular. If you
 *  want to change just the color, use the <code>todayColor</code> style property instead.
 *  The default value is the DateChooserTodayIndicator class.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name="todayIndicatorSkin", type="Class", inherit="no")]

/**
 *  Name of the style sheet definition to configure the appearence of the current day's
 *  numeric text, which is highlighted
 *  in the control when the <code>showToday</code> property is <code>true</code>.
 *  Specify a "color" style to change the font color.
 *  If omitted, the current day text inherits
 *  the text styles of the control.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name="todayStyleName", type="String", inherit="no")]

/**
 *  Name of the style sheet definition to configure the weekday names of
 *  the control. If omitted, the weekday names inherit the text
 *  styles of the control.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name="weekDayStyleName", type="String", inherit="no")]

//--------------------------------------
//  Other metadata
//--------------------------------------

[ExcludeClass]

[ResourceBundle("controls")]
    
/**
 *  @private
 *  The CalendarLayout class handles the layout of the date grid in a month.
 *  CalendarLayout can be extended to develop DateControls with
 *  single month display control or side-by-side month displays.
 *
 *  @see mx.styles.StyleManager
 */
public class CalendarLayout extends UIComponent
                            implements IFocusManagerComponent, IFontContextComponent
{
    include "../core/Version.as";

    //--------------------------------------------------------------------------
    //
    //  Constructor
    //
    //--------------------------------------------------------------------------

    /**
     *  Constructor.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function CalendarLayout()
    {
        super();

        addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
        addEventListener(MouseEvent.MOUSE_OVER, mouseOverHandler);
        addEventListener(MouseEvent.MOUSE_OUT, mouseOutHandler);
    }
	
	private static const START_END:int = 1;
	private static const START_ONLY:int = 2;
	private static const END_ONLY:int = 3;
	private static const SINGLE_DATE:int = 4;

    //--------------------------------------------------------------------------
    //
    //  Variables
    //
    //--------------------------------------------------------------------------

    /**
     *  @private
     */
    private var todayRow:int = -1;

    /**
     *  @private
     */
    private var todayColumn:int = -1;

    /**
     *  @private
     */
    private var enabledDaysInMonth:Array = [];

    /**
     *  @private
     */
    private var disabledRangeMode:Array;

    /**
     *  @private
     */
    private var cellHeight:Number = 14;

    /**
     *  @private
     */
    private var cellWidth:Number = 14;

    /**
     *  @private
     */
    private var yOffset:Number = -1;

    /**
     *  @private
     */
    mx_internal var dayBlocksArray:Array = [];

    /**
     *  @private
     */
    private var disabledArrays:Array = []; // An Array of Arrays

    /**
     *  @private
     */
    private var todaysLabelReference:IUITextField = null;

    /**
     *  @private
     */
    private var selectedMonthYearChanged:Boolean = false;

    /**
     *  @private
     */
    private var todayIndicator:IFlexDisplayObject;

    /**
     *  @private
     */
    private var selectionIndicator:Array = [];

    /**
     *  @private
     */
    private var rollOverIndicator:IFlexDisplayObject;

    /**
     *  @private
     */
    private var selectedRangeCount:int = 0;

    /**
     *  @private
     */
    private var lastSelectedDate:Date;

    /**
     *  @private
     */
    private var rangeStartDate:Date = null;

    /**
     *  @private
     */
    mx_internal var selRangeMode:int = START_END;

    //--------------------------------------------------------------------------
    //
    //  Overridden properties
    //
    //--------------------------------------------------------------------------

    //----------------------------------
    //  enabled
    //----------------------------------

    /**
     *  @private
     *  Storage for the displayedYear property.
     */
    private var _enabled:Boolean = true;

    /**
     *  @private
     */
    private var enabledChanged:Boolean = false;

    [Inspectable(category="General", defaultValue="true")]

    /**
     *  @private
     */
    override public function get enabled():Boolean
    {
        return _enabled;
    }

    /**
     *  @private
     */
    override public function set enabled(value:Boolean):void
    {
        super.enabled = value;

        _enabled = value;
        enabledChanged = true;

        invalidateProperties();
    }

    //--------------------------------------------------------------------------
    //
    //  Properties
    //
    //--------------------------------------------------------------------------

    //----------------------------------
    //  allowDisjointSelection
    //----------------------------------

    /**
     *  @private
     *  Storage for the allowDisjointSelection property.
     */
    private var _allowDisjointSelection:Boolean = true;

    [Inspectable(category="General", defaultValue="true")]

    /**
     *  @private
     */
    public function get allowDisjointSelection():Boolean
    {
        return _allowDisjointSelection;
    }

    /**
     *  @private
     */
    public function set allowDisjointSelection(value:Boolean):void
    {
        _allowDisjointSelection = value;
    }

    //----------------------------------
    //  allowMultipleSelection
    //----------------------------------

    /**
     *  @private
     *  Storage for the allowMultipleSelection property.
     */
    private var _allowMultipleSelection:Boolean = false;

    [Inspectable(category="General", defaultValue="false")]

    /**
     *  @private
     */
    public function get allowMultipleSelection():Boolean
    {
        return _allowMultipleSelection;
    }

    /**
     *  @private
     */
    public function set allowMultipleSelection(value:Boolean):void
    {
        _allowMultipleSelection = value;
    }

    //----------------------------------
    //  dayNames
    //----------------------------------

    /**
     *  @private
     *  Storage for the dayNames property.
     */
    private var _dayNames:Array;

    /**
     *  @private
     */
    private var dayNamesChanged:Boolean = false;

    /**
     *  @private
     */
    private var dayNamesOverride:Array;
    
    [Inspectable(category="Other", arrayType="String", defaultValue="null")]

    /**
     *  @private
     */
    public function get dayNames():Array
    {
        return _dayNames;
    }

    /**
     *  @private
     */
    public function set dayNames(value:Array):void
    {
        dayNamesOverride = value;

        _dayNames = value != null ?
                    value :
                    resourceManager.getStringArray(
                        "controls", "dayNamesShortest");

        // _dayNames will be null if there are no resources.
        _dayNames = _dayNames ? _dayNames.slice(0) : null;

        dayNamesChanged = true;

        invalidateProperties();
        invalidateSize();
        invalidateDisplayList();
    }

    //----------------------------------
    //  disabledDays
    //----------------------------------

    /**
     *  @private
     *  Storage for the disabledDays property.
     */
    private var _disabledDays:Array = [];

    [Inspectable(category="General", arrayType="int")]

    /**
     *  @private
     */
    public function get disabledDays():Array
    {
        var result:Array = [];
        
        for (var i:int = 0, k:int = 0; i < _disabledDays.length; i++)
        {
            if (_disabledDays[i] >= 0 && _disabledDays[i] <= 6)
            {
                result[k] = _disabledDays[i];
                k++;
            }
        }

        return result;
    }

    /**
     *  @private
     */
    public function set disabledDays(value:Array):void
    {
        _disabledDays = value.slice(0);
        selectedMonthYearChanged = true;
        
        invalidateProperties();
        
        // This removes the disabled ranges/days from the selected ranges.
        var selRange:Array = selectedRanges;
    }

    //----------------------------------
    //  disabledRanges
    //----------------------------------

    /**
     *  @private
     *  Storage for the disabledRanges property.
     */
    private var _disabledRanges:Array = [];

    [Inspectable(category="General", arrayType="Object")]

    /**
     *  @private
     */
    public function get disabledRanges():Array
    {
        return _disabledRanges.slice(0);
    }

    /**
     *  @private
     */
    public function set disabledRanges(value:Array):void
    {
        _disabledRanges = value.slice(0);
        disabledRangeMode = [];

        for (var i:int = 0; i < _disabledRanges.length; i++)
        {
            if (_disabledRanges[i] is Date)
            {
                disabledRangeMode[i] = SINGLE_DATE;
                _disabledRanges[i] = new Date(value[i].getFullYear(),
                                              value[i].getMonth(),
                                              value[i].getDate());
            }
            else if (_disabledRanges[i] is Object)
            {
                _disabledRanges[i] = {};
                _disabledRanges[i] = value[i];

                if (!_disabledRanges[i].rangeStart &&
                    _disabledRanges[i].rangeEnd)
                {
                    disabledRangeMode[i] = END_ONLY;
                }
                else if (_disabledRanges[i].rangeStart &&
                        !_disabledRanges[i].rangeEnd)
                {
                    disabledRangeMode[i] = START_ONLY;
                }
                else if (_disabledRanges[i].rangeStart &&
                         _disabledRanges[i].rangeEnd)
                {
                    disabledRangeMode[i] = START_END;
                }
            }
        }

        selectedMonthYearChanged = true;

        invalidateProperties();

        // To remove the disabled ranges/days from the selected ranges.
        var selRange:Array=selectedRanges;
    }

    //----------------------------------
    //  displayedMonth
    //----------------------------------

    /**
     *  @private
     *  Storage for the displayedMonth property.
     */
    private var _displayedMonth:int = (new Date()).getMonth();

    /**
     *  @private
     *  Holds the proposed value of displayedMonth until it can be verified in commitProperties
     */
    private var _proposedDisplayedMonth:int = -1;

    [Inspectable(category="General", defaultValue="0")]

    /**
     *  @private
     */
    public function get displayedMonth():int
    {
        return _proposedDisplayedMonth == -1 ? _displayedMonth : _proposedDisplayedMonth;
    }

    /**
     *  @private
     */
    public function set displayedMonth(value:int):void
    {
        if (value < 0 || value > 11)
            return;

        if (value == _proposedDisplayedMonth)
            return;

        _proposedDisplayedMonth = value;
        selectedMonthYearChanged = true;
        invalidateProperties();
    }

    //----------------------------------
    //  displayedYear
    //----------------------------------

    /**
     *  @private
     *  Storage for the displayedYear property.
     */
    private var _displayedYear:int = (new Date()).getFullYear();

    /**
     *  @private
     *  Holds the proposed value of displayedYear until it can be verified in commitProperties
     */
    private var _proposedDisplayedYear:int = -1;

    [Inspectable(category="General", defaultValue="2014")]

    /**
     *  @private
     */
    public function get displayedYear():int
    {
        return _proposedDisplayedYear == -1 ? _displayedYear : _proposedDisplayedYear;
    }

    /**
     *  @private
     */
    public function set displayedYear(value:int):void
    {
        if (value <= 0)
            return;

        if (value == _displayedYear)
            return;
            
        _proposedDisplayedYear = value;
        selectedMonthYearChanged = true;
        invalidateProperties();
    }

    //----------------------------------
    //  firstDayOfWeek
    //----------------------------------

    /**
     *  @private
     *  Storage for the firstDayOfWeek property.
     */
    private var _firstDayOfWeek:int = 0; // Sunday

    [Inspectable(category="General", defaultValue="0")]

    /**
     *  @private
     */
    public function get firstDayOfWeek():int
    {
        return _firstDayOfWeek;
    }

    /**
     *  @private
     */
    public function set firstDayOfWeek(value:int):void
    {
        if (value < 0 || value > 6)
            return;

        if (value == _firstDayOfWeek)
            return;

        _firstDayOfWeek = value;
        dayNamesChanged = true;
        selectedMonthYearChanged = true;
        
        invalidateProperties();
    }

    //----------------------------------
    //  fontContext
    //----------------------------------
    
    /**
     *  @private
     */
    public function get fontContext():IFlexModuleFactory
    {
        return moduleFactory;
    }

    /**
     *  @private
     */
    public function set fontContext(moduleFactory:IFlexModuleFactory):void
    {
        this.moduleFactory = moduleFactory;
    }
    
    //----------------------------------
    //  selectableRange
    //----------------------------------

    /**
     *  @private
     *  Storage for the selectableRange property.
     */
    private var _selectableRange:Object = null;

    [Inspectable(category="General")]

    /**
     *  @private
     */
    public function get selectableRange():Object
    {
        return _selectableRange;
    }

    /**
     *  @private
     */
    public function set selectableRange(value:Object):void
    {
        if (!value)
        {
            _selectableRange = null;
            selectedMonthYearChanged = true;
            invalidateProperties();
            return;
        }

        var todaysDate:Date = new Date();
        var todaysMonth:int = todaysDate.getMonth();
        var todaysYear:int = todaysDate.getFullYear();
        var callMonth:int;
        var callYear:int;
        
        if (value is Date)
        {
            selRangeMode = SINGLE_DATE;
            
            _selectableRange = new Date(value.getFullYear(),
                                        value.getMonth(),
                                        value.getDate());
            
            callMonth  = value.getMonth();
            callYear = value.getFullYear();
        }
        else if (value is Object)
        {
            _selectableRange = {};

            if (!value.rangeStart && value.rangeEnd)
            {
                selRangeMode = END_ONLY;
                _selectableRange.rangeEnd = value.rangeEnd;
                
                if (todaysYear <= _selectableRange.rangeEnd.getFullYear())
                {
                    if (todaysMonth >= _selectableRange.rangeEnd.getMonth())
                    {
                        callMonth = _selectableRange.rangeEnd.getMonth();
                        callYear = _selectableRange.rangeEnd.getFullYear();
                    }
                    else if (todaysMonth <=
                             _selectableRange.rangeEnd.getMonth())
                    {
                        callMonth = todaysMonth;
                        callYear = todaysYear;
                    }
                }
                else if (todaysYear > _selectableRange.rangeEnd.getFullYear())
                {
                    callMonth = _selectableRange.rangeEnd.getMonth();
                    callYear = _selectableRange.rangeEnd.getFullYear();
                }

            }
            else if (!value.rangeEnd && value.rangeStart)
            {
                selRangeMode = START_ONLY;
                _selectableRange.rangeStart = value.rangeStart;
                
                if (todaysYear >= _selectableRange.rangeStart.getFullYear())
                {
                    if (todaysMonth <= _selectableRange.rangeStart.getMonth())
                    {
                        callMonth = _selectableRange.rangeStart.getMonth();
                        callYear = _selectableRange.rangeStart.getFullYear();
                    }
                    else if (todaysMonth >=
                             _selectableRange.rangeStart.getMonth())
                    {
                        callMonth = todaysMonth;
                        callYear = todaysYear;
                    }
                }
                else if (todaysYear < _selectableRange.rangeStart.getFullYear())
                {
                    callMonth = _selectableRange.rangeStart.getMonth();
                    callYear = _selectableRange.rangeStart.getFullYear();
                }
            }
            else if (value.rangeStart && value.rangeEnd)
            {
                selRangeMode = START_END;
                _selectableRange.rangeStart = value.rangeStart;
                _selectableRange.rangeEnd = value.rangeEnd;
                
                if (todaysDate >= _selectableRange.rangeStart &&
                    todaysDate <= _selectableRange.rangeEnd)
                {
                    callMonth = todaysMonth;
                    callYear = todaysYear;
                }
                else if (todaysDate < _selectableRange.rangeStart)
                {
                    callMonth = _selectableRange.rangeStart.getMonth();
                    callYear = _selectableRange.rangeStart.getFullYear();
                }
                else if (todaysDate > _selectableRange.rangeEnd)
                {
                    callMonth = _selectableRange.rangeEnd.getMonth();
                    callYear = _selectableRange.rangeEnd.getFullYear();
                }
            }
        }

        _displayedMonth = callMonth;
        _displayedYear = callYear;

        selectedMonthYearChanged = true;
        invalidateProperties();
        
        // This removes the non-selectable ranges from the selected ranges.
        var selRange:Array = selectedRanges;
    }

    //----------------------------------
    //  selectedRanges
    //----------------------------------

    /**
     *  @private
     *  Storage for the selectableRange property.
     */
    private var _selectedRanges:Array = [];

    [Inspectable(category="General", arrayType="Object")]

    /**
     *  @private
     */
    public function get selectedRanges():Array
    {
        if (_selectableRange)
        {		
            switch (selRangeMode)
            {
                case START_END:
                {
                    removeRangeFromSelection(null, addSubtractDays(_selectableRange.rangeStart, -1));
                    removeRangeFromSelection(addSubtractDays(_selectableRange.rangeEnd, +1), null);
                    break;
                }

                case START_ONLY:
                case END_ONLY:
                {
                    removeRangeFromSelection(addSubtractDays(_selectableRange.rangeStart, -1),
												addSubtractDays(_selectableRange.rangeEnd, +1));
                    break;
                }

                case SINGLE_DATE:
                {
                    removeDayFromSelection(_selectableRange as Date);
                    break;
                }
            }
        }

        var i:int;
        
        for (i = 0; i < _disabledRanges.length; i++)
        {
            switch (disabledRangeMode[i])
            {
                case START_END:
                case START_ONLY:
                case END_ONLY:
                {
                    removeRangeFromSelection(_disabledRanges[i].rangeStart, _disabledRanges[i].rangeEnd);
                    break;
                }

                case SINGLE_DATE:
                {
                    removeDayFromSelection(_disabledRanges[i]);
                    break;
                }
            }
        }

        if (_disabledDays.length > 0 && selectedRangeCount)
        {
            var minDate:Date = _selectedRanges[0].rangeStart;
            var maxDate:Date = _selectedRanges[0].rangeEnd;

            for (i = 1; i < selectedRangeCount; i++)
            {
                if (minDate > _selectedRanges[i].rangeStart)
                    minDate = _selectedRanges[i].rangeStart;

                if (maxDate < _selectedRanges[i].rangeEnd)
                    maxDate = _selectedRanges[i].rangeEnd;
            }

            for (i = 0; i < _disabledDays.length; i++)
            {
                var tempDate:Date = minDate;

                var dayOffset:int = _disabledDays[i] - tempDate.getDay();

                if (dayOffset < 0)
                    dayOffset += 7;

                tempDate = addSubtractDays(tempDate, dayOffset);

                while (tempDate < maxDate)
                {
                    removeDayFromSelection(tempDate);
                    tempDate = addSubtractDays(tempDate, 7);
                }
            }
        }

        _selectedRanges.length = selectedRangeCount;
        return _selectedRanges;
    }

    /**
     *  @private
     */
    public function set selectedRanges(value:Array):void
    {
        _selectedRanges = value;

        selectedRangeCount = _selectedRanges.length;

        setSelectedIndicators();
    }

    //----------------------------------
    //  showToday
    //----------------------------------

    /**
     *  @private
     *  Storage for the showToday property.
     */
    private var _showToday:Boolean = true;

    [Inspectable(category="General", defaultValue="true")]

    /**
     *  @private
     */
    public function get showToday():Boolean
    {
        return _showToday;
    }

    /**
     *  @private
     */
    public function set showToday(value:Boolean):void
    {
        if (_showToday != value)
            _showToday = value;

        selectedMonthYearChanged = true;

        invalidateProperties();
    }

    //----------------------------------
    //  selectedDate
    //----------------------------------

    [Inspectable(category="General", defaultValue="null")]

    /**
     *  @private
     */
    public function get selectedDate():Date
    {
        return selectedRangeCount ? _selectedRanges[0].rangeStart : null;
    }

    /**
     *  @private
     */
    public function set selectedDate(value:Date):void
    {
        selectedRangeCount = 0;

        if (value && !checkDateIsDisabled(value))
        {
            addToSelected(value);
            
            _displayedMonth = value.getMonth();
            _displayedYear = value.getFullYear();
            selectedMonthYearChanged = true;
            
            invalidateProperties();
        }
        else
        {
            setSelectedIndicators();
        }
    }

    //--------------------------------------------------------------------------
    //
    //  Overridden methods
    //
    //--------------------------------------------------------------------------

    /*

    A note about DayBlocks:

    dayBlock0..dayBlock6 are skins for the 7 grid columns.
    They are dynamically created instances of the "DayBlock" symbol.
    Three additional properties are set when each dayBlock is created
    in createChildren():

        columnIndex:int (0-6)
            keeps track of where this dayBlock is in the grid

        selectedArray:Array
            7 elements, one for each row
            selectedArray[rowIndex] is true
                if that row in the dayBlock is selected

        disabledArray:Array
            7 elements, one for each row
            disabledArray[rowIndex] is true
                if that row in the dayBlock is disabled

    Additional properties are created dynamically to hold the skins
    for selected and disabled rows in the dayBlock:

        selectedSkin0..selectedSkin6

        disabledSkin0..disabledSkin6

    */

    /**
     *  @private
     *  Everything that gets initially created now exists.
     *  Some things, such as the selection skins and disabled skins,
     *  are created later as they are needed.
     *  Set the "S", "M", etc. labels in the first row.
     *  
     *  Set the day-number labels ("1".."31") in the other rows.
     *  This method also displays the selection skins,
     *  the disabled skins, and the "today" indicator.
     */
    override protected function createChildren():void
    {
        super.createChildren();

        var labelPosition:Number = 0;

        createDayLabels(-1);
        createTodayIndicator(0);
        
        if (!rollOverIndicator)
        {
            var rollOverIndicatorClass:Class = getStyle("rollOverIndicatorSkin");
            if (!rollOverIndicatorClass)
                rollOverIndicatorClass = DateChooserIndicator;
            rollOverIndicator = IFlexDisplayObject(new rollOverIndicatorClass());
            // too lazy to make an interface for this.
            if (isDateChooserIndicator(rollOverIndicator))
                Object(rollOverIndicator).indicatorColor = "rollOverColor";
            if (rollOverIndicator is ISimpleStyleClient)
                ISimpleStyleClient(rollOverIndicator).styleName = this;
            addChildAt(DisplayObject(rollOverIndicator), 0);
            rollOverIndicator.visible = false;
        }

        // Wait for all of the properties to be set before calling setSelectedMonthAndYear
        dayNamesChanged = true;
        selectedMonthYearChanged = true;
    }

    /**
     *  @private
     */
    override protected function commitProperties():void
    {
        super.commitProperties();

        if (hasFontContextChanged() && todayIndicator != null)
        {
            // Re-create the children so we can display
            // the embedded font from the new font context.
            removeSelectionIndicators();
            
            var childIndex:int = getChildIndex(DisplayObject(todayIndicator));
            removeTodayIndicator();
            createTodayIndicator(childIndex);

            childIndex = getChildIndex(dayBlocksArray[0][0]);
            removeDayLabels();
            createDayLabels(childIndex);
            
            enabledChanged = true;
            dayNamesChanged = true;
            selectedMonthYearChanged = true;
        }

        if (enabledChanged)
        {
            enabledChanged = false;

            for (var o:int = 0; o < 7; o++)
            {
                for (var r:int = 0; r < 7; r++)
                {
                    dayBlocksArray[o][r].enabled = _enabled;
                    disabledArrays[o][r] = _enabled;
                }
            }

            if (!_enabled)
            {

                if (todayIndicator)
                    todayIndicator.alpha = 0.3;

                // Remove the mouse event listeners
                removeEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
                removeEventListener(MouseEvent.MOUSE_OVER, mouseOverHandler);
                removeEventListener(MouseEvent.MOUSE_OUT, mouseOutHandler);
                removeEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
            }
            else
            {
                if (todayIndicator)
                    todayIndicator.alpha = 1.0;

                selectedMonthYearChanged = true;

                // Restore the mouse event listeners
                addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
                addEventListener(MouseEvent.MOUSE_OVER, mouseOverHandler);
                addEventListener(MouseEvent.MOUSE_OUT, mouseOutHandler);
                addEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
            }
        }

        if (dayNamesChanged)
        {
            dayNamesChanged = false;

            drawDayNames();
        }

        if (selectedMonthYearChanged)
        {
            selectedMonthYearChanged = false;

            var proposedDate:Date = 
                new Date(_proposedDisplayedYear == -1 ? _displayedYear : _proposedDisplayedYear,
                         _proposedDisplayedMonth == -1 ? _displayedMonth : _proposedDisplayedMonth);
                         
            if (isDateInRange(proposedDate, _selectableRange, selRangeMode, true))
            {            
                setSelectedMonthAndYear();
            }   
            
            _proposedDisplayedYear = -1;
            _proposedDisplayedMonth = -1;
        }
    }

    /**
     *  @private
     */
    override protected function measure():void
    {
        super.measure();

        var verticalGap:Number = getStyle("verticalGap");
        var horizontalGap:Number = getStyle("horizontalGap");

        var paddingLeft:Number = getStyle("paddingLeft");
        var paddingRight:Number = getStyle("paddingRight");
        var paddingBottom:Number = getStyle("paddingBottom");
        var paddingTop:Number = getStyle("paddingTop");

        var lineMetrics:TextLineMetrics;

        cellWidth = 0;
        cellHeight = 0;

        for (var dayOfWeek:int = 0; dayOfWeek < 7; dayOfWeek++)
        {
            // dayNames will be null if there are no resources.
            var dayName:String = dayNames ? dayNames[dayOfWeek] : "";
            lineMetrics = measureText(dayName);
            if (lineMetrics.width > cellWidth)
                cellWidth = lineMetrics.width;
            if (lineMetrics.height > cellHeight)
                cellHeight = lineMetrics.height;
        }

        lineMetrics = measureText("30");

        if (lineMetrics.width > cellWidth)
            cellWidth = lineMetrics.width;

        if (lineMetrics.height > cellHeight)
            cellHeight = lineMetrics.height;

        measuredWidth = paddingLeft + horizontalGap * 6 +
                        cellWidth * 7 + paddingRight;
        measuredHeight = verticalGap * 6 + cellHeight * 7 +
                         paddingBottom + paddingTop;
        measuredMinWidth = cellWidth * 7;
        measuredMinHeight = cellHeight * 7;
    }

    /**
     *  @private
     */
    override protected function updateDisplayList(unscaledWidth:Number,
                                                  unscaledHeight:Number):void
    {
        super.updateDisplayList(unscaledWidth, unscaledHeight);

        //var verticalGap:Number = getStyle("verticalGap");
        //var horizontalGap:Number = getStyle("horizontalGap");

        var paddingLeft:Number = getStyle("paddingLeft");
        var paddingRight:Number = getStyle("paddingRight");
        var paddingBottom:Number = getStyle("paddingBottom");
        var paddingTop:Number = getStyle("paddingTop");

        var blockX:Number = paddingLeft;

        // Bug 134794, clip height/width so that RTE's are not thrown
        cellWidth = Math.max((unscaledWidth - (paddingLeft + paddingRight))/7, 4);
        cellHeight = Math.max((unscaledHeight - paddingBottom)/7, 4);

        var labelPosition:Number = paddingTop;

        rollOverIndicator.setActualSize(cellWidth, cellHeight);
        todayIndicator.setActualSize(cellWidth, cellHeight);

        for (var columnIndex:int = 0; columnIndex < 7; columnIndex++)
        {
            // Remember the height of the cells if not set by user.
            // Create the 7 labels within each DayBlock.
            // The first row in each column displays a day name string, such as "Sun".
            // The other six rows displays day numbers in the range 1-31.

            for (var rowIndex:int = 0; rowIndex < 7; rowIndex++)
            {
                var label:IUITextField = dayBlocksArray[columnIndex][rowIndex];
                if (rowIndex == 0)
                    labelPosition = paddingTop;
                else
                    labelPosition += cellHeight;

                label.setActualSize(cellWidth, cellHeight);
                label.move(blockX, labelPosition);

                if (selectionIndicator[columnIndex][rowIndex])
                {
                    selectionIndicator[columnIndex][rowIndex].setActualSize(cellWidth, cellHeight);
                    selectionIndicator[columnIndex][rowIndex].move(blockX, labelPosition + yOffset);
                }
               //label.width = cellWidth;
                //label.height = cellHeight;
                //label.x = blockX;
                //label.y = labelPosition;
            }

            blockX += cellWidth;
        }

        drawDayNames();
        setSelectedMonthAndYear();
    }

    /**
     *  @private
     */
    override public function styleChanged(styleProp:String):void
    {
        var allStyles:Boolean = !styleProp || styleProp == "styleName";

        if (allStyles || styleProp == "todayStyleName")
        {
            selectedMonthYearChanged = true;
            invalidateProperties();
        }

        if (allStyles || styleProp == "weekDayStyleName")
        {
            var weekDayStyleName:Object = getStyle("weekDayStyleName");
            if (!weekDayStyleName)
                weekDayStyleName = this;

            if (dayBlocksArray)
            {
                for (var i:int = 0; i < 7; i++)
                {
                    // Set the styleName on the top row of day name labels
                    if (dayBlocksArray[i] && dayBlocksArray[i][0])
                        dayBlocksArray[i][0].styleName = weekDayStyleName;
                }
            }
        }

        super.styleChanged(styleProp);
    }

    /**
     *  @private
     */
    override protected function resourcesChanged():void
    {
        super.resourcesChanged();

        dayNames = dayNamesOverride;
    }

    //--------------------------------------------------------------------------
    //
    //  Methods
    //
    //--------------------------------------------------------------------------

    /**
     *  @private
     *  Creates the day labels and adds them as children of this component.
     * 
     *  @param childIndex The index of where to add the children.
     *  If -1, the text fields are appended to the end of the list.
     */
    mx_internal function createDayLabels(childIndex:int):void
    {
        var weekDayStyleName:Object = getStyle("weekDayStyleName");

        // Remember the height of the cells if not set by user.
        // Create the 7 labels within each DayBlock.
        // The first row in each column displays a day name string,
        // such as "Sun".
        // The other six rows displays day numbers in the range 1-31.

        // Calendar days
        for (var columnIndex:int = 0; columnIndex < 7; columnIndex++)
        {
            dayBlocksArray[columnIndex] = [];
            selectionIndicator[columnIndex] = [];

            for (var rowIndex:int = 0; rowIndex < 7; rowIndex++)
            {
                var label:IUITextField =
                dayBlocksArray[columnIndex][rowIndex] =
                    IUITextField(createInFontContext(UITextField));
                
                label.selectable = false;
                label.ignorePadding = true;
    
                if (childIndex == -1)
                    addChild(DisplayObject(label));         
                else
                    addChildAt(DisplayObject(label), childIndex++);
    
                if (rowIndex == 0)
                {
                    label.styleName = weekDayStyleName ?
                                      weekDayStyleName :
                                      this;
                }
                else
                {
                    label.styleName = this;
                }
            }

            disabledArrays[columnIndex] = new Array(7);
        }
    }

    /**
     *  @private
     *  Removes the day labels from this component.
     */
    mx_internal function removeDayLabels():void
    {
       for (var columnIndex:int = 0; columnIndex < 7; columnIndex++)
        {
            for (var rowIndex:int = 0; rowIndex < 7; rowIndex++)
            {
                removeChild(dayBlocksArray[columnIndex][rowIndex]);
                dayBlocksArray[columnIndex][rowIndex] = null;
            }
        }
    }
    
    /**
     *  @private
     *  @param childIndex The index of where to add the child.
     */
    mx_internal function createTodayIndicator(childIndex:int):void
    {
        if (!todayIndicator)
        {
            var todayIndicatorClass:Class = getStyle("todayIndicatorSkin");
            if (!todayIndicatorClass)
                todayIndicatorClass = DateChooserIndicator;
            todayIndicator = IFlexDisplayObject(new todayIndicatorClass());
            
            if (isDateChooserIndicator(todayIndicator))
            {
                Object(todayIndicator).indicatorColor =
                    "todayColor";
            }
            if (todayIndicator is ISimpleStyleClient)
                ISimpleStyleClient(todayIndicator).styleName = this;
            
            addChildAt(DisplayObject(todayIndicator), childIndex);
            
            todayIndicator.visible = false;
        }
    }

    /**
     *  @private
     */
    mx_internal function removeTodayIndicator():void
    {
        if (todayIndicator)
        {
            removeChild(DisplayObject(todayIndicator));
            todayIndicator = null;
        }       
    }

    /**
     *  @private
     */
    mx_internal function drawDayNames():void
    {
        for (var columnIndex:int = 0; columnIndex < 7; columnIndex++)
        {
            var dayOfWeek:int = (columnIndex + firstDayOfWeek) % 7;
            // dayNames will be null if there are no resources.
            var dayName:String = dayNames ? dayNames[dayOfWeek] : "";
            dayBlocksArray[columnIndex][0].text = dayName;
        }
    }

    /**
     *  @private
     */
    mx_internal function setSelectedMonthAndYear(monthVal:int = -1, yearVal:int = -1):void
    {
        // This lengthy method updates the UI to display a specified month
        // and year. In particular, it updates the day numbers (1-31) in the grid.

        // It does NOT update the day names ("Sun", "Mon", etc.),
        // since these do not change when the month and year change.
        //
        // It also takes care of displaying days that are disabled or selected.
        // Instances of the skins cal_monthDayDisabled (for disabled days) and
        // cal_monthDaySelected (for selected days) get created as they
        // are required, to minimize initialization time.

        var dayNumber:int; // 1 - 31
        var columnIndex:int; // 0 - 6
        var rowIndex:int; // 1 - 6
        var i:int;
        var displayTodayInCurrentMonth:Boolean = false;
        var displayDate:Date = null;


        // When another method needs to redraw the UI without changing the
        // currently selected month and year (because the firstDayOfWeek
        // property changed, for example) it calls setSelectedMonthAndYear()
        // with no arguments. Therefore we need to handle undefined arguments.
        var newMonth:int = monthVal == -1 ? displayedMonth : monthVal;
        var newYear:int = yearVal == -1 ? displayedYear : yearVal;

        // Determine where in the grid the 1st of the month should appear,
        // how many days are in the month, and today's date.

        enabledDaysInMonth = [];
        var offset:int = getOffsetOfMonth(newYear, newMonth);
        var daysInMonth:int = getNumberOfDaysInMonth(newYear, newMonth);

        // Determine whether this month contains today.
        var today:Date = new Date();
        var currentMonthContainsToday:Boolean = (today.getFullYear() == newYear && today.getMonth() == newMonth);

        // Set up the days (if any) in row 1 that come from the previous month.
        var previousMonth:int = Math.max(newMonth - 1,0);
        var previousMonthDate:Date = new Date(newYear, previousMonth, 1);
        dayNumber = getNumberOfDaysInMonth(previousMonthDate.getFullYear(), previousMonthDate.getMonth());
        rowIndex = 1;

        for (columnIndex = 0; columnIndex < offset; columnIndex++)
        {
            dayBlocksArray[columnIndex][rowIndex].text = "";

            // Disable the day.
            disabledArrays[columnIndex][rowIndex] = true;

            removeSelectionIndicator(columnIndex,rowIndex);
        }

        // Set up the days of the new month.
        for (dayNumber = 1; dayNumber <= daysInMonth; dayNumber++)
        {
            var cellDate:Date = new Date(newYear, newMonth, dayNumber);
            i = offset + dayNumber - 1;
            columnIndex = i % 7;
            rowIndex = 1 + Math.floor(i / 7);

            var todayLabel:IUITextField = dayBlocksArray[columnIndex][rowIndex];//this["dayBlock" + columnIndex+"label" + rowIndex];
            todayLabel.text = dayNumber.toString();
            // Enable the day.

            if (_enabled)
            {
                disabledArrays[columnIndex][rowIndex] = false;
                todayLabel.enabled = true;
            }

            if (!todayLabel.styleName)
                todayLabel.styleName = this;

            // Some of these days may be selected.
            // One of these days may be today's date.
            if (currentMonthContainsToday && (cellDate.getDate() == today.getDate()) && _showToday)
            {
                todayRow = rowIndex;
                todayColumn = columnIndex;
                displayTodayInCurrentMonth = true;

                todayIndicator.visible = _showToday;
                todayLabel.styleName = getStyle("todayStyleName");

                todayIndicator.move(todayLabel.x, todayLabel.y + yOffset); // Don't trigger layout
                todaysLabelReference = todayLabel;

            }
            else
            {
                if (!displayTodayInCurrentMonth)
                {
                    if (todaysLabelReference)
                    {
                        todaysLabelReference.styleName = this;
                        //todaysLabelReference.styleName = this;
                    }
                    todayIndicator.visible = false;
                }
            }

            var cellString:String;

            // Selectable Range
            // set up the selectable Range: type: Object/ Date Object
            // Object Attrib: rangeStart[Date Object], rangeEnd[Date Object]
            // 1 :: if both attribs are defined
            // 2 :: If only rangeStart is defined: All dates after the specified date are enabled
            // 3 :: if only rangeEnd is defined: All dates before ths specified date are enabled
            // 4 :: If selectable Range param is a Date Object, then only that day has to be defined

            if (_selectableRange)
            {
                if (!isDateInRange(cellDate, _selectableRange, selRangeMode))
                {
                    todayLabel.enabled = false;
                    disabledArrays[columnIndex][rowIndex] = true;
                }
            }

            // Disabled Ranges
            // set up the disabledRanges: type: Array
            // Array can contain an Object || Date Object.
            // Attrib for Object: rangeStart[Date Object], rangeEnd[Date Object]
            // "start"::All dates after the specified date are disabled, including the startDate
            // "end"::All dates before ths specified date are disabled, including the end Date
            // "date"::Only that day has to be disabled
            // "normal"::range is disabled including the start and end date
            if (_disabledRanges.length > 0)
            {
                for (var dRanges:int = 0; dRanges < _disabledRanges.length; dRanges++)
                {
                    if (isDateInRange(cellDate, _disabledRanges[dRanges], disabledRangeMode[dRanges]))
                    {
                        todayLabel.enabled = false;
                        disabledArrays[columnIndex][rowIndex] = true;
                    }
                }
            }

            var valToPush:Object = {};
            if (todayLabel.enabled)
            {
                valToPush.name = todayLabel.name;
                valToPush.text = todayLabel.text;
                valToPush.x = todayLabel.x;
                valToPush.y = todayLabel.y;
            }
            enabledDaysInMonth.push(valToPush);
        }

        // Set up the days (if any) at the end of the grid
        // that come from the following month.
        dayNumber = 1;
        for (i = offset + daysInMonth; i < 42; i++)
        {
            columnIndex = i % 7;
            rowIndex = 1 + Math.floor(i / 7);

            dayBlocksArray[columnIndex][rowIndex].text = "";


            // Disable the day.
            disabledArrays[columnIndex][rowIndex] = true;
            removeSelectionIndicator(columnIndex,rowIndex);
        }

        if (_disabledDays.length>0)
        {
            for (i = 0; i < _disabledDays.length; i++)
            {
                if (_disabledDays[i] >= 0 && _disabledDays[i] <= 6 && _disabledDays[i] != -1)
                {
                    columnIndex = ((7 + _disabledDays[i] - _firstDayOfWeek) % 7);

                    for (rowIndex = 1; rowIndex < 7; rowIndex++)
                    {
                        // Disable the day.
                        disabledArrays[columnIndex][rowIndex] = true;
                        var tempCalcDate:Number = Number(dayBlocksArray[columnIndex][rowIndex].text);
                        var tempOffset:Number;
                        if (!isNaN(tempCalcDate))
                        {
                            tempOffset = offset + tempCalcDate % 7;
                            enabledDaysInMonth[tempCalcDate-1] = null;
                        }
                        dayBlocksArray[columnIndex][rowIndex].enabled = false;
                    }
                }
            }
        }

        _displayedMonth = newMonth;
        _displayedYear = newYear;
        displayDate = new Date(newYear, newMonth, 1);
        todayIndicator.alpha = (todaysLabelReference) ? ((todaysLabelReference.enabled == false) ? 0.3 : 1.0) : 1.0;
        setSelectedIndicators();
        invalidateDisplayList();
    }

    /**
     *  @private
     *  Called from setSelectedMonthAndYear() to get an Offset of the starting day of the month
     */
    mx_internal function getOffsetOfMonth(year:int, month:int):int
    {
        // Determine whether the 1st of the month is a Sunday, Monday, etc.
        // and then determine which column of the grid where it appears.
        var first:Date = new Date(year, month, 1);
        var offset:int = first.getDay() - _firstDayOfWeek;
        return offset < 0 ? offset + 7 : offset;
    }

    /**
     *  @private
     */
    mx_internal function getNumberOfDaysInMonth(year:int, month:int):int
    {
        // "Thirty days hath September..."

        var n:int;

        if (month == 1) // Feb
        {
            if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) // leap year
                n = 29;
            else
                n = 28;
        }

        else if (month == 3 || month == 5 || month == 8 || month == 10)
            n = 30;

        else
            n = 31;

        return n;
    }

    /**
     *  @private
     */
    mx_internal function stepDate(deltaY:int, deltaM:int, triggerEvent:Event = null):void
    {
        var oldYear:int = displayedYear;
        var oldMonth:int = displayedMonth;

        var newDate:Object = getNewIncrementDate(oldYear, oldMonth, deltaY, deltaM);

        var newYear:int = newDate.year;
        var newMonth:int = newDate.month;

        _displayedMonth = newMonth;
        _displayedYear = newYear;
        selectedMonthYearChanged = true;
        invalidateProperties();

        var event:DateChooserEvent = new DateChooserEvent(DateChooserEvent.SCROLL);
        event.triggerEvent = triggerEvent;
        if (newYear > oldYear)
            event.detail = DateChooserEventDetail.NEXT_YEAR;
        else if (newYear < oldYear)
            event.detail = DateChooserEventDetail.PREVIOUS_YEAR;
        else if (newMonth > oldMonth)
            event.detail = DateChooserEventDetail.NEXT_MONTH;
        else if (newMonth < oldMonth)
            event.detail = DateChooserEventDetail.PREVIOUS_MONTH;
        dispatchEvent(event);
    }
    
    /**
     *  @private Takes a year and a month as well as an increment year and month value
     *           and returns a new valid year/month.
     */
    static mx_internal function getNewIncrementDate(oldYear:int, oldMonth:int, deltaY:int, deltaM:int):Object
    {
        var newYear:int = oldYear + deltaY;
        var newMonth:int = oldMonth + deltaM;

        while (newMonth < 0)
        {
            newYear--;
            newMonth += 12;
        }

        while (newMonth > 11)
        {
            newYear++;
            newMonth -= 12;
        }

        return {month: newMonth, year: newYear};
    }

    /**
     *  @private
     */
    mx_internal function dispatchChangeEvent(triggerEvent:Event = null):void
    {
        var change:CalendarLayoutChangeEvent =
            new CalendarLayoutChangeEvent(CalendarLayoutChangeEvent.CHANGE);
        change.newDate = lastSelectedDate;
        change.triggerEvent = triggerEvent;
        dispatchEvent(change);
    }

    /**
     *  @private
     * 
     *  Returns true if the date is within the dates specified by the dateRange object. 
     */ 
    mx_internal function isDateInRange(value:Date, dateRange:Object, rangeMode:int, ignoreDay:Boolean = false):Boolean
    {
        var result:Boolean = true;
        
        if (dateRange)
        {
            if (ignoreDay)
            {
                var dateRangeCopy:Object = {};
                if (dateRange.rangeStart)
                {
                    var startDate:Date = dateRange.rangeStart;
                    dateRangeCopy.rangeStart = new Date(startDate.fullYear, startDate.month, 1);
                }
                if (dateRange.rangeEnd)
                {
                    var endDate:Date = dateRange.rangeEnd;
                    dateRangeCopy.rangeEnd = new Date(endDate.fullYear, endDate.month, getNumberOfDaysInMonth(endDate.fullYear, endDate.month));
                }
                dateRange = dateRangeCopy;
            }
            
            switch (rangeMode)
            {	
                case START_END:
                {
                    if (value < dateRange.rangeStart ||
                        value > dateRange.rangeEnd)
                    {
                        result = false;
                    }
                    break;
                }

                case START_ONLY:
                {
                    if (value < dateRange.rangeStart)
                        result = false;
                    break;
                }

                case END_ONLY:
                {
                    if (value > dateRange.rangeEnd)
                        result = false;
                    break;
                }

                case SINGLE_DATE:
                {
                    if (value > dateRange || value < dateRange)
                        result = false;
                    break;
                }

                default:
                {
                    break;
                }
            }
        }
        
        return result;
    }


    /**
     *  @private
     *
     *  Checking for valid dates, months and Years before setting them through API
     *  Returns true is date is disabled. null date is considered enabled,
     *  as one can set date to null.
     */
    mx_internal function checkDateIsDisabled(value:Date):Boolean
    {
        if (!value)
            return false;

        var selectedDateIsDisabled:Boolean = false;

        if (_selectableRange)
        {
            if (!isDateInRange(value, _selectableRange, selRangeMode))
            {
                selectedDateIsDisabled = true;
            }
        }

        if (_disabledRanges.length > 0)
        {
            for (var dRanges:int = 0; dRanges < _disabledRanges.length; dRanges++)
            {
                if (isDateInRange(value, _disabledRanges[dRanges], disabledRangeMode[dRanges]))
                {
                    selectedDateIsDisabled = true;
                }
            }
        }

        if (_disabledDays.length > 0)
        {
            for (var i:int = 0; i < _disabledDays.length; i++)
            {
                if (value.getDay() == _disabledDays[i])
                    selectedDateIsDisabled = true;
            }
        }

        return selectedDateIsDisabled;
    }

    /**
     *  @private
     *  Adds the newDate to the list of selected dates.
     *  If range is true, a range of dates starting from the previous selection is selected.
     */
    mx_internal function addToSelected(newDate:Date, range:Boolean = false):void
    {

        if (selectedRangeCount == 0)
            rangeStartDate = null;

        lastSelectedDate = newDate;

        if (range == false)
        {
            _selectedRanges[selectedRangeCount] = {};
            _selectedRanges[selectedRangeCount].rangeStart =
                new Date(newDate);
            _selectedRanges[selectedRangeCount].rangeEnd =
                _selectedRanges[selectedRangeCount].rangeStart;
            selectedRangeCount++;
        }
        else
        {
            if (selectedRangeCount == 0)
            {
                _selectedRanges[0] = {};
                _selectedRanges[0].rangeStart = new Date(newDate);
            }
            else
            {
                selectedRangeCount = 1;

                if (!rangeStartDate)
                    rangeStartDate = _selectedRanges[0].rangeStart;

                _selectedRanges[0].rangeStart = new Date(rangeStartDate);

                if (newDate < _selectedRanges[0].rangeStart)
                {
                    _selectedRanges[0].rangeEnd = _selectedRanges[0].rangeStart;
                    _selectedRanges[0].rangeStart = new Date(newDate);
                    return;
                }
            }

            _selectedRanges[0].rangeEnd = new Date(newDate);
        }
    }

    /**
     *  @private
     *  Increments/decrements a date by 'No. of days'
     *  specified by amount and returns the new date.
     */
    mx_internal function addSubtractDays(value:Date, amount:int):Date
    {
        var newDate:Date = new Date(value);
		
		if (value)
        	return new Date(newDate.fullYear, newDate.month, newDate.date + amount);
		else
			return null;
    }

    /**
     *  @private
     *  Returns true if newDate is selected.
     */
    mx_internal function isSelected(newDate:Date):Boolean
    {
        for (var i:int = 0; i < selectedRangeCount; i++)
        {
            if (newDate >= _selectedRanges[i].rangeStart &&
                newDate <=_selectedRanges[i].rangeEnd)
            {
                return true;
            }
        }

        return false;
    }

    /**
     *  @private
     *  Removes the range of dates specified by startDate and endDate
     *  from the selected dates.
     */
    mx_internal function removeRangeFromSelection(startDate:Date, endDate:Date):void
	{
		var rangeEnd:Date;
		var rangeStart:Date;
		
		if (endDate < startDate)
			return;
		
		for (var n:int = 0; n < selectedRangeCount; n++)
		{
			rangeStart = _selectedRanges[n].rangeStart;
			rangeEnd = _selectedRanges[n].rangeEnd;
			
			// ignore selection range outsie of date range
			if (endDate < rangeStart || startDate > rangeEnd)
				continue;
			
			// remove selection range inside of date range
			if (startDate <= rangeStart && endDate >= rangeEnd)
			{
				_selectedRanges[n] = null;
			}
			// split selection range if date range inside selection range
			else if (startDate > rangeStart && endDate < rangeEnd)
			{
				var temp:Date = _selectedRanges[n].rangeEnd;
				
				_selectedRanges[n].rangeEnd = addSubtractDays(startDate, -1);
				
				_selectedRanges[selectedRangeCount] = {};
				_selectedRanges[selectedRangeCount].rangeStart = addSubtractDays(endDate, +1);
				_selectedRanges[selectedRangeCount].rangeEnd = temp;
				
				selectedRangeCount++;
			}
			// remove day at start of range
			else if (endDate.time == rangeStart.time) {
				_selectedRanges[n].rangeStart = addSubtractDays(startDate, +1);	
			}
			// remove day at end of range
			else if (startDate.time == rangeEnd.time) {
				_selectedRanges[n].rangeEnd = addSubtractDays(endDate, -1);	
			}
			// move selection start date if end overlaps
			else if (endDate >= rangeStart)
			{
				_selectedRanges[n].rangeStart = addSubtractDays(endDate, +1);	
			}
			// move selection end date if start overlaps
			else if (startDate <= rangeEnd)
			{
				_selectedRanges[n].rangeEnd = addSubtractDays(startDate, -1);	
			}			
		}
		
		// clean up any removed selections
		for (n = selectedRangeCount -1; n >= 0; n--)
		{
			if (_selectedRanges[n] == null)
			{
				_selectedRanges.splice(n,1);
				selectedRangeCount--;
			}
		}
	}
	
	/**
	 *  @private
	 *  Removes a single date specified by singleDate from the selected dates.
	 */
	mx_internal function removeDayFromSelection(singleDate:Date):void
	{
		removeRangeFromSelection(singleDate, singleDate);
	}

    /**
     *  @private
     *  Updates the visible property of all the selected indicators.
     *  Called when a date range has been selected or deselected.
     */
    mx_internal function setSelectedIndicators():void
    {
        var offset:int = getOffsetOfMonth(displayedYear, displayedMonth);
        var daysInMonth:int = getNumberOfDaysInMonth(displayedYear, displayedMonth);

        var columnIndex:int; // 0 - 6
        var rowIndex:int; // 1 - 6
        var i:int;
        for (var dayNumber:int = 1; dayNumber <= daysInMonth; dayNumber++)
        {
            var cellDate:Date = new Date(displayedYear, displayedMonth, dayNumber);
            i = offset + dayNumber - 1;
            columnIndex = i % 7;
            rowIndex = 1 + Math.floor(i / 7);

            if (isSelected(cellDate) && disabledArrays[columnIndex][rowIndex] == false)
                addSelectionIndicator(columnIndex,rowIndex);
            else
                removeSelectionIndicator(columnIndex,rowIndex);
        }

        var today:Date = new Date();
        if (isSelected(today))
            todayIndicator.alpha = 1.0;
    }

    /**
     *  @private
     */
    mx_internal function addSelectionIndicator(columnIndex:int, rowIndex:int):void
    {
        if (!selectionIndicator[columnIndex][rowIndex])
        {

            var selectionIndicatorClass:Class =
                    getStyle("selectionIndicatorSkin");
            if (!selectionIndicatorClass)
                selectionIndicatorClass = DateChooserIndicator;
            selectionIndicator[columnIndex][rowIndex] =
                IFlexDisplayObject(new selectionIndicatorClass());
            
            if (isDateChooserIndicator(selectionIndicator[columnIndex][rowIndex]))
                Object(selectionIndicator[columnIndex][rowIndex]).indicatorColor =
                    "selectionColor";
            if (selectionIndicator[columnIndex][rowIndex] is ISimpleStyleClient)
                ISimpleStyleClient(selectionIndicator[columnIndex][rowIndex]).styleName = this;
            
            addChildAt(DisplayObject(selectionIndicator[columnIndex][rowIndex]), 0);

            var selCell:IUITextField = dayBlocksArray[columnIndex][rowIndex];
            selectionIndicator[columnIndex][rowIndex].move(selCell.x, selCell.y + yOffset);
            selectionIndicator[columnIndex][rowIndex].setActualSize(cellWidth, cellHeight);
        }
        selectionIndicator[columnIndex][rowIndex].visible = true;
    }

    /**
     *  @private
     */
    mx_internal function removeSelectionIndicator(columnIndex:int,
                                                  rowIndex:int):void
    {
        if (selectionIndicator[columnIndex][rowIndex])
        {
            removeChild(selectionIndicator[columnIndex][rowIndex]);
            selectionIndicator[columnIndex][rowIndex] = null;
        }
    }

    /**
     *  @private
     * 
     *  Removes the selection indicators from this component.
     */
    mx_internal function removeSelectionIndicators():void
    {
       for (var columnIndex:int = 0; columnIndex < 7; columnIndex++)
        {
            for (var rowIndex:int = 0; rowIndex < 7; rowIndex++)
            {
                removeSelectionIndicator(columnIndex, rowIndex);
            }
        }
    }

    //--------------------------------------------------------------------------
    //
    //  Overridden event handlers
    //
    //--------------------------------------------------------------------------

    /**
     *  @private
     */
    override protected function keyDownHandler(event:KeyboardEvent):void
    {
        /*
             PageUp: Previous Month
             PageDown: Next Month
        */

        var selChanged:Boolean = false;

        var date:int = lastSelectedDate ? lastSelectedDate.getDate() : 1;

        /*
        calculate Days to move will take the following values:

        1: Left
        2: Right
        3: Up
        4: Down
        5. Home
        6. End

        */

        var daysInMonth:int = getNumberOfDaysInMonth(displayedYear, displayedMonth);

        // If rtl layout, need to swap LEFT and RIGHT so correct action
        // is done.
        var keyCode:uint = mapKeycodeForLayoutDirection(event);
                
        for (var i:uint = 0; i < 31; i++)
        {
            if (keyCode == Keyboard.LEFT)
            {
                if (date > 1)
                {
                    date--;
                    selChanged = true;
                }
                else
                    return;
            }
    
            else if (keyCode == Keyboard.RIGHT)
            {
                if (date < daysInMonth)
                {
                    date++;
                    selChanged = true;
                }
                else
                    return;
            }
    
            else if (keyCode == Keyboard.UP)
            {
                if (date > 7)
                {
                    date -= 7;
                    selChanged = true;
                }
                else
                    return;
            }
    
            else if (keyCode == Keyboard.DOWN)
            {
                if (date + 7 <= daysInMonth)
                {
                    date += 7;
                    selChanged = true;
                }
                else
                    return;
            }
    
            else if (keyCode == Keyboard.HOME)
            {
                if (i == 0)
                    date = 1;
                else
                    date++;
                selChanged = true;
            }
    
            else if (keyCode == Keyboard.END)
            {
                if (i == 0)
                    date = daysInMonth;
                else
                    date--;
                selChanged = true;
            }
    
            else if (lastSelectedDate && event.shiftKey &&
                     (keyCode == Keyboard.PAGE_UP ||
                      keyCode == Keyboard.PAGE_DOWN))
            {
                selChanged = true;
            }
            
            else if (lastSelectedDate &&
                     (keyCode == 189 ||
                      keyCode == 187)) // for year - and +
            {
                selChanged = true;
            }
    
            if (keyCode >= Keyboard.PAGE_UP &&
                keyCode <= Keyboard.DOWN)
            {
                event.stopPropagation();
            }
    
            if (selChanged)
            {
                var newDate:Date = new Date(displayedYear, displayedMonth, date);
    
                if (checkDateIsDisabled(newDate) && !event.shiftKey)
                    continue;
    
                if (!(event.shiftKey && _allowMultipleSelection))
                    selectedRangeCount = 0;
    
                addToSelected(newDate, event.shiftKey && _allowMultipleSelection);
    
                setSelectedIndicators();
    
                dispatchChangeEvent(event);
                return;
            }
        }
    }

    //--------------------------------------------------------------------------
    //
    //  Event handlers
    //
    //--------------------------------------------------------------------------

    /**
     *  @private
     */
    private function mouseOverHandler(event:MouseEvent):void
    {
        if (event.relatedObject && event.relatedObject.parent != this)
            addEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
        else
            event.stopImmediatePropagation();
    }

    /**
     *  @private
     */
    private function mouseOutHandler(event:MouseEvent):void
    {
        if (event.relatedObject && event.relatedObject.parent != this)
        {

            removeEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
            rollOverIndicator.visible = false;


            // If todayColumn and todayRow exist and today is not disabled
            if (todayColumn != -1 && todayRow != -1 && !disabledArrays[todayColumn][todayRow])
            {
                var today:Date = new Date();
                if (!isSelected(today))
                    todayIndicator.alpha = 1.0;
            }
        }
        else
        {
            event.stopImmediatePropagation();
        }
    }

    /**
     *  @private
     */
    private function mouseMoveHandler(event:MouseEvent):void
    {
        var paddingLeft:Number = getStyle("paddingLeft");
        var paddingTop:Number = getStyle("paddingTop");

        var firstColX:Number = dayBlocksArray[0][0].x;
        var lastColX:Number = dayBlocksArray[6][0].x;
        var firstRowY:Number = dayBlocksArray[6][0].y + cellHeight;

        var mousePoint:Point = new Point(event.stageX, event.stageY);
        mousePoint = globalToLocal(mousePoint);
        var mouseY:Number = mousePoint.y;
        var mouseX:Number = mousePoint.x;

        if (mouseX < firstColX ||
            mouseX > lastColX + cellWidth ||
            mouseY < firstRowY)
            return;

        var rowIndex:int = Math.floor((mouseY-paddingTop) / cellHeight);
        var colIndex:int = Math.floor((mouseX-paddingLeft) / cellWidth);

        colIndex = Math.min(colIndex, 6);
        rowIndex = Math.min(rowIndex, 6);

        var selCell:IUITextField = dayBlocksArray[colIndex][rowIndex];

        // If it is disabled, we're done.
        if (disabledArrays[colIndex][rowIndex] || rowIndex == 0)
            return;

        if (mouseY >= selCell.y &&
            mouseY <= selCell.y + cellHeight &&
            mouseX >= selCell.x &&
            mouseX <= selCell.x + cellWidth)
        {
            rollOverIndicator.move(selCell.x, selCell.y + yOffset); // Don't trigger layout
            rollOverIndicator.visible = true;

            // Don't show rollover if we're over the selected date
            if (selectionIndicator[colIndex][rowIndex])
            {
                rollOverIndicator.visible = false;
            }

            // Set alpha only if today is not disabled
            if (todayColumn != -1 && todayRow != -1 && !disabledArrays[todayColumn][todayRow])
            {
                var today:Date = new Date();
                if (rollOverIndicator.x == todayIndicator.x &&
                    rollOverIndicator.y == todayIndicator.y)
                {
                    todayIndicator.alpha = 0.6;
                }
                else if (!isSelected(today))
                {
                    todayIndicator.alpha = 1.0;
                }
            }
        }
    }

    /**
     *  @private
     */
    private function mouseUpHandler(event:MouseEvent):void
    {
        var paddingLeft:Number = getStyle("paddingLeft");
        var paddingTop:Number = getStyle("paddingTop");

        var firstColX:Number = dayBlocksArray[0][0].x;
        var lastColX:Number = dayBlocksArray[6][0].x;
        var firstRowY:Number = dayBlocksArray[6][0].y + cellHeight;

        var mousePoint:Point = new Point(event.stageX, event.stageY);
        mousePoint = globalToLocal(mousePoint);
        var mouseY:Number = mousePoint.y;
        var mouseX:Number = mousePoint.x;

        if (mouseX < firstColX &&
            mouseX >= lastColX + cellWidth ||
            mouseY < firstRowY)
            return;

        var rowIndex:int = Math.floor((mouseY-paddingTop) / cellHeight);

        if (rowIndex <= 0)
            return;
        rowIndex = Math.min(rowIndex, 6);

        var colIndex:int = Math.floor((mouseX-paddingLeft) / cellWidth);
        colIndex = Math.min(colIndex, 6);
        
        var selCell:IUITextField = dayBlocksArray[colIndex][rowIndex];//this["dayBlock"+colIndex+"label"+rowIndex];
        // If it is disabled, we're done.
        if (disabledArrays[colIndex][rowIndex])
            return;

        if (mouseY >= selCell.y &&
            mouseY <= selCell.y + cellHeight &&
            mouseX >= selCell.x &&
            mouseX <= selCell.x + cellWidth)
        {
            var newDate:Date = new Date(displayedYear, displayedMonth, int(selCell.text));

            if (event.shiftKey && _allowMultipleSelection)
            {
                addToSelected(newDate,true);
                setSelectedIndicators();
            }
            else
            {
                var alreadySelected:Boolean = selectionIndicator[colIndex][rowIndex] ? true : false;

                if (event.ctrlKey && _allowMultipleSelection && _allowDisjointSelection)
                {
                    if (alreadySelected)
                    {
                        removeSelectionIndicator(colIndex, rowIndex);
                        removeDayFromSelection(newDate);
                    }
                    else
                    {
                        addSelectionIndicator(colIndex, rowIndex);
                        addToSelected(newDate);
                    }
                }
                else
                {
                    rangeStartDate = null;

                    if (alreadySelected)
                    {
                        if (selectedRangeCount > 1 || (selectedRangeCount == 1 && _selectedRanges[0].rangeStart != _selectedRanges[0].rangeEnd))
                        {
                            selectedRangeCount = 0;
                            addSelectionIndicator(colIndex,rowIndex);
                            addToSelected(newDate);
                            setSelectedIndicators();
                        }
                        else if (event.ctrlKey)
                        {
                            removeSelectionIndicator(colIndex, rowIndex);
                            removeDayFromSelection(newDate);
                        }
                    }
                    else
                    {
                        selectedRangeCount = 0;
                        addSelectionIndicator(colIndex, rowIndex);
                        addToSelected(newDate);
                        setSelectedIndicators();
                    }
                }
            }

            dispatchChangeEvent(event);

            if (todayColumn != -1 && todayRow != -1 && !disabledArrays[todayColumn][todayRow]) // Set alpha only if today is not disabled
            {
                var todaysDate:Date = new Date();
                todayIndicator.alpha  = isSelected(todaysDate) ? 0.6 : 1.0;
            }

            // Hide the rollover indicator if it is the selected cell
            if (selectionIndicator[colIndex][rowIndex])
                rollOverIndicator.visible = false;
        }
    }

    /**
     *  We don't use 'is' to prevent dependency issues
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    private static var dcis:Object = {};

    private static function isDateChooserIndicator(parent:Object):Boolean
    {
        var s:String = getQualifiedClassName(parent);
        if (dcis[s] == 1)
            return true;

        if (dcis[s] == 0)
            return false;

        if (s == "mx.skins.halo::DateChooserIndicator")
        {
            dcis[s] == 1;
            return true;
        }

        var x:XML = describeType(parent);
        var xmllist:XMLList = x.extendsClass.(@type == "mx.skins.halo::DateChooserIndicator");
        if (xmllist.length() == 0)
        {
            dcis[s] = 0;
            return false;
        }
        
        dcis[s] = 1;
        return true;
    }
}

}