//
// CalendarView (for jQuery, originally for Prototype)
//
// Copyright 2007-2008 Singlesnet, Inc.
// Copyright 2002-2005 Mihai Bazon
// Copyright 2008-2015 Thebing Services GmbH
//
// Maintained by Justin Mecham <justin@corp.singlesnet.com>
//
// 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
//

(function($__) {

var Calendar = function(parent, params) {
	this.setParams(params);
	if(parent) {
		this.create($__(parent));
	} else {
		this.create();
	}
};

Calendar.VERSION = '1.1'

Calendar.DAY_NAMES = new Array(
  'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday',
  'Sunday'
)

Calendar.ACTIVE_DAYS;

Calendar.FIRST_DAY;

Calendar.LAST_DAY;

Calendar.SHORT_DAY_NAMES = new Array(
  'S', 'M', 'T', 'W', 'T', 'F', 'S', 'S'
)

Calendar.MONTH_NAMES = new Array(
  'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August',
  'September', 'October', 'November', 'December'
)

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
Calendar.TODAY				= 'Today';

//------------------------------------------------------------------------------
// Prpepare the output
//------------------------------------------------------------------------------

Calendar.prepare = function(aParams)
{
	Calendar.prepareCallback(oCalendarResponse, aParams);
}

Calendar.prepareCallback = function(oResponse, aParams)
{
	if(oResponse.responseText && oResponse.responseText != '')
	{
		var oData = oResponse.responseText.evalJSON();
	}
	else
	{
		var oData = oResponse;
	}

	var aData = oData;

	if(aData['sFirstDay']) {
		aData['sFirstDay']	= Date.parseDate(aData['sFirstDay'], aData['sFormat']);
	}
	if(aData['sLastDay']) {
		aData['sLastDay']	= Date.parseDate(aData['sLastDay'], aData['sFormat']);
	}

	Calendar.TODAY = aData['sToday'];

	Calendar.setup({
		dateField     	: aParams['dateField'],
		triggerElement	: aParams['triggerElement'],
		parentElement	: aParams['parentElement'],
		selectHandler	: eval(aParams['selectHandler']),
		closeHandler	: eval(aParams['closeHandler']),
		dateFormat		: aData['sFormat'],
		dayNames		: aData['aDays'],
		shortDayNames	: aData['aDaysShort'],
		monthNames		: aData['aMonths'],
		shortMonthNames	: aData['aMonthsShort'],
		today			: aData['sToday'],
		activeDays		: aData['aActiveDays'],
		firstDay		: aData['sFirstDay'],
		lastDay			: aData['sLastDay'],
		// External Closehandler
		extcloseHandler : aParams['extcloseHandler']
	});

}

//------------------------------------------------------------------------------
// 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($__.contains(window._popupCalendar.container, event.target)) {
	//	return;
	//}

  window._popupCalendar.callCloseHandler()
  return event.stopPropagation()
}

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

Calendar.handleMouseDownEvent = function(event)
{
	$__(document).mouseup(Calendar.handleMouseUpEvent);
	event.stopPropagation();
}

// 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.target);
  var calendar  = el.get(0).calendar
  var isNewDate = false

  // If the element that was clicked on does not have an associated Calendar
  // object, return as we have nothing to do.
  if (!calendar) return false

  // Clicked on a day
  if (typeof el.get(0).navAction == 'undefined')
  {

    if(el.hasClass('inactive')) {
    	return false;
    }

	if (calendar.currentDateElement) {
		$__(calendar.currentDateElement).removeClass('selected');
		el.addClass('selected');
      calendar.shouldClose = (calendar.currentDateElement == el.get(0))
      if (!calendar.shouldClose) calendar.currentDateElement = el.get(0)
    }
    calendar.date.setDateOnly(el.get(0).date)
    isNewDate = true
    calendar.shouldClose = !el.hasClass('otherDay')
    var isOtherMonth     = !calendar.shouldClose
    if (isOtherMonth) calendar.update(calendar.date)
  }

  // Clicked on an action button
  else
  {
    var date = new Date(calendar.date)

    if (el.get(0).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.get(0).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

    }

    var dateFirst = new Date(date);
    dateFirst.setDate(1);
    var dateLast = new Date(date);
    dateLast.setDate(dateLast.getMonthDays());

    if(
    	calendar.firstDay &&
    	dateLast.compare(calendar.firstDay) == -1
    ) {
    	return false;
    } else if(
    		calendar.lastDay &&
    	dateFirst.compare(calendar.lastDay) == 1
    ) {
    	return false;
    }

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

  }

  if (isNewDate) event && calendar.callSelectHandler()

	$__(document).off('mouseup', Calendar.handleMouseUpEvent);

  return event.stopPropagation();
}

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

  // Update dateField value
  if(calendar.dateField.prop('tagName') == 'DIV') {
	  calendar.dateField.html(calendar.date.print(calendar.dateFormat));
  } else if(calendar.dateField.prop('tagName') == 'INPUT') {
	  calendar.dateField.val(calendar.date.print(calendar.dateFormat));
  }

  // Trigger the onchange callback on the dateField, if one has been defined
  calendar.dateField.change();

  // 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
  }

  param_default('dateField', null)
  param_default('triggerElement', null)
  param_default('parentElement', null)
  param_default('selectHandler',  null)
  param_default('closeHandler', null)
  param_default('extcloseHandler', null)

  // In-Page Calendar
  if (params.parentElement)
  {
    var calendar = new Calendar(params.parentElement, params)
    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.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)
	  if(triggerElement.length){
		  triggerElement.click(function() {
			  var calendar = new Calendar(false, params)
			  calendar.setSelectHandler(params.selectHandler || Calendar.defaultSelectHandler)

			  calendar.setCloseHandler(params.closeHandler || Calendar.defaultCloseHandler)

			  calendar.setExtCloseHandler(params.extcloseHandler);

			  if (params.dateFormat)
				calendar.setDateFormat(params.dateFormat)
			  if (params.dateField) {
				calendar.setDateField(params.dateField)
				calendar.parseDate(calendar.dateField.html() || calendar.dateField.val())
			  }
			  if (params.dateField)
				Date.parseDate(calendar.dateField.val() || calendar.dateField.html(), calendar.dateFormat)

			  //var aOffset = calendar.dateField.cumulativeOffset();
			  //var iHeight = calendar.dateField.getHeight();

			  calendar.showAtElement(calendar.dateField)
			  return calendar
		  });
	}
  }
}

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

