//
// CalendarView (for Prototype)
// calendarview.org
//
// Maintained by Justin Mecham <justin@aspect.net>
//
// Portions Copyright 2002-2005 Mihai Bazon
//
// This calendar is based very loosely on the Dynarch Calendar in that it was
// used as a base, but completely gutted and more or less rewritten in place
// to use the Prototype JavaScript library.
//
// As such, CalendarView is licensed under the terms of the GNU Lesser General
// Public License (LGPL). More information on the Dynarch Calendar can be
// found at:
//
//   www.dynarch.com/projects/calendar
//

var lang = 'ru';
var image = '/_images/actions/calendar2.png';
var inputClassName = 'date_editable';
var showTime = false;


function c_isParent(child, parent) {
    if (!child || !parent) {
        return false;
    }
    while (true) {
        if (child == parent) {
            return true;
        }
        if (child.parentElement) {
            child = child.parentElement;
        } else if (child.parentNode) {
            child = child.parentNode;
        } else {
            return false;
        }
    }
}

var globalCalendar = null;
var Calendar = Class.create()
//------------------------------------------------------------------------------
// Constants
//------------------------------------------------------------------------------
Calendar.VERSION = '1.2'

Calendar.DAY_NAMES = new Array(
'Sunday', 'Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота',
'Воскресенье'
)

/*Calendar.SHORT_DAY_NAMES = new Array(
'пн', 'вт', 'ср', 'чт', 'пт', 'сб', 'вс'
)*/
var ru_days = new Array(
'Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб', 'Вс'
)
var en_days = new Array(
'mo', 'tu', 'we', 'th', 'fr', 'sa', 'su'
)
var ua_days = new Array(
'пн', 'вт', 'ср', 'чт', 'пт', 'сб', 'нд'
)
var all_days = new Array();
all_days['ru'] = ru_days;
all_days['en'] = en_days;
all_days['ua'] = ua_days;
Calendar.SHORT_DAY_NAMES = all_days;

var ru_months = new Array(
'Январь', 'Февраль', 'Март', 'Апрель', 'Май', 'Июнь', 'Июль', 'Август',
'Сентябрь', 'Октябрь', 'Ноябрь', 'Декабрь'
)
var en_months = new Array(
'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August',
'Seprember', 'October', 'November', 'December'
)
var ua_months = new Array(
'Січень', 'Лютий', 'Березень', 'Квітень', 'Травень', 'Червень', 'Липень', 'Серпень',
'Вересень', 'Жовтень', 'Листопад', 'Грудень'
)
var all_months = new Array();
all_months['ru'] = ru_months;
all_months['en'] = en_months;
all_months['ua'] = ua_months;
Calendar.MONTH_NAMES = all_months;

Calendar.SHORT_MONTH_NAMES = new Array(
'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov',
'Dec'
)

Calendar.NAV_PREVIOUS_YEAR  = -2
Calendar.NAV_PREVIOUS_MONTH = -1
Calendar.NAV_TODAY          =  0
Calendar.NAV_NEXT_MONTH     =  1
Calendar.NAV_NEXT_YEAR      =  2

//------------------------------------------------------------------------------
// Static Methods
//------------------------------------------------------------------------------
// This gets called when the user presses a mouse button anywhere in the
// document, if the calendar is shown. If the click was outside the open
// calendar this function closes it.
Calendar._checkCalendar = function(event) {
    if (!window._popupCalendar)
    return false
    if (Element.descendantOf(Event.element(event), window._popupCalendar.container))
    return
    window._popupCalendar.callCloseHandler()
    return Event.stop(event)
}

//------------------------------------------------------------------------------
// Event Handlers
//------------------------------------------------------------------------------

Calendar.handleMouseDownEvent = function(event)
{
    Event.observe(document, 'mouseup', Calendar.handleMouseUpEvent);
    //Event.stop(event);
}

