/*!

 * FullCalendar v1.6.4

 * Docs & License: http://arshaw.com/fullcalendar/

 * (c) 2013 Adam Shaw

 */

/*

 * Use fullcalendar.css for basic styling.

 * For event drag & drop, requires jQuery UI draggable.

 * For event resizing, requires jQuery UI resizable.

 */

(function($, undefined) {

;;

var defaults = {

	// display

	defaultView: 'month',

	aspectRatio: 1.35,

	header: {

		left: 'title',

		center: '',

		right: 'today prev,next'

	},

	weekends: true,

	weekNumbers: false,

	weekNumberCalculation: 'iso',

	weekNumberTitle: 'W',

	// editing

	//editable: false,

	//disableDragging: false,

	//disableResizing: false,

	allDayDefault: true,

	ignoreTimezone: true,

	// event ajax

	lazyFetching: true,

	startParam: 'start',

	endParam: 'end',

	// time formats

	titleFormat: {

		month: 'MMMM yyyy',

		week: "MMM d[ yyyy]{ '—'[ MMM] d yyyy}",

		day: 'dddd, MMM d, yyyy'

	},

	columnFormat: {

		month: 'ddd',

		week: 'ddd M/d',

		day: 'dddd M/d'

	},

	timeFormat: { // for event elements

		'': 'h(:mm)t' // default

	},

	// locale

	isRTL: false,

	firstDay: 0,

	monthNames: ['January','February','March','April','May','June','July','August','September','October','November','December'],

	monthNamesShort: ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'],

	dayNames: ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'],

	dayNamesShort: ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'],

	buttonText: {

		prev: "<span class='fc-text-arrow'>&lsaquo;</span>",

		next: "<span class='fc-text-arrow'>&rsaquo;</span>",

		prevYear: "<span class='fc-text-arrow'>&laquo;</span>",

		nextYear: "<span class='fc-text-arrow'>&raquo;</span>",

		today: 'today',

		month: 'month',

		week: 'week',

		day: 'day'

	},

	// jquery-ui theming

	theme: false,

	buttonIcons: {

		prev: 'circle-triangle-w',

		next: 'circle-triangle-e'

	},

	//selectable: false,

	unselectAuto: true,

	dropAccept: '*',

	handleWindowResize: true

};

// right-to-left defaults

var rtlDefaults = {

	header: {

		left: 'next,prev today',

		center: '',

		right: 'title'

	},

	buttonText: {

		prev: "<span class='fc-text-arrow'>&rsaquo;</span>",

		next: "<span class='fc-text-arrow'>&lsaquo;</span>",

		prevYear: "<span class='fc-text-arrow'>&raquo;</span>",

		nextYear: "<span class='fc-text-arrow'>&laquo;</span>"

	},

	buttonIcons: {

		prev: 'circle-triangle-e',

		next: 'circle-triangle-w'

	}

};

;;

var fc = $.fullCalendar = { version: "1.6.4" };

var fcViews = fc.views = {};

$.fn.fullCalendar = function(options) {

	// method calling

	if (typeof options == 'string') {

		var args = Array.prototype.slice.call(arguments, 1);

		var res;

		this.each(function() {

			var calendar = $.data(this, 'fullCalendar');

			if (calendar && $.isFunction(calendar[options])) {

				var r = calendar[options].apply(calendar, args);

				if (res === undefined) {

					res = r;

				}

				if (options == 'destroy') {

					$.removeData(this, 'fullCalendar');

				}

			}

		});

		if (res !== undefined) {

			return res;

		}

		return this;

	}

	options = options || {};

	// would like to have this logic in EventManager, but needs to happen before options are recursively extended

	var eventSources = options.eventSources || [];

	delete options.eventSources;

	if (options.events) {

		eventSources.push(options.events);

		delete options.events;

	}

	options = $.extend(true, {},

		defaults,

		(options.isRTL || options.isRTL===undefined && defaults.isRTL) ? rtlDefaults : {},

		options

	);

	this.each(function(i, _element) {

		var element = $(_element);

		var calendar = new Calendar(element, options, eventSources);

		element.data('fullCalendar', calendar); // TODO: look into memory leak implications

		calendar.render();

	});

	return this;

};

// function for adding/overriding defaults

function setDefaults(d) {

	$.extend(true, defaults, d);

}

;;

function Calendar(element, options, eventSources) {

	var t = this;

	// exports

	t.options = options;

	t.render = render;

	t.destroy = destroy;

	t.refetchEvents = refetchEvents;

	t.reportEvents = reportEvents;

	t.reportEventChange = reportEventChange;

	t.rerenderEvents = rerenderEvents;

	t.changeView = changeView;

	t.select = select;

	t.unselect = unselect;

	t.prev = prev;

	t.next = next;

	t.prevYear = prevYear;

	t.nextYear = nextYear;

	t.today = today;

	t.gotoDate = gotoDate;

	t.incrementDate = incrementDate;

	t.formatDate = function(format, date) { return formatDate(format, date, options) };

	t.formatDates = function(format, date1, date2) { return formatDates(format, date1, date2, options) };

	t.getDate = getDate;

	t.getView = getView;

	t.option = option;

	t.trigger = trigger;

	// imports

	EventManager.call(t, options, eventSources);

	var isFetchNeeded = t.isFetchNeeded;

	var fetchEvents = t.fetchEvents;

	// locals

	var _element = element[0];

	var header;

	var headerElement;

	var content;

	var tm; // for making theme classes

	var currentView;

	var elementOuterWidth;

	var suggestedViewHeight;

	var resizeUID = 0;

	var ignoreWindowResize = 0;

	var date = new Date();

	var events = [];

	var _dragElement;

	/* Main Rendering

	-----------------------------------------------------------------------------*/

	setYMD(date, options.year, options.month, options.date);

	function render(inc) {

		if (!content) {

			initialRender();

		}

		else if (elementVisible()) {

			// mainly for the public API

			calcSize();

			_renderView(inc);

		}

	}

	function initialRender() {

		tm = options.theme ? 'ui' : 'fc';

		element.addClass('fc');

		if (options.isRTL) {

			element.addClass('fc-rtl');

		}

		else {

			element.addClass('fc-ltr');

		}

		if (options.theme) {

			element.addClass('ui-widget');

		}

		content = $("<div class='fc-content' style='position:relative'/>")

			.prependTo(element);

		header = new Header(t, options);

		headerElement = header.render();

		if (headerElement) {

			element.prepend(headerElement);

		}

		changeView(options.defaultView);

		if (options.handleWindowResize) {

			$(window).resize(windowResize);

		}

		// needed for IE in a 0x0 iframe, b/c when it is resized, never triggers a windowResize

		if (!bodyVisible()) {

			lateRender();

		}

	}

	// called when we know the calendar couldn't be rendered when it was initialized,

	// but we think it's ready now

	function lateRender() {

		setTimeout(function() { // IE7 needs this so dimensions are calculated correctly

			if (!currentView.start && bodyVisible()) { // !currentView.start makes sure this never happens more than once

				renderView();

			}

		},0);

	}

	function destroy() {

		if (currentView) {

			trigger('viewDestroy', currentView, currentView, currentView.element);

			currentView.triggerEventDestroy();

		}

		$(window).unbind('resize', windowResize);

		header.destroy();

		content.remove();

		element.removeClass('fc fc-rtl ui-widget');

	}

	function elementVisible() {

		return element.is(':visible');

	}

	function bodyVisible() {

		return $('body').is(':visible');

	}

	/* View Rendering

	-----------------------------------------------------------------------------*/

	function changeView(newViewName) {

		if (!currentView || newViewName != currentView.name) {

			_changeView(newViewName);

		}

	}

	function _changeView(newViewName) {

		ignoreWindowResize++;

		if (currentView) {

			trigger('viewDestroy', currentView, currentView, currentView.element);

			unselect();

			currentView.triggerEventDestroy(); // trigger 'eventDestroy' for each event

			freezeContentHeight();

			currentView.element.remove();

			header.deactivateButton(currentView.name);

		}

		header.activateButton(newViewName);

		currentView = new fcViews[newViewName](

			$("<div class='fc-view fc-view-" + newViewName + "' style='position:relative'/>")

				.appendTo(content),

			t // the calendar object

		);

		renderView();

		unfreezeContentHeight();

		ignoreWindowResize--;

	}

	function renderView(inc) {

		if (

			!currentView.start || // never rendered before

			inc || date < currentView.start || date >= currentView.end // or new date range

		) {

			if (elementVisible()) {

				_renderView(inc);

			}

		}

	}

	function _renderView(inc) { // assumes elementVisible

		ignoreWindowResize++;

		if (currentView.start) { // already been rendered?

			trigger('viewDestroy', currentView, currentView, currentView.element);

			unselect();

			clearEvents();

		}

		freezeContentHeight();

		currentView.render(date, inc || 0); // the view's render method ONLY renders the skeleton, nothing else

		setSize();

		unfreezeContentHeight();

		(currentView.afterRender || noop)();

		updateTitle();

		updateTodayButton();

		trigger('viewRender', currentView, currentView, currentView.element);

		currentView.trigger('viewDisplay', _element); // deprecated

		ignoreWindowResize--;

		getAndRenderEvents();

	}

	/* Resizing

	-----------------------------------------------------------------------------*/

	function updateSize() {

		if (elementVisible()) {

			unselect();

			clearEvents();

			calcSize();

			setSize();

			renderEvents();

		}

	}

	function calcSize() { // assumes elementVisible

		if (options.contentHeight) {

			suggestedViewHeight = options.contentHeight;

		}

		else if (options.height) {

			suggestedViewHeight = options.height - (headerElement ? headerElement.height() : 0) - vsides(content);

		}

		else {

			suggestedViewHeight = Math.round(content.width() / Math.max(options.aspectRatio, .5));

		}

	}

	function setSize() { // assumes elementVisible

		if (suggestedViewHeight === undefined) {

			calcSize(); // for first time

				// NOTE: we don't want to recalculate on every renderView because

				// it could result in oscillating heights due to scrollbars.

		}

		ignoreWindowResize++;

		currentView.setHeight(suggestedViewHeight);

		currentView.setWidth(content.width());

		ignoreWindowResize--;

		elementOuterWidth = element.outerWidth();

	}

	function windowResize() {

		if (!ignoreWindowResize) {

			if (currentView.start) { // view has already been rendered

				var uid = ++resizeUID;

				setTimeout(function() { // add a delay

					if (uid == resizeUID && !ignoreWindowResize && elementVisible()) {

						if (elementOuterWidth != (elementOuterWidth = element.outerWidth())) {

							ignoreWindowResize++; // in case the windowResize callback changes the height

							updateSize();

							currentView.trigger('windowResize', _element);

							ignoreWindowResize--;

						}

					}

				}, 200);

			}else{

				// calendar must have been initialized in a 0x0 iframe that has just been resized

				lateRender();

			}

		}

	}

	/* Event Fetching/Rendering

	-----------------------------------------------------------------------------*/

	// TODO: going forward, most of this stuff should be directly handled by the view

	function refetchEvents() { // can be called as an API method

		clearEvents();

		fetchAndRenderEvents();

	}

	function rerenderEvents(modifiedEventID) { // can be called as an API method

		clearEvents();

		renderEvents(modifiedEventID);

	}

	function renderEvents(modifiedEventID) { // TODO: remove modifiedEventID hack

		if (elementVisible()) {

			currentView.setEventData(events); // for View.js, TODO: unify with renderEvents

			currentView.renderEvents(events, modifiedEventID); // actually render the DOM elements

			currentView.trigger('eventAfterAllRender');

		}

	}

	function clearEvents() {

		currentView.triggerEventDestroy(); // trigger 'eventDestroy' for each event

		currentView.clearEvents(); // actually remove the DOM elements

		currentView.clearEventData(); // for View.js, TODO: unify with clearEvents

	}

	function getAndRenderEvents() {

		if (!options.lazyFetching || isFetchNeeded(currentView.visStart, currentView.visEnd)) {

			fetchAndRenderEvents();

		}

		else {

			renderEvents();

		}

	}

	function fetchAndRenderEvents() {

		fetchEvents(currentView.visStart, currentView.visEnd);

			// ... will call reportEvents

			// ... which will call renderEvents

	}

	// called when event data arrives

	function reportEvents(_events) {