var sFormat = '%Y-%m-%d';

Calendar.prototype = {

  // The HTML Container Element
  container: null,

  // Callbacks
  selectHandler: null,
  closeHandler: null,

  // Configuration
  minYear: 1900,
  maxYear: 2100,
  dateFormat: sFormat,

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

  // Status
  shouldClose: false,
  isPopup: true,

  dateField: null,

  dayNames: null,
  shortDayNames: null,
  monthNames: null,
  shortMonthNames: null,
  today: null,
  activeDays: null,
  firstDay: null,
  lastDay: null,

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

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

  setParams: function(oParams) {

	  this.dayNames			= oParams['dayNames'];
	  this.shortDayNames	= oParams['shortDayNames'];
	  this.monthNames		= oParams['monthNames'];
	  this.shortMonthNames	= oParams['shortMonthNames'];
	  this.today			= oParams['today'];
	  this.activeDays		= oParams['activeDays'];
	  this.firstDay			= oParams['firstDay'];
	  this.lastDay 			= oParams['lastDay'];

  },


  //----------------------------------------------------------------------------
  // 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()

    // 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)

    if(
    	calendar.firstDay &&
    	date.compare(calendar.firstDay) == -1
    ) {
    	date = new Date(calendar.firstDay);
    } else if(
    	calendar.lastDay &&
   		date.compare(calendar.lastDay) == 1
    ) {
    	date = new Date(calendar.lastDay);
    }

    var month      = date.getMonth();
    var dayOfMonth = date.getDate();

    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
    this.container.find('tbody tr').each(
    	function(i, row) {
			row = $__(row);

    	var rowHasDays = false
        row.children().each(
          function(j, cell) {
			  cell = $__(cell);

        	var day            = date.getDate()
            var dayOfWeek      = date.getDay()
            var isCurrentMonth = (date.getMonth() == month)

            // Reset classes on the cell
            cell.removeClass();
            cell.get(0).date = new Date(date)
            cell.html(day);

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

            // Ensure the current day is selected
            if (isCurrentMonth && day == dayOfMonth) {
              cell.addClass('selected');
              calendar.currentDateElement = cell.get(0)
            }

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

            // Weekend
            if ([0, 6].indexOf(dayOfWeek) != -1)
              cell.addClass('weekend');

            // Inactive day
            if(
            	calendar.activeDays.indexOf(dayOfWeek) == -1
            ) {
            	cell.addClass('inactive');
            } else if(
            	calendar.firstDay &&
            	date.compare(calendar.firstDay) == -1
            ) {
            	cell.addClass('inactive');
            } else if(
            	calendar.lastDay &&
           		date.compare(calendar.lastDay) == 1
            ) {
            	cell.addClass('inactive');
            }

            // 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(this.container.find('td.title').get(0))
	{
		this.container.find('td.title').get(0).innerHTML = this.monthNames[month] + ' ' + this.date.getFullYear();

	}

  },



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

  create: function(parent)
  {

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

    // Calendar Table
    var table = document.createElement('table');

    // Calendar Header
    var thead = document.createElement('thead');
    table.appendChild(thead)

    // Title Placeholder
    var row  = document.createElement('tr');
    var cell = document.createElement('td');
    cell.colSpan = 7;
    cell.className = 'title';
    row.appendChild(cell)
    thead.appendChild(row)

    // Calendar Navigation
    row = document.createElement('tr')
    this._drawButtonCell(row, '&#x00ab;', 1, Calendar.NAV_PREVIOUS_YEAR)
    this._drawButtonCell(row, '&#x2039;', 1, Calendar.NAV_PREVIOUS_MONTH)
    this._drawButtonCell(row, Calendar.TODAY,    3, Calendar.NAV_TODAY)
    this._drawButtonCell(row, '&#x203a;', 1, Calendar.NAV_NEXT_MONTH)
    this._drawButtonCell(row, '&#x00bb;', 1, Calendar.NAV_NEXT_YEAR)
    thead.appendChild(row)

    // Day Names
    row = document.createElement('tr')
//    for (var i = 0; i < 7; ++i) {
	for (var i = 1; i <= 7; ++i) {
      cell = document.createElement('th');
	  cell.innerHTML = this.shortDayNames[i];
      if (i == 0 || i == 6)
        cell.className = 'weekend';
      row.appendChild(cell)
    }
    thead.appendChild(row)

    // Calendar Days
    var tbody = table.appendChild(document.createElement('tbody'))
    for (i = 6; i > 0; --i) {
      row = tbody.appendChild(document.createElement('tr'))
	  row.className = 'days';
      for (var j = 7; j > 0; --j) {
        cell = row.appendChild(document.createElement('td'))
        cell.calendar = this
      }
    }

    // Calendar Container (div)
    this.container = $__('<div/>');
	this.container.addClass('calendar');
    if (this.isPopup) {
		this.container.css({'position': 'absolute', 'display': 'none'});
      //this.container.addClassName('popup')
    }
    this.container.append(table);

    // Initialize Calendar
    this.update(this.date)

    // Observe the container for mousedown events
    this.container.mousedown(Calendar.handleMouseDownEvent);

    // Append to parent element
    parent.appendChild(this.container.get(0))

  },

  _drawButtonCell: function(parent, text, colSpan, navAction)
  {
    var cell          = document.createElement('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.closeExtHandler) {
		this.hide()
		this.closeExtHandler.calendarCloseHandler(this.dateField, this.date);
    }else if(this.closeHandler){
    	this.closeHandler(this);
    }
  },



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

  // Shows the Calendar
  show: function()
  {
    this.container.show()
    if (this.isPopup) {
      window._popupCalendar = this;
	  $__(document).mousedown(Calendar._checkCalendar);
    }
  },


	// Shows the calendar at the given absolute position
	showAt: function (fLeft, fTop) {
		this.container.css({ left: fLeft + 'px', top: fTop + 'px' });
		this.show();
	},

	// Shows the Calendar at the coordinates of the provided element
	showAtElement: function(oElement) {

		var fTop = oElement.height() + 5;
		var fLeft = 0;

		// Den "wirklich richtigen" Offset berechnen weil jQuery().offset() immer aufs Document geht und
		// außerdem §$%%&$§!!%$%§%&%&3$%§$%&§$& ...
		do {
			fTop += parseFloat(oElement.prop('offsetTop'))
				  - parseFloat(oElement.prop('scrollTop'))
				  + parseFloat(oElement.prop('clientTop'));
			fLeft += parseFloat(oElement.prop('offsetLeft'))
				  - parseFloat(oElement.prop('scrollLeft'))
				  + parseFloat(oElement.prop('clientLeft'));
			if(oElement.css('position') === 'relative') {
				break;
			}
			oElement = $__(oElement.get(0).offsetParent);
		} while(oElement.length > 0);

		this.showAt(fLeft, fTop);

	},

	// Hides the Calendar
	hide: function() {
		if (this.isPopup) {
			$__(document).off('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
  },

  setExtCloseHandler: function(closeHandler)
  {
    this.closeExtHandler = 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

window.ThebingCalendar = Calendar;

})(jQueryThebing);



























//==============================================================================
//
// 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;

  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[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;
    }
  }
  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 (y != 0 && m != -1 && d != 0)
    return new Date(y, m, d, hr, min, 0);
  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[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, 0);
  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()));
};

/** Checks date and time equality */
Date.prototype.compare = function(date) {
	if(this.getFullYear() == date.getFullYear()) {
		if(this.getMonth() == date.getMonth()) {
			if(this.getDate() == date.getDate()) {
				return 0;
			} else if(this.getDate() < date.getDate()) {
				return -1;
			} else {
				return 1;		
			}
		} else if(this.getMonth() < date.getMonth()) {
			return -1;
		} else {
			return 1;		
		}
	} else if(this.getFullYear() < date.getFullYear()) {
		return -1;
	} else {
		return 1;		
	}
};

/** 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());
};

/** 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"] = ThebingCalendar.SHORT_DAY_NAMES[w]; // abbreviated weekday name [FIXME: I18N]
  s["%A"] = ThebingCalendar.DAY_NAMES[w]; // full weekday name
  s["%b"] = ThebingCalendar.SHORT_MONTH_NAMES[m]; // abbreviated month name [FIXME: I18N]
  s["%B"] = ThebingCalendar.MONTH_NAMES[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.replace(/%./g, 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);
}