// XXX I am not happy with how clicks of different actions are handled. Need to
// clean this up!
Calendar.handleMouseUpEvent = function(event)
{
    var el        = Event.element(event);
    var calendar  = el.calendar;
    var isNewDate = false;
    globalCalendar = calendar;

    // If the element that was clicked on does not have an associated Calendar
    // object, return as we have nothing to do.

    if (!calendar) {
        Event.stopObserving(document, 'mouseup', Calendar.handleMouseUpEvent);
        return false;
    }
    if (calendar == 'undefined') {
        Event.stopObserving(document, 'mouseup', Calendar.handleMouseUpEvent);
        return false;
    }

    // Clicked on a day
    if (typeof el.navAction == 'undefined'){
        if (calendar.currentDateElement) {
            if (calendar.datesCreated){
                viewConnectionsTime(el.date.print('%Y-%m-%d'));
            }

            //(calendar.currentDateElement.parentNode);
            Element.removeClassName(calendar.currentDateElement, 'selected');
            Element.removeClassName(calendar.currentDateElement.parentNode, 'selected_row');
            Element.addClassName(el, 'selected');
            Element.addClassName(el.parentNode, 'selected_row');
            calendar.shouldClose = (calendar.currentDateElement == el);
            if (!calendar.shouldClose) calendar.currentDateElement = el;
        }

        calendar.date.setDateOnly(el.date);
        isNewDate = true;
        calendar.shouldClose = !el.hasClassName('otherDay');
        var isOtherMonth     = !calendar.shouldClose;

        if (isOtherMonth) calendar.update(calendar.date);
        /*if (el.parentNode.hasClassName('selected_row')){
        Element.removeClassName(el.parentNode, 'selected_row');
        //Element.addClassName(el.parentNode, 'selected_row');
        }*/
    }

    // Clicked on an action button
    else
    {
        var date = new Date(calendar.date)
        if (el.navAction == Calendar.NAV_TODAY)
        date.setDateOnly(new Date())
        var year = date.getFullYear()
        var mon = date.getMonth()
        function setMonth(m) {
            var day = date.getDate()
            var max = date.getMonthDays(m)
            if (day > max) date.setDate(max)
            date.setMonth(m)
        }

        switch (el.navAction) {

            // Previous Year
            case Calendar.NAV_PREVIOUS_YEAR:
            if (year > calendar.minYear)
            date.setFullYear(year - 1)
            break
            // Previous Month
            case Calendar.NAV_PREVIOUS_MONTH:
            if (mon > 0) {
                setMonth(mon - 1)
            }
            else if (year-- > calendar.minYear) {
                date.setFullYear(year)
                setMonth(11)
            }
            break
            // Today
            case Calendar.NAV_TODAY:
            break
            // Next Month
            case Calendar.NAV_NEXT_MONTH:
            if (mon < 11) {
                setMonth(mon + 1)
            }
            else if (year < calendar.maxYear) {
                date.setFullYear(year + 1)
                setMonth(0)
            }
            break
            // Next Year
            case Calendar.NAV_NEXT_YEAR:
            if (year < calendar.maxYear)
            date.setFullYear(year + 1)
            break
        }

        if (!date.equalsTo(calendar.date)) {
            calendar.setDate(date)
            isNewDate = true
        } else if (el.navAction == 0) {
            isNewDate = (calendar.shouldClose = true)
        }
    }

    if (isNewDate) event && calendar.callSelectHandler();
    if (calendar.shouldClose) event && calendar.callCloseHandler();

    //Event.stopObserving(document, 'mouseup', Calendar.handleMouseUpEvent);

    return Event.stop(event);
}

Calendar.defaultSelectHandler = function(calendar) {
    if (!calendar.dateField) return false

    globalCalendar = calendar;

    // Update dateField value
    if (calendar.dateField.tagName == 'DIV')
    Element.update(calendar.dateField, calendar.date.print(calendar.dateFormat))
    else if (calendar.dateField.tagName == 'INPUT') {
        calendar.dateField.value = calendar.date.print(calendar.dateFormat) }

        // Trigger the onchange callback on the dateField, if one has been defined
        if (typeof calendar.dateField.onchange == 'function')
        calendar.dateField.onchange()

        // Call the close handler, if necessary
        if (calendar.shouldClose) calendar.callCloseHandler()
}

Calendar.defaultCloseHandler = function(calendar) {
    calendar.hide()
}


//------------------------------------------------------------------------------
// Calendar Setup
//------------------------------------------------------------------------------

Calendar.setup = function(params) {
    function param_default(name, def) {
        if (!params[name]) params[name] = def;
    }

    //alert(params.showTime);
    
    param_default('dateField', null)
    param_default('triggerElement', null)
    param_default('parentElement', null)
    param_default('selectHandler',  null)
    param_default('closeHandler', null)
    param_default('showPopup', null)
    //param_default('showTime', null)
    param_default('lang', null)

    param_default('datesCreated', null)
    param_default('datesNotCreated', null)
    param_default('datesExpired', null)
    
    this.showTime = params['showTime'];
    
    // In-Page Calendar
    if (params.parentElement) {
        var calendar = new Calendar(params.parentElement)
        calendar.datesCreated = params['datesCreated'];
        calendar.datesNotCreated = params['datesNotCreated'];
        calendar.datesExpired = params['datesExpired'];
        
        calendar.showTime = params['showTime'];
        calendar.lang = params['lang'];

        calendar.setSelectHandler(params.selectHandler || Calendar.defaultSelectHandler)
        if (params.dateFormat)
        calendar.setDateFormat(params.dateFormat)
        if (params.dateField) {
            calendar.setDateField(params.dateField)
            calendar.parseDate(calendar.dateField.innerHTML || calendar.dateField.value)
        }

        calendar.showTime = params['showTime'];
        calendar.showPopup = params['showPopup'];
        calendar.showTime = params['showTime'];
        calendar.show();

        return calendar
    }

    // Popup Calendars
    //
    // XXX There is significant optimization to be had here by creating the
    // calendar and storing it on the page, but then you will have issues with
    // multiple calendars on the same page.
    /*else
    {
    var triggerElement = $(params.triggerElement || params.dateField)
    triggerElement.onclick = function() {
    var calendar = new Calendar()
    calendar.setSelectHandler(params.selectHandler || Calendar.defaultSelectHandler)
    calendar.setCloseHandler(params.closeHandler || Calendar.defaultCloseHandler)
    if (params.dateFormat)
    calendar.setDateFormat(params.dateFormat)
    if (params.dateField) {
    calendar.setDateField(params.dateField)
    calendar.parseDate(calendar.dateField.innerHTML || calendar.dateField.value)
    }
    if (params.dateField)
    Date.parseDate(calendar.dateField.value || calendar.dateField.innerHTML, calendar.dateFormat)
    calendar.showAtElement(triggerElement)
    return calendar
    }
    }*/
}



