/**
* @preserve
* FullCalendar v1.4.6
* http://arshaw.com/fullcalendar/
*
* Use fullcalendar.css for basic styling.
* For event drag & drop, required jQuery UI draggable.
* For event resizing, requires jQuery UI resizable.
*
* Copyright (c) 2009 Adam Shaw
* Dual licensed under the MIT and GPL licenses:
* http://www.opensource.org/licenses/mit-license.php
* http://www.gnu.org/licenses/gpl.html
*
* Date: Mon May 31 10:18:29 2010 -0700
*
*/
(function($) {
var fc = $.fullCalendar = {};
var views = fc.views = {};
/* Defaults
-----------------------------------------------------------------------------*/
var defaults = {
// display
defaultView: 'month',
aspectRatio: 1.35,
header: {
left: 'title',
center: '',
right: 'today prev,next'
},
weekends: true,
// editing
//editable: false,
//disableDragging: false,
//disableResizing: false,
allDayDefault: 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: ' ◄ ',
next: ' ► ',
prevYear: ' << ',
nextYear: ' >> ',
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
};
// right-to-left defaults
var rtlDefaults = {
header: {
left: 'next,prev today',
center: '',
right: 'title'
},
buttonText: {
prev: ' ► ',
next: ' ◄ ',
prevYear: ' >> ',
nextYear: ' << '
},
buttonIcons: {
prev: 'circle-triangle-e',
next: 'circle-triangle-w'
}
};
// function for adding/overriding defaults
var setDefaults = fc.setDefaults = function(d) {
$.extend(true, defaults, d);
};
/* .fullCalendar jQuery function
-----------------------------------------------------------------------------*/
$.fn.fullCalendar = function(options) {
// method calling
if (typeof options == 'string') {
var args = Array.prototype.slice.call(arguments, 1),
res;
this.each(function() {
var data = $.data(this, 'fullCalendar');
if (data) {
var meth = data[options];
if (meth) {
var r = meth.apply(this, args);
if (res === undefined) {
res = r;
}
}
}
});
if (res !== undefined) {
return res;
}
return this;
}
// pluck the 'events' and 'eventSources' options
var eventSources = options.eventSources || [];
delete options.eventSources;
if (options.events) {
eventSources.push(options.events);
delete options.events;
}
// first event source reserved for 'sticky' events
eventSources.unshift([]);
// initialize options
options = $.extend(true, {},
defaults,
(options.isRTL || options.isRTL === undefined && defaults.isRTL) ? rtlDefaults : {},
options
);
var tm = options.theme ? 'ui' : 'fc'; // for making theme classes
this.each(function() {
/* Instance Initialization
-----------------------------------------------------------------------------*/
// element
var _element = this,
element = $(_element).addClass('fc'),
elementOuterWidth,
content = $("").prependTo(_element),
suggestedViewHeight,
resizeUID = 0,
ignoreWindowResize = 0,
date = new Date(),
viewName, // the current view name (TODO: look into getting rid of)
view, // the current view
viewInstances = {},
absoluteViewElement;
if (options.isRTL) {
element.addClass('fc-rtl');
}
if (options.theme) {
element.addClass('ui-widget');
}
if (options.year !== undefined && options.year != date.getFullYear()) {
date.setDate(1);
date.setMonth(0);
date.setFullYear(options.year);
}
if (options.month !== undefined && options.month != date.getMonth()) {
date.setDate(1);
date.setMonth(options.month);
}
if (options.date !== undefined) {
date.setDate(options.date);
}
/* View Rendering
-----------------------------------------------------------------------------*/
function changeView(v) {
if (v != viewName) {
ignoreWindowResize++; // because setMinHeight might change the height before render (and subsequently setSize) is reached
viewUnselect();
var oldView = view,
newViewElement;
if (oldView) {
if (oldView.eventsChanged) {
eventsDirty();
oldView.eventDirty = oldView.eventsChanged = false;
}
if (oldView.beforeHide) {
oldView.beforeHide(); // called before changing min-height. if called after, scroll state is reset (in Opera)
}
setMinHeight(content, content.height());
oldView.element.hide();
} else {
setMinHeight(content, 1); // needs to be 1 (not 0) for IE7, or else view dimensions miscalculated
}
content.css('overflow', 'hidden');
if (viewInstances[v]) {
(view = viewInstances[v]).element.show();
} else {
view = viewInstances[v] = fc.views[v](
newViewElement = absoluteViewElement =
$("")
.appendTo(content),
options
);
}
if (header) {
// update 'active' view button
header.find('div.fc-button-' + viewName).removeClass(tm + '-state-active');
header.find('div.fc-button-' + v).addClass(tm + '-state-active');
}
view.name = viewName = v;
render(); // after height has been set, will make absoluteViewElement's position=relative, then set to null
content.css('overflow', '');
if (oldView) {
setMinHeight(content, 1);
}
if (!newViewElement && view.afterShow) {
view.afterShow(); // called after setting min-height/overflow, so in final scroll state (for Opera)
}
ignoreWindowResize--;
}
}
function render(inc) {
if (elementVisible()) {
ignoreWindowResize++; // because view.renderEvents might temporarily change the height before setSize is reached
viewUnselect();
if (suggestedViewHeight === undefined) {
calcSize();
}
if (!view.start || inc || date < view.start || date >= view.end) {
view.render(date, inc || 0); // responsible for clearing events
setSize(true);
if (!eventStart || !options.lazyFetching || view.visStart < eventStart || view.visEnd > eventEnd) {
fetchAndRenderEvents();
} else {
view.renderEvents(events); // don't refetch
}
}
else if (view.sizeDirty || view.eventsDirty || !options.lazyFetching) {
view.clearEvents();
if (view.sizeDirty) {
setSize();
}
if (options.lazyFetching) {
view.renderEvents(events); // don't refetch
} else {
fetchAndRenderEvents();
}
}
elementOuterWidth = element.outerWidth();
view.sizeDirty = false;
view.eventsDirty = false;
if (header) {
// update title text
header.find('h2.fc-header-title').html(view.title);
// enable/disable 'today' button
var today = new Date();
if (today >= view.start && today < view.end) {
header.find('div.fc-button-today').addClass(tm + '-state-disabled');
} else {
header.find('div.fc-button-today').removeClass(tm + '-state-disabled');
}
}
ignoreWindowResize--;
view.trigger('viewDisplay', _element);
}
}
function elementVisible() {
return _element.offsetWidth !== 0;
}
function bodyVisible() {
return $('body')[0].offsetWidth !== 0;
}
function viewUnselect() {
if (view) {
view.unselect();
}
}
// called when any event objects have been added/removed/changed, rerenders
function eventsChanged() {
eventsDirty();
if (elementVisible()) {
view.clearEvents();
view.renderEvents(events);
view.eventsDirty = false;
}
}
// marks other views' events as dirty
function eventsDirty() {
$.each(viewInstances, function() {
this.eventsDirty = true;
});
}
// called when we know the element size has changed
function sizeChanged() {
sizesDirty();
if (elementVisible()) {
calcSize();
setSize();
viewUnselect();
view.rerenderEvents();
view.sizeDirty = false;
}
}
// marks other views' sizes as dirty
function sizesDirty() {
$.each(viewInstances, function() {
this.sizeDirty = true;
});
}
/* Event Sources and Fetching
-----------------------------------------------------------------------------*/
var events = [],
eventStart, eventEnd;
// Fetch from ALL sources. Clear 'events' array and populate
function fetchEvents(callback) {
events = [];
eventStart = cloneDate(view.visStart);
eventEnd = cloneDate(view.visEnd);
var queued = eventSources.length,
sourceDone = function() {
if (!--queued) {
if (callback) {
callback(events);
}
}
}, i = 0;
for (; i < eventSources.length; i++) {
fetchEventSource(eventSources[i], sourceDone);
}
}
// Fetch from a particular source. Append to the 'events' array
function fetchEventSource(src, callback) {
var prevViewName = view.name,
prevDate = cloneDate(date),
reportEvents = function(a) {
if (prevViewName == view.name && +prevDate == +date && // protects from fast switching
$.inArray(src, eventSources) != -1) { // makes sure source hasn't been removed
for (var i = 0; i < a.length; i++) {
normalizeEvent(a[i], options);
a[i].source = src;
}
events = events.concat(a);
if (callback) {
callback(a);
}
}
},
reportEventsAndPop = function(a) {
reportEvents(a);
popLoading();
};
if (typeof src == 'string') {
var params = {};
params[options.startParam] = Math.round(eventStart.getTime() / 1000);
params[options.endParam] = Math.round(eventEnd.getTime() / 1000);
if (options.cacheParam) {
params[options.cacheParam] = (new Date()).getTime(); // TODO: deprecate cacheParam
}
pushLoading();
$.ajax({
url: src,
dataType: 'json',
data: params,
cache: options.cacheParam || false, // don't let jquery prevent caching if cacheParam is being used
success: reportEventsAndPop
});
}
else if ($.isFunction(src)) {
pushLoading();
src(cloneDate(eventStart), cloneDate(eventEnd), reportEventsAndPop);
}
else {
reportEvents(src); // src is an array
}
}
// for convenience
function fetchAndRenderEvents() {
fetchEvents(function(events) {
view.renderEvents(events); // maintain `this` in view
});
}
/* Loading State
-----------------------------------------------------------------------------*/
var loadingLevel = 0;
function pushLoading() {
if (!loadingLevel++) {
view.trigger('loading', _element, true);
}
}
function popLoading() {
if (!--loadingLevel) {
view.trigger('loading', _element, false);
}
}
/* Public Methods
-----------------------------------------------------------------------------*/
var publicMethods = {
render: function() {
calcSize();
sizesDirty();
eventsDirty();
render();
},
changeView: changeView,
getView: function() {
return view;
},
getDate: function() {
return date;
},
option: function(name, value) {
if (value === undefined) {
return options[name];
}
if (name == 'height' || name == 'contentHeight' || name == 'aspectRatio') {
options[name] = value;
sizeChanged();
}
},
destroy: function() {
$(window).unbind('resize', windowResize);
if (header) {
header.remove();
}
content.remove();
$.removeData(_element, 'fullCalendar');
},
//
// Navigation
//
prev: function() {
render(-1);
},
next: function() {
render(1);
},
prevYear: function() {
addYears(date, -1);
render();
},
nextYear: function() {
addYears(date, 1);
render();
},
today: function() {
date = new Date();
render();
},
gotoDate: function(year, month, dateNum) {
if (typeof year == 'object') {
date = cloneDate(year); // provided 1 argument, a Date
} else {
if (year !== undefined) {
date.setFullYear(year);
}
if (month !== undefined) {
date.setMonth(month);
}
if (dateNum !== undefined) {
date.setDate(dateNum);
}
}
render();
},
incrementDate: function(years, months, days) {
if (years !== undefined) {
addYears(date, years);
}
if (months !== undefined) {
addMonths(date, months);
}
if (days !== undefined) {
addDays(date, days);
}
render();
},
//
// Event Manipulation
//
updateEvent: function(event) { // update an existing event
var i, len = events.length, e,
startDelta = event.start - event._start,
endDelta = event.end ?
(event.end - (event._end || view.defaultEventEnd(event))) // event._end would be null if event.end
: 0; // was null and event was just resized
for (i = 0; i < len; i++) {
e = events[i];
if (e._id == event._id && e != event) {
e.start = new Date(+e.start + startDelta);
if (event.end) {
if (e.end) {
e.end = new Date(+e.end + endDelta);
} else {
e.end = new Date(+view.defaultEventEnd(e) + endDelta);
}
} else {
e.end = null;
}
e.title = event.title;
e.url = event.url;
e.allDay = event.allDay;
e.className = event.className;
e.editable = event.editable;
normalizeEvent(e, options);
}
}
normalizeEvent(event, options);
eventsChanged();
},
renderEvent: function(event, stick) { // render a new event
normalizeEvent(event, options);
if (!event.source) {
if (stick) {
(event.source = eventSources[0]).push(event);
}
events.push(event);
}
eventsChanged();
},
removeEvents: function(filter) {
if (!filter) { // remove all
events = [];
// clear all array sources
for (var i = 0; i < eventSources.length; i++) {
if (typeof eventSources[i] == 'object') {
eventSources[i] = [];
}
}
} else {
if (!$.isFunction(filter)) { // an event ID
var id = filter + '';
filter = function(e) {
return e._id == id;
};
}
events = $.grep(events, filter, true);
// remove events from array sources
for (var i = 0; i < eventSources.length; i++) {
if (typeof eventSources[i] == 'object') {
eventSources[i] = $.grep(eventSources[i], filter, true);
}
}
}
eventsChanged();
},
clientEvents: function(filter) {
if ($.isFunction(filter)) {
return $.grep(events, filter);
}
else if (filter) { // an event ID
filter += '';
return $.grep(events, function(e) {
return e._id == filter;
});
}
return events; // else, return all
},
rerenderEvents: eventsChanged, // TODO: think of renaming eventsChanged
//
// Event Source
//
addEventSource: function(source) {
eventSources.push(source);
fetchEventSource(source, eventsChanged);
},
removeEventSource: function(source) {
eventSources = $.grep(eventSources, function(src) {
return src != source;
});
// remove all client events from that source
events = $.grep(events, function(e) {
return e.source != source;
});
eventsChanged();
},
refetchEvents: function() {
fetchEvents(eventsChanged);
},
//
// selection
//
select: function(start, end, allDay) {
view.select(start, end, allDay === undefined ? true : allDay);
},
unselect: function() {
view.unselect();
}
};
$.data(this, 'fullCalendar', publicMethods); // TODO: look into memory leak implications
/* Header
-----------------------------------------------------------------------------*/
var header,
sections = options.header;
if (sections) {
header = $("")
.append($("|
")
.append($("").append(buildSection(sections.left)))
.append($("").append(buildSection(sections.center)))
.append($("").append(buildSection(sections.right))))
.prependTo(element);
}
function buildSection(buttonStr) {
if (buttonStr) {
var tr = $("|
");
$.each(buttonStr.split(' '), function(i) {
if (i > 0) {
tr.append(" | ");
}
var prevButton;
$.each(this.split(','), function(j, buttonName) {
if (buttonName == 'title') {
tr.append(" | ");
if (prevButton) {
prevButton.addClass(tm + '-corner-right');
}
prevButton = null;
} else {
var buttonClick;
if (publicMethods[buttonName]) {
buttonClick = publicMethods[buttonName];
}
else if (views[buttonName]) {
buttonClick = function() {
button.removeClass(tm + '-state-hover');
changeView(buttonName);
};
}
if (buttonClick) {
if (prevButton) {
prevButton.addClass(tm + '-no-right');
}
var button,
icon = options.theme ? smartProperty(options.buttonIcons, buttonName) : null,
text = smartProperty(options.buttonText, buttonName);
if (icon) {
button = $("");
}
else if (text) {
button = $("");
}
if (button) {
button
.click(function() {
if (!button.hasClass(tm + '-state-disabled')) {
buttonClick();
}
})
.mousedown(function() {
button
.not('.' + tm + '-state-active')
.not('.' + tm + '-state-disabled')
.addClass(tm + '-state-down');
})
.mouseup(function() {
button.removeClass(tm + '-state-down');
})
.hover(
function() {
button
.not('.' + tm + '-state-active')
.not('.' + tm + '-state-disabled')
.addClass(tm + '-state-hover');
},
function() {
button
.removeClass(tm + '-state-hover')
.removeClass(tm + '-state-down');
}
)
.appendTo($(" | ").appendTo(tr));
if (prevButton) {
prevButton.addClass(tm + '-no-right');
} else {
button.addClass(tm + '-corner-left');
}
prevButton = button;
}
}
}
});
if (prevButton) {
prevButton.addClass(tm + '-corner-right');
}
});
return $("").append(tr);
}
}
/* Resizing
-----------------------------------------------------------------------------*/
function calcSize() {
if (options.contentHeight) {
suggestedViewHeight = options.contentHeight;
}
else if (options.height) {
suggestedViewHeight = options.height - (header ? header.height() : 0) - vsides(content[0]);
}
else {
suggestedViewHeight = Math.round(content.width() / Math.max(options.aspectRatio, .5));
}
}
function setSize(dateChanged) {
ignoreWindowResize++;
view.setHeight(suggestedViewHeight, dateChanged);
if (absoluteViewElement) {
absoluteViewElement.css('position', 'relative');
absoluteViewElement = null;
}
view.setWidth(content.width(), dateChanged);
ignoreWindowResize--;
}
function windowResize() {
if (!ignoreWindowResize) {
if (view.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
sizeChanged();
view.trigger('windowResize', _element);
ignoreWindowResize--;
}
}
}, 200);
} else {
// calendar must have been initialized in a 0x0 iframe that has just been resized
lateRender();
}
}
}
$(window).resize(windowResize);
// let's begin...
changeView(options.defaultView);
// 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 (!view.start && bodyVisible()) { // !view.start makes sure this never happens more than once
render();
}
}, 0);
}
});
return this;
};
/* Important Event Utilities
-----------------------------------------------------------------------------*/
var fakeID = 0;
function normalizeEvent(event, options) {
event._id = event._id || (event.id === undefined ? '_fc' + fakeID++ : event.id + '');
if (event.date) {
if (!event.start) {
event.start = event.date;
}
delete event.date;
}
event._start = cloneDate(event.start = parseDate(event.start));
event.end = parseDate(event.end);
if (event.end && event.end <= event.start) {
event.end = null;
}
event._end = event.end ? cloneDate(event.end) : null;
if (event.allDay === undefined) {
event.allDay = options.allDayDefault;
}
if (event.className) {
if (typeof event.className == 'string') {
event.className = event.className.split(/\s+/);
}
} else {
event.className = [];
}
}
// TODO: if there is no start date, return false to indicate an invalid event
/* Grid-based Views: month, basicWeek, basicDay
-----------------------------------------------------------------------------*/
setDefaults({
weekMode: 'fixed'
});
views.month = function(element, options) {
return new Grid(element, options, {
render: function(date, delta) {
if (delta) {
addMonths(date, delta);
date.setDate(1);
}
// start/end
var start = this.start = cloneDate(date, true);
start.setDate(1);
this.end = addMonths(cloneDate(start), 1);
// visStart/visEnd
var visStart = this.visStart = cloneDate(start),
visEnd = this.visEnd = cloneDate(this.end),
nwe = options.weekends ? 0 : 1;
if (nwe) {
skipWeekend(visStart);
skipWeekend(visEnd, -1, true);
}
addDays(visStart, -((visStart.getDay() - Math.max(options.firstDay, nwe) + 7) % 7));
addDays(visEnd, (7 - visEnd.getDay() + Math.max(options.firstDay, nwe)) % 7);
// row count
var rowCnt = Math.round((visEnd - visStart) / (DAY_MS * 7));
if (options.weekMode == 'fixed') {
addDays(visEnd, (6 - rowCnt) * 7);
rowCnt = 6;
}
// title
this.title = formatDate(
start,
this.option('titleFormat'),
options
);
// render
this.renderGrid(
rowCnt, options.weekends ? 7 : 5,
this.option('columnFormat'),
true
);
}
});
};
views.basicWeek = function(element, options) {
return new Grid(element, options, {
render: function(date, delta) {
if (delta) {
addDays(date, delta * 7);
}
var visStart = this.visStart = cloneDate(
this.start = addDays(cloneDate(date), -((date.getDay() - options.firstDay + 7) % 7))
),
visEnd = this.visEnd = cloneDate(
this.end = addDays(cloneDate(visStart), 7)
);
if (!options.weekends) {
skipWeekend(visStart);
skipWeekend(visEnd, -1, true);
}
this.title = formatDates(
visStart,
addDays(cloneDate(visEnd), -1),
this.option('titleFormat'),
options
);
this.renderGrid(
1, options.weekends ? 7 : 5,
this.option('columnFormat'),
false
);
}
});
};
views.basicDay = function(element, options) {
return new Grid(element, options, {
render: function(date, delta) {
if (delta) {
addDays(date, delta);
if (!options.weekends) {
skipWeekend(date, delta < 0 ? -1 : 1);
}
}
this.title = formatDate(date, this.option('titleFormat'), options);
this.start = this.visStart = cloneDate(date, true);
this.end = this.visEnd = addDays(cloneDate(this.start), 1);
this.renderGrid(
1, 1,
this.option('columnFormat'),
false
);
}
});
};
// rendering bugs
var tdHeightBug;
function Grid(element, options, methods) {
var tm, firstDay,
nwe, // no weekends (int)
rtl, dis, dit, // day index sign / translate
viewWidth, viewHeight,
rowCnt, colCnt,
colWidth,
thead, tbody,
cachedEvents = [],
segmentContainer,
dayContentPositions = new HorizontalPositionCache(function(dayOfWeek) {
return tbody.find('td:eq(' + ((dayOfWeek - Math.max(firstDay, nwe) + colCnt) % colCnt) + ') div div');
}),
selectionManager,
selectionMatrix,
// ...
// initialize superclass
view = $.extend(this, viewMethods, methods, {
renderGrid: renderGrid,
renderEvents: renderEvents,
rerenderEvents: rerenderEvents,
clearEvents: clearEvents,
setHeight: setHeight,
setWidth: setWidth,
defaultEventEnd: function(event) { // calculates an end if event doesnt have one, mostly for resizing
return cloneDate(event.start);
}
});
view.init(element, options);
/* Grid Rendering
-----------------------------------------------------------------------------*/
disableTextSelection(element.addClass('fc-grid'));
function renderGrid(r, c, colFormat, showNumbers) {
rowCnt = r;
colCnt = c;
// update option-derived variables
tm = options.theme ? 'ui' : 'fc';
nwe = options.weekends ? 0 : 1;
firstDay = options.firstDay;
if (rtl = options.isRTL) {
dis = -1;
dit = colCnt - 1;
} else {
dis = 1;
dit = 0;
}
var month = view.start.getMonth(),
today = clearTime(new Date()),
s, i, j, d = cloneDate(view.visStart);
if (!tbody) { // first time, build all cells from scratch
var table = $("").appendTo(element);
s = "";
for (i = 0; i < colCnt; i++) {
s += "| " + formatDate(d, colFormat, options) + " | ";
addDays(d, 1);
if (nwe) {
skipWeekend(d);
}
}
thead = $(s + "
").appendTo(table);
s = "";
d = cloneDate(view.visStart);
for (i = 0; i < rowCnt; i++) {
s += "";
for (j = 0; j < colCnt; j++) {
s += "| 1 && d.getMonth() != month ? ' fc-other-month' : '') +
(+d == +today ?
' fc-today ' + tm + '-state-highlight' :
' fc-not-today') + "'>" +
(showNumbers ? " " + d.getDate() + " " : '') +
" | ";
addDays(d, 1);
if (nwe) {
skipWeekend(d);
}
}
s += "
";
}
tbody = $(s + "").appendTo(table);
dayBind(tbody.find('td'));
segmentContainer = $("").appendTo(element);
} else { // NOT first time, reuse as many cells as possible
clearEvents();
var prevRowCnt = tbody.find('tr').length;
if (rowCnt < prevRowCnt) {
tbody.find('tr:gt(' + (rowCnt - 1) + ')').remove(); // remove extra rows
}
else if (rowCnt > prevRowCnt) { // needs to create new rows...
s = '';
for (i = prevRowCnt; i < rowCnt; i++) {
s += "";
for (j = 0; j < colCnt; j++) {
s += "| " +
(showNumbers ? "" : '') +
"" +
" | ";
addDays(d, 1);
if (nwe) {
skipWeekend(d);
}
}
s += "
";
}
tbody.append(s);
}
dayBind(tbody.find('td.fc-new').removeClass('fc-new'));
// re-label and re-class existing cells
d = cloneDate(view.visStart);
tbody.find('td').each(function() {
var td = $(this);
if (rowCnt > 1) {
if (d.getMonth() == month) {
td.removeClass('fc-other-month');
} else {
td.addClass('fc-other-month');
}
}
if (+d == +today) {
td.removeClass('fc-not-today')
.addClass('fc-today')
.addClass(tm + '-state-highlight');
} else {
td.addClass('fc-not-today')
.removeClass('fc-today')
.removeClass(tm + '-state-highlight');
}
td.find('div.fc-day-number').text(d.getDate());
addDays(d, 1);
if (nwe) {
skipWeekend(d);
}
});
if (rowCnt == 1) { // more changes likely (week or day view)
// redo column header text and class
d = cloneDate(view.visStart);
thead.find('th').each(function() {
$(this).text(formatDate(d, colFormat, options));
this.className = this.className.replace(/^fc-\w+(?= )/, 'fc-' + dayIDs[d.getDay()]);
addDays(d, 1);
if (nwe) {
skipWeekend(d);
}
});
// redo cell day-of-weeks
d = cloneDate(view.visStart);
tbody.find('td').each(function() {
this.className = this.className.replace(/^fc-\w+(?= )/, 'fc-' + dayIDs[d.getDay()]);
addDays(d, 1);
if (nwe) {
skipWeekend(d);
}
});
}
}
}
function setHeight(height) {
viewHeight = height;
var leftTDs = tbody.find('tr td:first-child'),
tbodyHeight = viewHeight - thead.height(),
rowHeight1, rowHeight2;
if (options.weekMode == 'variable') {
rowHeight1 = rowHeight2 = Math.floor(tbodyHeight / (rowCnt == 1 ? 2 : 6));
} else {
rowHeight1 = Math.floor(tbodyHeight / rowCnt);
rowHeight2 = tbodyHeight - rowHeight1 * (rowCnt - 1);
}
if (tdHeightBug === undefined) {
// bug in firefox where cell height includes padding
var tr = tbody.find('tr:first'),
td = tr.find('td:first');
td.height(rowHeight1);
tdHeightBug = rowHeight1 != td.height();
}
if (tdHeightBug) {
leftTDs.slice(0, -1).height(rowHeight1);
leftTDs.slice(-1).height(rowHeight2);
} else {
setOuterHeight(leftTDs.slice(0, -1), rowHeight1);
setOuterHeight(leftTDs.slice(-1), rowHeight2);
}
}
function setWidth(width) {
viewWidth = width;
dayContentPositions.clear();
setOuterWidth(
thead.find('th').slice(0, -1),
colWidth = Math.floor(viewWidth / colCnt)
);
}
/* Event Rendering
-----------------------------------------------------------------------------*/
function renderEvents(events) {
view.reportEvents(cachedEvents = events);
renderSegs(compileSegs(events));
}
function rerenderEvents(modifiedEventId) {
clearEvents();
renderSegs(compileSegs(cachedEvents), modifiedEventId);
}
function clearEvents() {
view._clearEvents(); // only clears the hashes
segmentContainer.empty();
}
function compileSegs(events) {
var d1 = cloneDate(view.visStart),
d2 = addDays(cloneDate(d1), colCnt),
visEventsEnds = $.map(events, exclEndDay),
i, row,
j, level,
k, seg,
segs = [];
for (i = 0; i < rowCnt; i++) {
row = stackSegs(view.sliceSegs(events, visEventsEnds, d1, d2));
for (j = 0; j < row.length; j++) {
level = row[j];
for (k = 0; k < level.length; k++) {
seg = level[k];
seg.row = i;
seg.level = j;
segs.push(seg);
}
}
addDays(d1, 7);
addDays(d2, 7);
}
return segs;
}
function renderSegs(segs, modifiedEventId) {
_renderDaySegs(
segs,
rowCnt,
view,
0,
viewWidth,
function(i) {
return tbody.find('tr:eq(' + i + ')')
},
dayContentPositions.left,
dayContentPositions.right,
segmentContainer,
bindSegHandlers,
modifiedEventId
);
}
function bindSegHandlers(event, eventElement, seg) {
view.eventElementHandlers(event, eventElement);
if (event.editable || event.editable === undefined && options.editable) {
draggableEvent(event, eventElement);
if (seg.isEnd) {
view.resizableDayEvent(event, eventElement, colWidth);
}
}
}
/* Event Dragging
-----------------------------------------------------------------------------*/
function draggableEvent(event, eventElement) {
if (!options.disableDragging && eventElement.draggable) {
var matrix,
dayDelta = 0;
eventElement.draggable({
zIndex: 9,
delay: 50,
opacity: view.option('dragOpacity'),
revertDuration: options.dragRevertDuration,
start: function(ev, ui) {
view.hideEvents(event, eventElement);
view.trigger('eventDragStart', eventElement, event, ev, ui);
matrix = buildDayMatrix(function(cell) {
eventElement.draggable('option', 'revert', !cell || !cell.rowDelta && !cell.colDelta);
clearOverlays();
if (cell) {
dayDelta = cell.rowDelta * 7 + cell.colDelta * dis;
renderDayOverlays(
matrix,
addDays(cloneDate(event.start), dayDelta),
addDays(exclEndDay(event), dayDelta)
);
} else {
dayDelta = 0;
}
});
matrix.mouse(ev);
},
drag: function(ev) {
matrix.mouse(ev);
},
stop: function(ev, ui) {
clearOverlays();
view.trigger('eventDragStop', eventElement, event, ev, ui);
if (dayDelta) {
eventElement.find('a').removeAttr('href'); // prevents safari from visiting the link
view.eventDrop(this, event, dayDelta, 0, event.allDay, ev, ui);
} else {
if ($.browser.msie) {
eventElement.css('filter', ''); // clear IE opacity side-effects
}
view.showEvents(event, eventElement);
}
}
});
}
}
/* Day clicking and binding
---------------------------------------------------------*/
function dayBind(days) {
days.click(dayClick)
.mousedown(selectionMousedown);
}
function dayClick(ev) {
if (!view.option('selectable')) { // SelectionManager will worry about dayClick
var n = parseInt(this.className.match(/fc\-day(\d+)/)[1]),
date = addDays(
cloneDate(view.visStart),
Math.floor(n / colCnt) * 7 + n % colCnt
);
// TODO: what about weekends in middle of week?
view.trigger('dayClick', this, date, true, ev);
}
}
/* Selecting
--------------------------------------------------------*/
selectionManager = new SelectionManager(
view,
unselect,
function(startDate, endDate, allDay) {
renderDayOverlays(
selectionMatrix,
startDate,
addDays(cloneDate(endDate), 1)
);
},
clearOverlays
);
function selectionMousedown(ev) {
if (view.option('selectable')) {
selectionMatrix = buildDayMatrix(function(cell) {
if (cell) {
var d = cellDate(cell.row, cell.col);
selectionManager.drag(d, d, true);
} else {
selectionManager.drag();
}
});
documentDragHelp(
function(ev) {
selectionMatrix.mouse(ev);
},
function(ev) {
selectionManager.dragStop(ev);
}
);
selectionManager.dragStart(ev);
selectionMatrix.mouse(ev);
return false; // prevent auto-unselect and text selection
}
}
documentUnselectAuto(view, unselect);
view.select = function(start, end, allDay) {
if (!end) {
end = cloneDate(start);
}
selectionMatrix = buildDayMatrix();
selectionManager.select(start, end, allDay);
};
function unselect() {
selectionManager.unselect();
}
view.unselect = unselect;
/* Semi-transparent Overlay Helpers
------------------------------------------------------*/
function renderDayOverlays(matrix, overlayStart, overlayEnd) { // overlayEnd is exclusive
var rowStart = cloneDate(view.visStart);
var rowEnd = addDays(cloneDate(rowStart), colCnt);
for (var i = 0; i < rowCnt; i++) {
var stretchStart = new Date(Math.max(rowStart, overlayStart));
var stretchEnd = new Date(Math.min(rowEnd, overlayEnd));
if (stretchStart < stretchEnd) {
var colStart, colEnd;
if (rtl) {
colStart = dayDiff(stretchEnd, rowStart) * dis + dit + 1;
colEnd = dayDiff(stretchStart, rowStart) * dis + dit + 1;
} else {
colStart = dayDiff(stretchStart, rowStart);
colEnd = dayDiff(stretchEnd, rowStart);
}
var rect = matrix.rect(i, colStart, i + 1, colEnd, element);
dayBind(
view.renderOverlay(rect, element)
);
}
addDays(rowStart, 7);
addDays(rowEnd, 7);
}
}
function clearOverlays() {
view.clearOverlays();
}
/* Utils
---------------------------------------------------*/
function buildDayMatrix(changeCallback) {
var tds = tbody.find('tr:first td');
if (rtl) {
tds = $(tds.get().reverse());
}
return new HoverMatrix(tbody.find('tr'), tds, changeCallback);
}
function cellDate(r, c) { // convert r,c to date
return addDays(cloneDate(view.visStart), r * 7 + c * dis + dit);
// TODO: what about weekends in middle of week?
}
}
function _renderDaySegs(segs, rowCnt, view, minLeft, maxLeft, getRow, dayContentLeft, dayContentRight, segmentContainer, bindSegHandlers, modifiedEventId) {
var options = view.options,
rtl = options.isRTL,
i, segCnt = segs.length, seg,
event,
className,
left, right,
html = '',
eventElements,
eventElement,
triggerRes,
hsideCache = {},
vmarginCache = {},
key, val,
rowI, top, levelI, levelHeight,
rowDivs = [],
rowDivTops = [];
// calculate desired position/dimensions, create html
for (i = 0; i < segCnt; i++) {
seg = segs[i];
event = seg.event;
className = 'fc-event fc-event-hori ';
if (rtl) {
if (seg.isStart) {
className += 'fc-corner-right ';
}
if (seg.isEnd) {
className += 'fc-corner-left ';
}
left = seg.isEnd ? dayContentLeft(seg.end.getDay() - 1) : minLeft;
right = seg.isStart ? dayContentRight(seg.start.getDay()) : maxLeft;
} else {
if (seg.isStart) {
className += 'fc-corner-left ';
}
if (seg.isEnd) {
className += 'fc-corner-right ';
}
left = seg.isStart ? dayContentLeft(seg.start.getDay()) : minLeft;
right = seg.isEnd ? dayContentRight(seg.end.getDay() - 1) : maxLeft;
}
html +=
"" +
"
" +
(!event.allDay && seg.isStart ?
"" +
htmlEscape(formatDates(event.start, event.end, view.option('timeFormat'), options)) +
""
: '') +
"" + htmlEscape(event.title) + "" +
"" +
((event.editable || event.editable === undefined && options.editable) && !options.disableResizing && $.fn.resizable ?
""
: '') +
"" +
"
" +
"" +
"| | ";
for (i = 0; i < colCnt; i++) {
s += "" + formatDate(d, colFormat, options) + " | ";
addDays(d, dis);
if (nwe) {
skipWeekend(d, dis);
}
}
s += " |
";
if (options.allDaySlot) {
s += "" +
"| " + options.allDayText + " | " +
"" +
" | " +
" | " +
"
|
|---|
";
}
s += "
";
for (i = 0; d < maxd; i++) {
minutes = d.getMinutes();
s += "| " +
((!slotNormal || !minutes) ? formatDate(d, options.axisFormat) : ' ') +
" | |
|---|
";
addMinutes(d, options.slotMinutes);
slotCnt++;
}
s += "
";
body = $("")
.append(bodyContent = $("")
.append(bodyTable = $(s)))
.appendTo(element);
slotBind(body.find('td'));
// slot event container
slotSegmentContainer = $("").appendTo(bodyContent);
// background stripes
d = cloneDate(d0);
s = "" +
"
";
for (i = 0; i < colCnt; i++) {
s += " | ";
addDays(d, dis);
if (nwe) {
skipWeekend(d, dis);
}
}
s += "
" +
"
" +
"" +
"" + htmlEscape(formatDates(event.start, event.end, view.option('timeFormat'))) + "" +
"" + htmlEscape(event.title) + "" +
"" +
((event.editable || event.editable === undefined && options.editable) && !options.disableResizing && $.fn.resizable ?
"=
"
: '') +
"