//------------------------------------------------------------------------------
// Calendar Instance
//------------------------------------------------------------------------------

Calendar.prototype = {

    // The HTML Container Element
    container: null,

    // Callbacks
    selectHandler: null,
    closeHandler: null,

    // Configuration
    minYear: 1900,
    maxYear: 2100,
    dateFormat: '%Y-%m-%d',

    // Dates
    date: new Date(),
    currentDateElement: null,

    // Status
    shouldClose: false,
    isPopup: true,

    showPopup: false,

    dateField: null,

    datesCreated: null,
    datesNotCreated: null,
    datesExpired: null,
    showTime: null,
    lang: 'ru',


    //----------------------------------------------------------------------------
    // Initialize
    //----------------------------------------------------------------------------

    initialize: function(parent) {
        if (parent)
        this.create($(parent))
        else
        this.create()
    },



    //----------------------------------------------------------------------------
    // Update / (Re)initialize Calendar
    //----------------------------------------------------------------------------

    update: function(date) {
        var calendar   = this
        var today      = new Date()
        var thisYear   = today.getFullYear()
        var thisMonth  = today.getMonth()
        var thisDay    = today.getDate()
        var month      = date.getMonth();
        var dayOfMonth = date.getDate();

        var datesCreated = this.datesCreated;
        var datesNotCreated = this.datesNotCreated;
        var datesExpired = this.datesExpired;
        var lang = this.lang;

        var dateFormat = this.dateFormat;

        // Ensure date is within the defined range
        if (date.getFullYear() < this.minYear)
        date.setFullYear(this.minYear)
        else if (date.getFullYear() > this.maxYear)
        date.setFullYear(this.maxYear)

        this.date = new Date(date)

        // Calculate the first day to display (including the previous month)
        date.setDate(1);
        date.setDate(-(date.getDay()) + 2);

        // Fill in the days of the month
        Element.getElementsBySelector(this.container, 'tbody tr').each(
        function(row, i) {
            var rowHasDays = false;
            row.removeClassName('selected_row')
            row.immediateDescendants().each(
            function(cell, j) {
                var day            = date.getDate()
                var dayOfWeek      = date.getDay()
                var isCurrentMonth = (date.getMonth() == month)

                if (datesCreated){
                    var curDate = date.print('%Y-%m-%d');
                    var isDateCreated = false;
                    datesCreated.each(function(d){
                        if (d == curDate){
                            isDateCreated = true;
                        }
                    })

                    var isDateNotCreated = false;
                    datesNotCreated.each(function(d){
                        if (d == curDate){
                            isDateNotCreated = true;
                        }
                    })

                    var isDateExpired = false;
                    datesExpired.each(function(d){
                        if (d == curDate){
                            isDateExpired = true;
                        }
                    })
                }

                //row.removeClassName('selected_row');

                // Reset classes on the cell

                cell.className = ''
                cell.date = new Date(date)
                cell.update(day)

                // Account for days of the month other than the current month
                if (!isCurrentMonth){
                    cell.addClassName('otherDay');
                }
                else
                rowHasDays = true

                if (isDateCreated){
                    cell.addClassName('date_created');
                }

                if (isDateNotCreated){
                    cell.addClassName('date_notcreated');
                }

                if (isDateExpired){
                    cell.addClassName('date_expired');
                }

                // Ensure the current day is selected
                if (isCurrentMonth && day == dayOfMonth) {
                    cell.addClassName('selected')
                    row.addClassName('selected_row')
                    calendar.currentDateElement = cell
                }

                // Today
                if (date.getFullYear() == thisYear && date.getMonth() == thisMonth && day == thisDay)
                cell.addClassName('today')

                // Weekend
                if ([5, 6].indexOf(dayOfWeek) != -1)
                cell.addClassName('weekend')

                // Set the date to tommorrow
                date.setDate(day + 1)
            }
            )
            // Hide the extra row if it contains only days from another month
            !rowHasDays ? row.hide() : row.show()
        })


        if (calendar.showTime){

            /*var df = this.dateFormat;
            var showHour = df.indexOf('%H');
            var showMin = df.indexOf('%M');
            var showSec = df.indexOf('%S');*/

            var curHour = date.print('%H')*1;
            var curMin = date.print('%M')*1;
            var curSec = date.print('%S')*1;

            $('c_hours').options[curHour].selected = true;
            $('c_minutes').options[curMin].selected = true;
            $('c_seconds').options[curSec].selected = true;
        }

        /*this.container.getElementsBySelector('td.title')[0].update(
        Calendar.MONTH_NAMES[month] + ' ' + this.date.getFullYear()
        );*/



        var yearSpan = $('year_span');
        var monthSpan = $('month_span');
        if (yearSpan){
            yearSpan.update(this.date.getFullYear());
            monthSpan.update(Calendar.MONTH_NAMES[lang][month]);
        }

        /*document.getElementById('year_span').update(
        Calendar.MONTH_NAMES[month] + ' ' + this.date.getFullYear()
        )*/
    },


    _remove: function(){
        var cal = this;
        //Event.stopObserving(document, 'mouseup');
        if ($('datecalendar') && cal.showPopup) $('datecalendar').remove();
    },


    //----------------------------------------------------------------------------
    // Create/Draw the Calendar HTML Elements
    //----------------------------------------------------------------------------

    create: function(parent)
    {
    	
        var p = parent.parentNode || parent.parent;

        if (p && (p.id == 'datecalendar')) this.showTime = true;

        // If no parent was specified, assume that we are creating a popup calendar.
        if (!parent) {
            parent = document.getElementsByTagName('body')[0]
            this.isPopup = true
        } else {
            this.isPopup = false
        }

        // Calendar Table
        var table = new Element('table');
        table.addClassName('tbldates');

        // Calendar Header
        var thead = new Element('thead')
        table.appendChild(thead);

        var dayA = new Element('a');

        /*alert(this.lang);
        alert(Calendar.lang);*/

        // Day Names
        row = new Element('tr')
        for (var i = 0; i < 7; ++i) {
            cell = new Element('td').update(Calendar.SHORT_DAY_NAMES[lang][i])
            cell.addClassName('c_day_name');
            if (i == 5 || i == 6)
            cell.addClassName('weekend');
            row.appendChild(cell);
        }
        thead.appendChild(row)

        // Calendar Days
        var tbody = table.appendChild(new Element('tbody'))
        for (i = 6; i > 0; --i) {
            row = tbody.appendChild(new Element('tr'))
            row.addClassName('days')
            for (var j = 7; j > 0; --j) {
                var td1 = new Element('td');
                /*var da = new Element('a');
                da.href = '#';
                td1.appendChild(da);*/
                //td1.innerHTML = '<a href="">q</a>';
                cell = row.appendChild(td1)
                cell.calendar = this
            }
        }

        // Calendar Container (div)
        this.container = new Element('div')
        //this.container.addClassName('calendar')
        if (this.isPopup) {
            this.container.setStyle({ position: 'absolute', display: 'none' })
            this.container.addClassName('popup')
        }

        /*<b><a href="#">«</a> 2009 <a href="#">»</a></b>
        <p><a class="mr" href="#"></a> <a class="ml" href="#"></a>Февраль</p>*/

        var aLeft = new Element('a');
        aLeft.href = '';
        aLeft.addClassName('year_left_link');
        aLeft.onclick = function(){return false};
        aLeft.calendar = this;
        aLeft.navAction = Calendar.NAV_PREVIOUS_YEAR;
        aLeft.innerHTML = '&nbsp;';

        var aRight = new Element('a');
        aRight.href = '';
        aRight.addClassName('year_right_link');
        aRight.onclick = function(){return false};
        aRight.calendar = this;
        aRight.navAction = Calendar.NAV_NEXT_YEAR;
        aRight.innerHTML = '&nbsp;';

        var sYear = new Element('span');
        sYear.id = 'year_span';
        sYear.update(this.date.getFullYear());

        var aml = new Element('a');
        aml.addClassName("ml");
        aml.href = '';
        aml.innerHTML = '&nbsp;';
        aml.calendar = this;
        aml.onclick = function(){return false};
        aml.navAction = Calendar.NAV_PREVIOUS_MONTH;

        var amr = new Element('a');
        amr.addClassName("mr");
        amr.href = '';
        amr.innerHTML = '&nbsp;';
        amr.calendar = this;
        amr.onclick = function(){return false};
        amr.navAction = Calendar.NAV_NEXT_MONTH;

        var mspan = new Element('span');
        mspan.id = 'month_span';

        var date = new Date();
        mspan.update(Calendar.MONTH_NAMES[lang][date.getMonth()]);

        //p.update('<a class="mr" href="#"></a> <a class="ml" href="#"></a>Февраль');

        var b =  new Element('b');
        b.appendChild(aLeft);
        b.appendChild(sYear);
        b.appendChild(aRight);
        //b.appendChild(p);

        var p = new Element('p');
        p.appendChild(aml);
        p.appendChild(amr);
        p.appendChild(mspan);

        //b.update(a + this.date.getFullYear());
        this.container.appendChild(b);
        this.container.appendChild(p);
        this.container.appendChild(table);

        //alert(this.showTime);
        
        if (showTime){
            var timeDiv = new Element('div');
            c = this;
            var curHour = this.date.print('%H');
            var hourCbb = new Element('select');
            hourCbb.style.width = '55px';
            //hourCbb.style.width = '82px';
            hourCbb.id = 'c_hours';
            for (var i = 0; i < 24; i++){
                hourOpt = new Element('option');
                /*if (i == curHour) {
                hourOpt.selected = true;
                }*/
                hourOpt.innerHTML = i;
                hourCbb.appendChild(hourOpt);
            }

            timeDiv.appendChild(hourCbb);
            Event.observe(hourCbb, 'change', function(){
                c.date.setHours($F(hourCbb.id));
                c.dateField.value = c.date.print(c.dateFormat);
            });

            var curMin = this.date.print('%M');
            var minCbb = new Element('select');
            minCbb.style.width = '55px';
            //minCbb.style.width = '82px';
            minCbb.id = 'c_minutes';
            for (var i = 0; i < 60; i++){
                minOpt = new Element('option');
                /*if (i == curMin) {
                minOpt.selected = true;
                }*/
                minOpt.innerHTML = i;
                minCbb.appendChild(minOpt);
            }
            timeDiv.appendChild(minCbb);
            Event.observe(minCbb, 'change', function(){
                c.date.setMinutes($F(minCbb.id));
                c.dateField.value = c.date.print(c.dateFormat);
            });

            var curSec = this.date.print('%S');

            var secCbb = new Element('select');
            secCbb.style.width = '55px';
            secCbb.id = 'c_seconds';
            for (var i = 0; i < 60; i++){
                secOpt = new Element('option');
                secOpt.innerHTML = i;
                secCbb.appendChild(secOpt);
            }
            timeDiv.appendChild(secCbb);
            Event.observe(secCbb, 'change', function(){
                c.date.setSeconds($F(secCbb.id));
                c.dateField.value = c.date.print(c.dateFormat);
            });

            this.container.appendChild(timeDiv);
        }

        // Observe the container for mousedown events
        Event.observe(this.container, 'mousedown', Calendar.handleMouseDownEvent);

        var calObj = this;
        Event.observe(document, 'mouseup', function(event){
            var el        = Event.element(event);
            var calendar  = el.calendar;

            var cal = $('datecalendar');
            if(!c_isParent(el, cal)) {
                calObj._remove();
            }
        });

        /*Event.observe(window, 'click', function(){
        if ($('datecalendar')) $('datecalendar').remove();
        });*/
        Event.observe(this.container, 'click', function(event){
            var el        = Event.element(event);
            var calendar  = el.calendar;
            if (calendar && (typeof el.navAction == 'undefined')){
                calObj._remove();
            }
        });

        // Append to parent element
        parent.appendChild(this.container)
    },

    _drawButtonCell: function(parent, text, colSpan, navAction)
    {
        var cell          = new Element('td')
        if (colSpan > 1) cell.colSpan = colSpan
        cell.className    = 'button'
        cell.calendar     = this
        cell.navAction    = navAction
        cell.innerHTML    = text
        cell.unselectable = 'on' // IE
        parent.appendChild(cell)

        return cell
    },


    //------------------------------------------------------------------------------
    // Callbacks
    //------------------------------------------------------------------------------

    // Calls the Select Handler (if defined)
    callSelectHandler: function()
    {
        if (this.selectHandler)
        this.selectHandler(this, this.date.print(this.dateFormat))
    },

    // Calls the Close Handler (if defined)
    callCloseHandler: function()
    {
        if (this.closeHandler)
        this.closeHandler(this)
    },


    //------------------------------------------------------------------------------
    // Calendar Display Functions
    //------------------------------------------------------------------------------

    // Shows the Calendar
    show: function()
    {
        this.container.show()
        if (this.isPopup) {
            window._popupCalendar = this
            Event.observe(document, 'mousedown', Calendar._checkCalendar)
        }
    },

    // Shows the calendar at the given absolute position
    showAt: function (x, y)
    {
        this.container.setStyle({ left: x + 'px', top: y + 'px' })
        this.show()
    },

    // Shows the Calendar at the coordinates of the provided element
    showAtElement: function(element)
    {
        var pos = Position.cumulativeOffset(element)
        this.showAt(pos[0], pos[1])
    },

    // Hides the Calendar
    hide: function()
    {
        if (this.isPopup)
        Event.stopObserving(document, 'mousedown', Calendar._checkCalendar)
        this.container.hide()
    },



    //------------------------------------------------------------------------------
    // Miscellaneous
    //------------------------------------------------------------------------------

    // Tries to identify the date represented in a string.  If successful it also
    // calls this.setDate which moves the calendar to the given date.
    parseDate: function(str, format)
    {
        if (!format)
        format = this.dateFormat
        this.setDate(Date.parseDate(str, format))
    },



    //------------------------------------------------------------------------------
    // Getters/Setters
    //------------------------------------------------------------------------------

    setSelectHandler: function(selectHandler)
    {
        this.selectHandler = selectHandler
    },

    setCloseHandler: function(closeHandler)
    {
        this.closeHandler = closeHandler
    },

    setDate: function(date)
    {
        //if (!date.equalsTo(this.date))
        this.update(date)
    },

    setDateFormat: function(format)
    {
        this.dateFormat = format
    },

    setDateField: function(field)
    {
        this.dateField = $(field)
    },

    setRange: function(minYear, maxYear)
    {
        this.minYear = minYear
        this.maxYear = maxYear
    }

}

// global object that remembers the calendar
window._popupCalendar = null





























//==============================================================================
//
// Date Object Patches
//
// This is pretty much untouched from the original. I really would like to get
// rid of these patches if at all possible and find a cleaner way of
// accomplishing the same things. It's a shame Prototype doesn't extend Date at
// all.
//
//==============================================================================

Date.DAYS_IN_MONTH = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
Date.SECOND        = 1000 /* milliseconds */
Date.MINUTE        = 60 * Date.SECOND
Date.HOUR          = 60 * Date.MINUTE
Date.DAY           = 24 * Date.HOUR
Date.WEEK          =  7 * Date.DAY

// Parses Date
Date.parseDate = function(str, fmt) {

    var today = new Date();
    var y     = 0;
    var m     = -1;
    var d     = 0;
    var a     = str.split(/\W+/);
    var b     = fmt.match(/%./g);
    var i     = 0, j = 0;
    var hr    = 0;
    var min   = 0;
    var sec   = 0;

    for (i = 0; i < a.length; ++i) {
        if (!a[i]) continue;
        switch (b[i]) {
            case "%d":
            case "%e":
            d = parseInt(a[i], 10);
            break;
            case "%m":
            m = parseInt(a[i], 10) - 1;
            break;
            case "%Y":
            case "%y":
            y = parseInt(a[i], 10);
            (y < 100) && (y += (y > 29) ? 1900 : 2000);
            break;
            case "%b":
            case "%B":
            for (j = 0; j < 12; ++j) {
                if (Calendar.MONTH_NAMES[lang][j].substr(0, a[i].length).toLowerCase() == a[i].toLowerCase()) {
                    m = j;
                    break;
                }
            }
            break;
            case "%H":
            case "%I":
            case "%k":
            case "%l":
            hr = parseInt(a[i], 10);
            break;
            case "%P":
            case "%p":
            if (/pm/i.test(a[i]) && hr < 12)
            hr += 12;
            else if (/am/i.test(a[i]) && hr >= 12)
            hr -= 12;
            break;
            case "%M":
            min = parseInt(a[i], 10);
            break;
        }
    }

    sec = a[5];

    if (isNaN(y)) y = today.getFullYear();
    if (isNaN(m)) m = today.getMonth();
    if (isNaN(d)) d = today.getDate();
    if (isNaN(hr)) hr = today.getHours();
    if (isNaN(min)) min = today.getMinutes();
    if (isNaN(sec)) sec = today.getSeconds();
    if (y != 0 && m != -1 && d != 0)
    return new Date(y, m, d, hr, min, sec);
    y = 0; m = -1; d = 0;
    for (i = 0; i < a.length; ++i) {
        if (a[i].search(/[a-zA-Z]+/) != -1) {
            var t = -1;
            for (j = 0; j < 12; ++j) {
                if (Calendar.MONTH_NAMES[lang][j].substr(0, a[i].length).toLowerCase() == a[i].toLowerCase()) { t = j; break; }
            }
            if (t != -1) {
                if (m != -1) {
                    d = m+1;
                }
                m = t;
            }
        } else if (parseInt(a[i], 10) <= 12 && m == -1) {
            m = a[i]-1;
        } else if (parseInt(a[i], 10) > 31 && y == 0) {
            y = parseInt(a[i], 10);
            (y < 100) && (y += (y > 29) ? 1900 : 2000);
        } else if (d == 0) {
            d = a[i];
        }
    }
    if (y == 0)
    y = today.getFullYear();

    if (m != -1 && d != 0)
    return new Date(y, m, d, hr, min, sec);
    return today;
};

// Returns the number of days in the current month
Date.prototype.getMonthDays = function(month) {
    var year = this.getFullYear()
    if (typeof month == "undefined")
    month = this.getMonth()
    if (((0 == (year % 4)) && ( (0 != (year % 100)) || (0 == (year % 400)))) && month == 1)
    return 29
    else
    return Date.DAYS_IN_MONTH[month]
};

// Returns the number of day in the year
Date.prototype.getDayOfYear = function() {
    var now = new Date(this.getFullYear(), this.getMonth(), this.getDate(), 0, 0, 0);
    var then = new Date(this.getFullYear(), 0, 0, 0, 0, 0);
    var time = now - then;
    return Math.floor(time / Date.DAY);
};

/** Returns the number of the week in year, as defined in ISO 8601. */
Date.prototype.getWeekNumber = function() {
    var d = new Date(this.getFullYear(), this.getMonth(), this.getDate(), 0, 0, 0);
    var DoW = d.getDay();
    d.setDate(d.getDate() - (DoW + 6) % 7 + 3); // Nearest Thu
    var ms = d.valueOf(); // GMT
    d.setMonth(0);
    d.setDate(4); // Thu in Week 1
    return Math.round((ms - d.valueOf()) / (7 * 864e5)) + 1;
};

/** Checks date and time equality */
Date.prototype.equalsTo = function(date) {
    return ((this.getFullYear() == date.getFullYear()) &&
    (this.getMonth() == date.getMonth()) &&
    (this.getDate() == date.getDate()) &&
    (this.getHours() == date.getHours()) &&
    (this.getMinutes() == date.getMinutes()));
};

/** Set only the year, month, date parts (keep existing time) */
Date.prototype.setDateOnly = function(date) {
    var tmp = new Date(date);
    this.setDate(1);
    this.setFullYear(tmp.getFullYear());
    this.setMonth(tmp.getMonth());
    this.setDate(tmp.getDate());
};

/** Set only the year, month, date parts (keep existing time) */
Date.prototype.setDateTime = function(date) {
    var tmp = new Date(date);
    this.setDate(1);
    this.setFullYear(tmp.getFullYear());
    this.setMonth(tmp.getMonth());
    this.setDate(tmp.getDate());
};

/** Prints the date in a string according to the given format. */
Date.prototype.print = function (str) {
    var m = this.getMonth();
    var d = this.getDate();
    var y = this.getFullYear();
    var wn = this.getWeekNumber();
    var w = this.getDay();
    var s = {};
    var hr = this.getHours();
    var pm = (hr >= 12);
    var ir = (pm) ? (hr - 12) : hr;
    var dy = this.getDayOfYear();
    if (ir == 0)
    ir = 12;
    var min = this.getMinutes();
    var sec = this.getSeconds();
    s["%a"] = Calendar.SHORT_DAY_NAMES[lang][w]; // abbreviated weekday name [FIXME: I18N]
    s["%A"] = Calendar.DAY_NAMES[w]; // full weekday name
    s["%b"] = Calendar.SHORT_MONTH_NAMES[m]; // abbreviated month name [FIXME: I18N]
    s["%B"] = Calendar.MONTH_NAMES[lang][m]; // full month name
    // FIXME: %c : preferred date and time representation for the current locale
    s["%C"] = 1 + Math.floor(y / 100); // the century number
    s["%d"] = (d < 10) ? ("0" + d) : d; // the day of the month (range 01 to 31)
    s["%e"] = d; // the day of the month (range 1 to 31)
    // FIXME: %D : american date style: %m/%d/%y
    // FIXME: %E, %F, %G, %g, %h (man strftime)
    s["%H"] = (hr < 10) ? ("0" + hr) : hr; // hour, range 00 to 23 (24h format)
    s["%I"] = (ir < 10) ? ("0" + ir) : ir; // hour, range 01 to 12 (12h format)
    s["%j"] = (dy < 100) ? ((dy < 10) ? ("00" + dy) : ("0" + dy)) : dy; // day of the year (range 001 to 366)
    s["%k"] = hr;   // hour, range 0 to 23 (24h format)
    s["%l"] = ir;   // hour, range 1 to 12 (12h format)
    s["%m"] = (m < 9) ? ("0" + (1+m)) : (1+m); // month, range 01 to 12
    s["%M"] = (min < 10) ? ("0" + min) : min; // minute, range 00 to 59
    s["%n"] = "\n";   // a newline character
    s["%p"] = pm ? "PM" : "AM";
    s["%P"] = pm ? "pm" : "am";
    // FIXME: %r : the time in am/pm notation %I:%M:%S %p
    // FIXME: %R : the time in 24-hour notation %H:%M
    s["%s"] = Math.floor(this.getTime() / 1000);
    s["%S"] = (sec < 10) ? ("0" + sec) : sec; // seconds, range 00 to 59
    s["%t"] = "\t";   // a tab character
    // FIXME: %T : the time in 24-hour notation (%H:%M:%S)
    s["%U"] = s["%W"] = s["%V"] = (wn < 10) ? ("0" + wn) : wn;
    s["%u"] = w + 1;  // the day of the week (range 1 to 7, 1 = MON)
    s["%w"] = w;    // the day of the week (range 0 to 6, 0 = SUN)
    // FIXME: %x : preferred date representation for the current locale without the time
    // FIXME: %X : preferred time representation for the current locale without the date
    s["%y"] = ('' + y).substr(2, 2); // year without the century (range 00 to 99)
    s["%Y"] = y;    // year with the century
    s["%%"] = "%";    // a literal '%' character

    return str.gsub(/%./, function(match) { return s[match] || match });
};

Date.prototype.__msh_oldSetFullYear = Date.prototype.setFullYear;
Date.prototype.setFullYear = function(y) {
    var d = new Date(this);
    d.__msh_oldSetFullYear(y);
    if (d.getMonth() != this.getMonth())
    this.setDate(28);
    this.__msh_oldSetFullYear(y);
}

function c_getWindowSize(){
    var y = 0;
    if (self.pageYOffset) {
        yScroll = self.pageYOffset;
    } else if (document.documentElement && document.documentElement.scrollTop) {
        // Explorer 6 Strict
        yScroll = document.documentElement.scrollTop;
    } else if (document.body) {
        // all other Explorers
        yScroll = document.body.scrollTop;
    }
    y += yScroll;
    var windowWidth, windowHeight;
    if (self.innerHeight) {
        // all except Explorer
        windowWidth = self.innerWidth;
        windowHeight = self.innerHeight;
        if (yScroll > windowHeight)	windowWidth -= 16;
    } else if (document.documentElement && document.documentElement.clientHeight)	{
        // Explorer 6 Strict Mode
        windowWidth = document.documentElement.clientWidth;
        windowHeight = document.documentElement.clientHeight;
    } else if (document.body) {
        // other Explorers
        windowWidth = document.body.clientWidth;
        windowHeight = document.body.clientHeight;
    }
    var a = new Array();
    a['windWidth'] = windowWidth;
    a['windHeight'] = windowHeight;
    a['yScroll'] = yScroll;
    a['allHeight'] = windowHeight + yScroll;
    return a;
}

function c_centeredMessage(mesIdName){
    var messDiv = $(mesIdName);
    var ws = c_getWindowSize();
    var windowWidth = ws.windWidth;
    var windowHeight = ws.windHeight;
    var yScroll = ws.yScroll;
    var alertWidth = messDiv.getWidth();
    var alertHeight = messDiv.getHeight();
    var heightCenter = (windowHeight - alertHeight) / 2 + yScroll - 5;
    var widthCenter = (windowWidth - alertWidth) / 2;
    messDiv.style.top = heightCenter+'px';
    messDiv.style.left = widthCenter+'px';
}

function positionUnderField(dateFieldName, calDiv){
	var dateField = $(dateFieldName);
	var fieldWidth = dateField.getWidth();
	var fieldHeight = dateField.getHeight();
	var fieldOffset = Position.cumulativeOffset(dateField);
	var leftPos = fieldOffset.left;
	var topPos = fieldOffset.top + fieldHeight;
	calDiv.style.top = topPos+'px';
	calDiv.style.left = leftPos+'px';
}


function showCalendar(dateFieldName){
	
    if ($('datecalendar')) {
        $('datecalendar').remove();
    }
    calBody = '<div id="calendar" class="lc_b"></div>';

    var calDiv = document.createElement("div");
    calDiv.id = "datecalendar";
    calDiv.style.display = "none";
    calDiv.className ="mess_calendar_popup";
    calDiv.innerHTML = calBody;
    document.body.appendChild(calDiv);

    Calendar.setup({
        dateField: dateFieldName,
        showPopup: true,
        showTime: false,
        lang: lang,
        parentElement : 'calendar',
        dateFormat: '%Y-%m-%d'
    })
    //c_centeredMessage(calDiv);

    positionUnderField(dateFieldName, calDiv);
    $('datecalendar').appear({duration: 0.4});
    //new Draggable('datecalendar', {starteffect: null, reverteffect: null, endeffect: null, scrollSensitivity:null});
}

/*Event.observe(window, 'load', function(){
    $$('input.'+inputClassName).each(function(e, i){
        if (!e.id) e.id = 'f_'+i;
        e.insert({after: '<a href="" onclick="showCalendar(\''+e.id+'\', this); return false;"><img class="date_img" src="'+image+'" alt="" height="16" width="16"></a>'});
    });
})*/