")
+ .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 += "
";
+ bg = $(s).appendTo(element);
+
+ } else { // skeleton already built, just modify it
+
+ clearEvents();
+
+ // redo column header text and class
+ head.find('tr:first th').slice(1, -1).each(function() {
+ $(this).text(formatDate(d, colFormat, options));
+ this.className = this.className.replace(/^fc-\w+(?= )/, 'fc-' + dayIDs[d.getDay()]);
+ addDays(d, dis);
+ if (nwe) {
+ skipWeekend(d, dis);
+ }
+ });
+
+ // change classes of background stripes
+ d = cloneDate(d0);
+ bg.find('td').each(function() {
+ this.className = this.className.replace(/^fc-\w+(?= )/, 'fc-' + dayIDs[d.getDay()]);
+ if (+d == +today) {
+ $(this)
+ .removeClass('fc-not-today')
+ .addClass('fc-today')
+ .addClass(tm + '-state-highlight');
+ } else {
+ $(this)
+ .addClass('fc-not-today')
+ .removeClass('fc-today')
+ .removeClass(tm + '-state-highlight');
+ }
+ addDays(d, dis);
+ if (nwe) {
+ skipWeekend(d, dis);
+ }
+ });
+
+ }
+
+ }
+
+
+ function resetScroll() {
+ var d0 = zeroDate(),
+ scrollDate = cloneDate(d0);
+ scrollDate.setHours(options.firstHour);
+ var top = timePosition(d0, scrollDate) + 1, // +1 for the border
+ scroll = function() {
+ body.scrollTop(top);
+ };
+ scroll();
+ setTimeout(scroll, 0); // overrides any previous scroll state made by the browser
+ }
+
+
+ function setHeight(height, dateChanged) {
+ viewHeight = height;
+ slotTopCache = {};
+
+ body.height(height - head.height());
+
+ slotHeight = body.find('tr:first div').height() + 1;
+
+ bg.css({
+ top: head.find('tr').height(),
+ height: height
+ });
+
+ if (dateChanged) {
+ resetScroll();
+ }
+ }
+
+
+ function setWidth(width) {
+ viewWidth = width;
+ colContentPositions.clear();
+
+ body.width(width);
+ bodyTable.width('');
+
+ var topTDs = head.find('tr:first th'),
+ stripeTDs = bg.find('td'),
+ clientWidth = body[0].clientWidth;
+
+ bodyTable.width(clientWidth);
+
+ // time-axis width
+ axisWidth = 0;
+ setOuterWidth(
+ head.find('tr:lt(2) th:first').add(body.find('tr:first th'))
+ .width('')
+ .each(function() {
+ axisWidth = Math.max(axisWidth, $(this).outerWidth());
+ }),
+ axisWidth
+ );
+
+ // column width
+ colWidth = Math.floor((clientWidth - axisWidth) / colCnt);
+ setOuterWidth(stripeTDs.slice(0, -1), colWidth);
+ setOuterWidth(topTDs.slice(1, -2), colWidth);
+ setOuterWidth(topTDs.slice(-2, -1), clientWidth - axisWidth - colWidth * (colCnt - 1));
+
+ bg.css({
+ left: axisWidth,
+ width: clientWidth - axisWidth
+ });
+ }
+
+
+ /* Slot/Day clicking and binding
+ -----------------------------------------------------------------------*/
+
+
+ function dayBind(tds) {
+ tds.click(slotClick)
+ .mousedown(daySelectionMousedown);
+ }
+
+
+ function slotBind(tds) {
+ tds.click(slotClick)
+ .mousedown(slotSelectionMousedown);
+ }
+
+
+ function slotClick(ev) {
+ if (!view.option('selectable')) { // SelectionManager will worry about dayClick
+ var col = Math.floor((ev.pageX - bg.offset().left) / colWidth),
+ date = addDays(cloneDate(view.visStart), dit + dis * col),
+ rowMatch = this.className.match(/fc-slot(\d+)/);
+ if (rowMatch) {
+ var mins = parseInt(rowMatch[1]) * options.slotMinutes,
+ hours = Math.floor(mins / 60);
+ date.setHours(hours);
+ date.setMinutes(mins % 60 + minMinute);
+ view.trigger('dayClick', this, date, false, ev);
+ } else {
+ view.trigger('dayClick', this, date, true, ev);
+ }
+ }
+ }
+
+
+ /* Event Rendering
+ -----------------------------------------------------------------------------*/
+
+ function renderEvents(events, modifiedEventId) {
+ view.reportEvents(cachedEvents = events);
+ var i, len = events.length,
+ dayEvents = [],
+ slotEvents = [];
+ for (i = 0; i < len; i++) {
+ if (events[i].allDay) {
+ dayEvents.push(events[i]);
+ } else {
+ slotEvents.push(events[i]);
+ }
+ }
+ renderDaySegs(compileDaySegs(dayEvents), modifiedEventId);
+ renderSlotSegs(compileSlotSegs(slotEvents), modifiedEventId);
+ }
+
+
+ function rerenderEvents(modifiedEventId) {
+ clearEvents();
+ renderEvents(cachedEvents, modifiedEventId);
+ }
+
+
+ function clearEvents() {
+ view._clearEvents(); // only clears the hashes
+ daySegmentContainer.empty();
+ slotSegmentContainer.empty();
+ }
+
+
+ function compileDaySegs(events) {
+ var levels = stackSegs(view.sliceSegs(events, $.map(events, exclEndDay), view.visStart, view.visEnd)),
+ i, levelCnt = levels.length, level,
+ j, seg,
+ segs = [];
+ for (i = 0; i < levelCnt; i++) {
+ level = levels[i];
+ for (j = 0; j < level.length; j++) {
+ seg = level[j];
+ seg.row = 0;
+ seg.level = i;
+ segs.push(seg);
+ }
+ }
+ return segs;
+ }
+
+
+ function compileSlotSegs(events) {
+ var d = addMinutes(cloneDate(view.visStart), minMinute),
+ visEventEnds = $.map(events, slotEventEnd),
+ i, col,
+ j, level,
+ k, seg,
+ segs = [];
+ for (i = 0; i < colCnt; i++) {
+ col = stackSegs(view.sliceSegs(events, visEventEnds, d, addMinutes(cloneDate(d), maxMinute - minMinute)));
+ countForwardSegs(col);
+ for (j = 0; j < col.length; j++) {
+ level = col[j];
+ for (k = 0; k < level.length; k++) {
+ seg = level[k];
+ seg.col = i;
+ seg.level = j;
+ segs.push(seg);
+ }
+ }
+ addDays(d, 1, true);
+ }
+ return segs;
+ }
+
+
+ // renders 'all-day' events at the top
+
+ function renderDaySegs(segs, modifiedEventId) {
+ if (options.allDaySlot) {
+ _renderDaySegs(
+ segs,
+ 1,
+ view,
+ axisWidth,
+ viewWidth,
+ function() {
+ return head.find('tr.fc-all-day');
+ },
+ function(dayOfWeek) {
+ return axisWidth + colContentPositions.left(dayOfWeekCol(dayOfWeek));
+ },
+ function(dayOfWeek) {
+ return axisWidth + colContentPositions.right(dayOfWeekCol(dayOfWeek));
+ },
+ daySegmentContainer,
+ daySegBind,
+ modifiedEventId
+ );
+ setHeight(viewHeight); // might have pushed the body down, so resize
+ }
+ }
+
+
+ // renders events in the 'time slots' at the bottom
+
+ function renderSlotSegs(segs, modifiedEventId) {
+
+ var i, segCnt = segs.length, seg,
+ event,
+ className,
+ top, bottom,
+ colI, levelI, forward,
+ leftmost,
+ availWidth,
+ outerWidth,
+ left,
+ html = '',
+ eventElements,
+ eventElement,
+ triggerRes,
+ vsideCache = {},
+ hsideCache = {},
+ key, val,
+ titleSpan,
+ height;
+
+ // calculate position/dimensions, create html
+ for (i = 0; i < segCnt; i++) {
+ seg = segs[i];
+ event = seg.event;
+ className = 'fc-event fc-event-vert ';
+ if (seg.isStart) {
+ className += 'fc-corner-top ';
+ }
+ if (seg.isEnd) {
+ className += 'fc-corner-bottom ';
+ }
+ top = timePosition(seg.start, seg.start);
+ bottom = timePosition(seg.start, seg.end);
+ colI = seg.col;
+ levelI = seg.level;
+ forward = seg.forward || 0;
+ leftmost = axisWidth + colContentPositions.left(colI * dis + dit);
+ availWidth = axisWidth + colContentPositions.right(colI * dis + dit) - leftmost;
+ availWidth = Math.min(availWidth - 6, availWidth * .95); // TODO: move this to CSS
+ if (levelI) {
+ // indented and thin
+ outerWidth = availWidth / (levelI + forward + 1);
+ } else {
+ if (forward) {
+ // moderately wide, aligned left still
+ outerWidth = ((availWidth / (forward + 1)) - (12 / 2)) * 2; // 12 is the predicted width of resizer =
+ } else {
+ // can be entire width, aligned left
+ outerWidth = availWidth;
+ }
+ }
+ left = leftmost + // leftmost possible
+ (availWidth / (levelI + forward + 1) * levelI) // indentation
+ * dis + (rtl ? availWidth - outerWidth : 0); // rtl
+ seg.top = top;
+ seg.left = left;
+ seg.outerWidth = outerWidth;
+ seg.outerHeight = bottom - top;
+ html += slotSegHtml(event, seg, className);
+ }
+ slotSegmentContainer[0].innerHTML = html; // faster than html()
+ eventElements = slotSegmentContainer.children();
+
+ // retrieve elements, run through eventRender callback, bind event handlers
+ for (i = 0; i < segCnt; i++) {
+ seg = segs[i];
+ event = seg.event;
+ eventElement = $(eventElements[i]); // faster than eq()
+ triggerRes = view.trigger('eventRender', event, event, eventElement);
+ if (triggerRes === false) {
+ eventElement.remove();
+ } else {
+ if (triggerRes && triggerRes !== true) {
+ eventElement.remove();
+ eventElement = $(triggerRes)
+ .css({
+ position: 'absolute',
+ top: seg.top,
+ left: seg.left
+ })
+ .appendTo(slotSegmentContainer);
+ }
+ seg.element = eventElement;
+ if (event._id === modifiedEventId) {
+ slotSegBind(event, eventElement, seg);
+ } else {
+ eventElement[0]._fci = i; // for lazySegBind
+ }
+ view.reportEventElement(event, eventElement);
+ }
+ }
+
+ lazySegBind(slotSegmentContainer, segs, slotSegBind);
+
+ // record event sides and title positions
+ for (i = 0; i < segCnt; i++) {
+ seg = segs[i];
+ if (eventElement = seg.element) {
+ val = vsideCache[key = seg.key = cssKey(eventElement[0])];
+ seg.vsides = val === undefined ? (vsideCache[key] = vsides(eventElement[0], true)) : val;
+ val = hsideCache[key];
+ seg.hsides = val === undefined ? (hsideCache[key] = hsides(eventElement[0], true)) : val;
+ titleSpan = eventElement.find('span.fc-event-title');
+ if (titleSpan.length) {
+ seg.titleTop = titleSpan[0].offsetTop;
+ }
+ }
+ }
+
+ // set all positions/dimensions at once
+ for (i = 0; i < segCnt; i++) {
+ seg = segs[i];
+ if (eventElement = seg.element) {
+ eventElement[0].style.width = seg.outerWidth - seg.hsides + 'px';
+ eventElement[0].style.height = (height = seg.outerHeight - seg.vsides) + 'px';
+ event = seg.event;
+ if (seg.titleTop !== undefined && height - seg.titleTop < 10) {
+ // not enough room for title, put it in the time header
+ eventElement.find('span.fc-event-time')
+ .text(formatDate(event.start, view.option('timeFormat')) + ' - ' + event.title);
+ eventElement.find('span.fc-event-title')
+ .remove();
+ }
+ view.trigger('eventAfterRender', event, event, eventElement);
+ }
+ }
+
+ }
+
+ function slotSegHtml(event, seg, className) {
+ return "
" +
+ "
" +
+ "" +
+ "" + htmlEscape(formatDates(event.start, event.end, view.option('timeFormat'))) + "" +
+ "" + htmlEscape(event.title) + "" +
+ "" +
+ ((event.editable || event.editable === undefined && options.editable) && !options.disableResizing && $.fn.resizable ?
+ "=
"
+ : '') +
+ "";
+ }
+
+
+ function daySegBind(event, eventElement, seg) {
+ view.eventElementHandlers(event, eventElement);
+ if (event.editable || event.editable === undefined && options.editable) {
+ draggableDayEvent(event, eventElement, seg.isStart);
+ if (seg.isEnd) {
+ view.resizableDayEvent(event, eventElement, colWidth);
+ }
+ }
+ }
+
+
+ function slotSegBind(event, eventElement, seg) {
+ view.eventElementHandlers(event, eventElement);
+ if (event.editable || event.editable === undefined && options.editable) {
+ var timeElement = eventElement.find('span.fc-event-time');
+ draggableSlotEvent(event, eventElement, timeElement);
+ if (seg.isEnd) {
+ resizableSlotEvent(event, eventElement, timeElement);
+ }
+ }
+ }
+
+
+ /* Event Dragging
+ -----------------------------------------------------------------------------*/
+
+
+ // when event starts out FULL-DAY
+
+ function draggableDayEvent(event, eventElement, isStart) {
+ if (!options.disableDragging && eventElement.draggable) {
+ var origPosition, origWidth,
+ resetElement,
+ allDay = true,
+ matrix;
+ eventElement.draggable({
+ zIndex: 9,
+ opacity: view.option('dragOpacity', 'month'), // use whatever the month view was using
+ revertDuration: options.dragRevertDuration,
+ start: function(ev, ui) {
+ view.hideEvents(event, eventElement);
+ view.trigger('eventDragStart', eventElement, event, ev, ui);
+ origPosition = eventElement.position();
+ origWidth = eventElement.width();
+ resetElement = function() {
+ if (!allDay) {
+ eventElement
+ .width(origWidth)
+ .height('')
+ .draggable('option', 'grid', null);
+ allDay = true;
+ }
+ };
+ matrix = buildDayMatrix(function(cell) {
+ eventElement.draggable('option', 'revert', !cell || !cell.rowDelta && !cell.colDelta);
+ view.clearOverlays();
+ if (cell) {
+ if (!cell.row) {
+ // on full-days
+ renderDayOverlay(
+ matrix,
+ addDays(cloneDate(event.start), cell.colDelta),
+ addDays(exclEndDay(event), cell.colDelta)
+ );
+ resetElement();
+ } else {
+ // mouse is over bottom slots
+ if (isStart && allDay) {
+ // convert event to temporary slot-event
+ setOuterHeight(
+ eventElement.width(colWidth - 10), // don't use entire width
+ slotHeight * Math.round(
+ (event.end ? ((event.end - event.start) / MINUTE_MS) : options.defaultEventMinutes)
+ / options.slotMinutes)
+ );
+ eventElement.draggable('option', 'grid', [colWidth, 1]);
+ allDay = false;
+ }
+ }
+ }
+ }, true);
+ matrix.mouse(ev);
+ },
+ drag: function(ev, ui) {
+ matrix.mouse(ev);
+ },
+ stop: function(ev, ui) {
+ view.trigger('eventDragStop', eventElement, event, ev, ui);
+ view.clearOverlays();
+ var cell = matrix.cell;
+ var dayDelta = dis * (
+ allDay ? // can't trust cell.colDelta when using slot grid
+ (cell ? cell.colDelta : 0) :
+ Math.floor((ui.position.left - origPosition.left) / colWidth)
+ );
+ if (!cell || !dayDelta && !cell.rowDelta) {
+ // over nothing (has reverted)
+ resetElement();
+ if ($.browser.msie) {
+ eventElement.css('filter', ''); // clear IE opacity side-effects
+ }
+ view.showEvents(event, eventElement);
+ } else {
+ eventElement.find('a').removeAttr('href'); // prevents safari from visiting the link
+ view.eventDrop(
+ this, event, dayDelta,
+ allDay ? 0 : // minute delta
+ Math.round((eventElement.offset().top - bodyContent.offset().top) / slotHeight)
+ * options.slotMinutes
+ + minMinute
+ - (event.start.getHours() * 60 + event.start.getMinutes()),
+ allDay, ev, ui
+ );
+ }
+ }
+ });
+ }
+ }
+
+
+ // when event starts out IN TIMESLOTS
+
+ function draggableSlotEvent(event, eventElement, timeElement) {
+ if (!options.disableDragging && eventElement.draggable) {
+ var origPosition,
+ resetElement,
+ prevSlotDelta, slotDelta,
+ allDay = false,
+ matrix;
+ eventElement.draggable({
+ zIndex: 9,
+ scroll: false,
+ grid: [colWidth, slotHeight],
+ axis: colCnt == 1 ? 'y' : false,
+ opacity: view.option('dragOpacity'),
+ revertDuration: options.dragRevertDuration,
+ start: function(ev, ui) {
+ view.hideEvents(event, eventElement);
+ view.trigger('eventDragStart', eventElement, event, ev, ui);
+ if ($.browser.msie) {
+ eventElement.find('span.fc-event-bg').hide(); // nested opacities mess up in IE, just hide
+ }
+ origPosition = eventElement.position();
+ resetElement = function() {
+ // convert back to original slot-event
+ if (allDay) {
+ timeElement.css('display', ''); // show() was causing display=inline
+ eventElement.draggable('option', 'grid', [colWidth, slotHeight]);
+ allDay = false;
+ }
+ };
+ prevSlotDelta = 0;
+ matrix = buildDayMatrix(function(cell) {
+ eventElement.draggable('option', 'revert', !cell);
+ view.clearOverlays();
+ if (cell) {
+ if (!cell.row && options.allDaySlot) { // over full days
+ if (!allDay) {
+ // convert to temporary all-day event
+ allDay = true;
+ timeElement.hide();
+ eventElement.draggable('option', 'grid', null);
+ }
+ renderDayOverlay(
+ matrix,
+ addDays(cloneDate(event.start), cell.colDelta),
+ addDays(exclEndDay(event), cell.colDelta)
+ );
+ } else { // on slots
+ resetElement();
+ }
+ }
+ }, true);
+ matrix.mouse(ev);
+ },
+ drag: function(ev, ui) {
+ slotDelta = Math.round((ui.position.top - origPosition.top) / slotHeight);
+ if (slotDelta != prevSlotDelta) {
+ if (!allDay) {
+ // update time header
+ var minuteDelta = slotDelta * options.slotMinutes,
+ newStart = addMinutes(cloneDate(event.start), minuteDelta),
+ newEnd;
+ if (event.end) {
+ newEnd = addMinutes(cloneDate(event.end), minuteDelta);
+ }
+ timeElement.text(formatDates(newStart, newEnd, view.option('timeFormat')));
+ }
+ prevSlotDelta = slotDelta;
+ }
+ matrix.mouse(ev);
+ },
+ stop: function(ev, ui) {
+ view.clearOverlays();
+ view.trigger('eventDragStop', eventElement, event, ev, ui);
+ var cell = matrix.cell,
+ dayDelta = dis * (
+ allDay ? // can't trust cell.colDelta when using slot grid
+ (cell ? cell.colDelta : 0) :
+ Math.floor((ui.position.left - origPosition.left) / colWidth)
+ );
+ if (!cell || !slotDelta && !dayDelta) {
+ resetElement();
+ if ($.browser.msie) {
+ eventElement
+ .css('filter', '')// clear IE opacity side-effects
+ .find('span.fc-event-bg').css('display', ''); // .show() made display=inline
+ }
+ eventElement.css(origPosition); // sometimes fast drags make event revert to wrong position
+ view.showEvents(event, eventElement);
+ } else {
+ view.eventDrop(
+ this, event, dayDelta,
+ allDay ? 0 : slotDelta * options.slotMinutes, // minute delta
+ allDay, ev, ui
+ );
+ }
+ }
+ });
+ }
+ }
+
+
+ /* Event Resizing
+ -----------------------------------------------------------------------------*/
+
+ // for TIMESLOT events
+
+ function resizableSlotEvent(event, eventElement, timeElement) {
+ if (!options.disableResizing && eventElement.resizable) {
+ var slotDelta, prevSlotDelta;
+ eventElement.resizable({
+ handles: {
+ s: 'div.ui-resizable-s'
+ },
+ grid: slotHeight,
+ start: function(ev, ui) {
+ slotDelta = prevSlotDelta = 0;
+ view.hideEvents(event, eventElement);
+ if ($.browser.msie && $.browser.version == '6.0') {
+ eventElement.css('overflow', 'hidden');
+ }
+ eventElement.css('z-index', 9);
+ view.trigger('eventResizeStart', this, event, ev, ui);
+ },
+ resize: function(ev, ui) {
+ // don't rely on ui.size.height, doesn't take grid into account
+ slotDelta = Math.round((Math.max(slotHeight, eventElement.height()) - ui.originalSize.height) / slotHeight);
+ if (slotDelta != prevSlotDelta) {
+ timeElement.text(
+ formatDates(
+ event.start,
+ (!slotDelta && !event.end) ? null : // no change, so don't display time range
+ addMinutes(view.eventEnd(event), options.slotMinutes * slotDelta),
+ view.option('timeFormat')
+ )
+ );
+ prevSlotDelta = slotDelta;
+ }
+ },
+ stop: function(ev, ui) {
+ view.trigger('eventResizeStop', this, event, ev, ui);
+ if (slotDelta) {
+ view.eventResize(this, event, 0, options.slotMinutes * slotDelta, ev, ui);
+ } else {
+ eventElement.css('z-index', 8);
+ view.showEvents(event, eventElement);
+ // BUG: if event was really short, need to put title back in span
+ }
+ }
+ });
+ }
+ }
+
+
+ /* Selecting
+ -----------------------------------------------------------------------------*/
+
+ daySelectionManager = new SelectionManager(
+ view,
+ unselect,
+ function(startDate, endDate, allDay) {
+ renderDayOverlay(
+ selectionMatrix,
+ startDate,
+ addDays(cloneDate(endDate), 1)
+ );
+ },
+ clearSelection
+ );
+
+ function daySelectionMousedown(ev) {
+ if (view.option('selectable')) {
+ selectionMatrix = buildDayMatrix(function(cell) {
+ if (cell) {
+ var d = dayColDate(cell.col);
+ daySelectionManager.drag(d, d, true);
+ } else {
+ daySelectionManager.drag();
+ }
+ });
+ documentDragHelp(
+ function(ev) {
+ selectionMatrix.mouse(ev);
+ },
+ function(ev) {
+ daySelectionManager.dragStop(ev);
+ }
+ );
+ daySelectionManager.dragStart(ev);
+ selectionMatrix.mouse(ev);
+ return false; // prevent auto-unselect and text selection
+ }
+ }
+
+ slotSelectionManager = new SelectionManager(
+ view,
+ unselect,
+ renderSlotSelection,
+ clearSelection
+ );
+
+ function slotSelectionMousedown(ev) {
+ if (view.option('selectable')) {
+ selectionMatrix = buildSlotMatrix(function(cell) {
+ if (cell) {
+ var d = slotCellDate(cell.row, cell.origCol);
+ slotSelectionManager.drag(d, addMinutes(cloneDate(d), options.slotMinutes), false);
+ } else {
+ slotSelectionManager.drag();
+ }
+ });
+ documentDragHelp(
+ function(ev) {
+ selectionMatrix.mouse(ev);
+ },
+ function(ev) {
+ slotSelectionManager.dragStop(ev);
+ }
+ );
+ slotSelectionManager.dragStart(ev);
+ selectionMatrix.mouse(ev);
+ return false; // prevent auto-unselect and text selection
+ }
+ }
+
+ documentUnselectAuto(view, unselect);
+
+ this.select = function(start, end, allDay) {
+ if (allDay) {
+ if (options.allDaySlot) {
+ if (!end) {
+ end = cloneDate(start);
+ }
+ selectionMatrix = buildDayMatrix();
+ daySelectionManager.select(start, end, allDay);
+ }
+ } else {
+ if (!end) {
+ end = addMinutes(cloneDate(start), options.slotMinutes);
+ }
+ selectionMatrix = buildSlotMatrix();
+ slotSelectionManager.select(start, end, allDay);
+ }
+ };
+
+ function unselect() {
+ slotSelectionManager.unselect();
+ daySelectionManager.unselect();
+ }
+
+ this.unselect = unselect;
+
+
+ /* Selecting drawing utils
+ -----------------------------------------------------------------------------*/
+
+ function renderSlotSelection(startDate, endDate) {
+ var helperOption = view.option('selectHelper');
+ if (helperOption) {
+ var col = dayDiff(startDate, view.visStart);
+ if (col >= 0 && col < colCnt) { // only works when times are on same day
+ var rect = selectionMatrix.rect(0, col * dis + dit, 1, col * dis + dit + 1, bodyContent); // only for horizontal coords
+ var top = timePosition(startDate, startDate);
+ var bottom = timePosition(startDate, endDate);
+ if (bottom > top) { // protect against selections that are entirely before or after visible range
+ rect.top = top;
+ rect.height = bottom - top;
+ rect.left += 2;
+ rect.width -= 5;
+ if ($.isFunction(helperOption)) {
+ var helperRes = helperOption(startDate, endDate);
+ if (helperRes) {
+ rect.position = 'absolute';
+ rect.zIndex = 8;
+ selectionHelper = $(helperRes)
+ .css(rect)
+ .appendTo(bodyContent);
+ }
+ } else {
+ selectionHelper = $(slotSegHtml(
+ {
+ title: '',
+ start: startDate,
+ end: endDate,
+ className: [],
+ editable: false
+ },
+ rect,
+ 'fc-event fc-event-vert fc-corner-top fc-corner-bottom '
+ ));
+ if ($.browser.msie) {
+ selectionHelper.find('span.fc-event-bg').hide(); // nested opacities mess up in IE, just hide
+ }
+ selectionHelper.css('opacity', view.option('dragOpacity'));
+ }
+ if (selectionHelper) {
+ slotBind(selectionHelper);
+ bodyContent.append(selectionHelper);
+ setOuterWidth(selectionHelper, rect.width, true); // needs to be after appended
+ setOuterHeight(selectionHelper, rect.height, true);
+ }
+ }
+ }
+ } else {
+ renderSlotOverlay(selectionMatrix, startDate, endDate);
+ }
+ }
+
+ function clearSelection() {
+ clearOverlays();
+ if (selectionHelper) {
+ selectionHelper.remove();
+ selectionHelper = null;
+ }
+ }
+
+
+ /* Semi-transparent Overlay Helpers
+ -----------------------------------------------------*/
+
+ function renderDayOverlay(matrix, startDate, endDate) {
+ var startCol, endCol;
+ if (rtl) {
+ startCol = dayDiff(endDate, view.visStart) * dis + dit + 1;
+ endCol = dayDiff(startDate, view.visStart) * dis + dit + 1;
+ } else {
+ startCol = dayDiff(startDate, view.visStart);
+ endCol = dayDiff(endDate, view.visStart);
+ }
+ startCol = Math.max(0, startCol);
+ endCol = Math.min(colCnt, endCol);
+ if (startCol < endCol) {
+ var rect = matrix.rect(0, startCol, 1, endCol, head);
+ dayBind(
+ view.renderOverlay(rect, head)
+ );
+ }
+ }
+
+ function renderSlotOverlay(matrix, overlayStart, overlayEnd) {
+ var dayStart = cloneDate(view.visStart);
+ var dayEnd = addDays(cloneDate(dayStart), 1);
+ for (var i = 0; i < colCnt; i++) {
+ var stretchStart = new Date(Math.max(dayStart, overlayStart));
+ var stretchEnd = new Date(Math.min(dayEnd, overlayEnd));
+ if (stretchStart < stretchEnd) {
+ var rect = matrix.rect(0, i * dis + dit, 1, i * dis + dit + 1, bodyContent); // only use it for horizontal coords
+ var top = timePosition(dayStart, stretchStart);
+ var bottom = timePosition(dayStart, stretchEnd);
+ rect.top = top;
+ rect.height = bottom - top;
+ slotBind(
+ view.renderOverlay(rect, bodyContent)
+ );
+ }
+ addDays(dayStart, 1);
+ addDays(dayEnd, 1);
+ }
+ }
+
+ function clearOverlays() {
+ view.clearOverlays();
+ }
+
+
+ /* Coordinate Utilities
+ -----------------------------------------------------------------------------*/
+
+ // get the Y coordinate of the given time on the given day (both Date objects)
+ function timePosition(day, time) { // both date objects. day holds 00:00 of current day
+ day = cloneDate(day, true);
+ if (time < addMinutes(cloneDate(day), minMinute)) {
+ return 0;
+ }
+ if (time >= addMinutes(cloneDate(day), maxMinute)) {
+ return bodyContent.height();
+ }
+ var slotMinutes = options.slotMinutes,
+ minutes = time.getHours() * 60 + time.getMinutes() - minMinute,
+ slotI = Math.floor(minutes / slotMinutes),
+ slotTop = slotTopCache[slotI];
+ if (slotTop === undefined) {
+ slotTop = slotTopCache[slotI] = body.find('tr:eq(' + slotI + ') td div')[0].offsetTop;
+ }
+ return Math.max(0, Math.round(
+ slotTop - 1 + slotHeight * ((minutes % slotMinutes) / slotMinutes)
+ ));
+ }
+
+ function buildDayMatrix(changeCallback, includeSlotArea) {
+ var rowElements = options.allDaySlot ? head.find('td') : $([]);
+ if (includeSlotArea) {
+ rowElements = rowElements.add(body);
+ }
+ return new HoverMatrix(rowElements, bg.find('td'), changeCallback);
+ }
+
+ function buildSlotMatrix(changeCallback) {
+ return new HoverMatrix(bodyTable.find('td'), bg.find('td'), changeCallback);
+ }
+
+
+ /* Date Utilities
+ ----------------------------------------------------*/
+
+ function slotEventEnd(event) {
+ if (event.end) {
+ return cloneDate(event.end);
+ } else {
+ return addMinutes(cloneDate(event.start), options.defaultEventMinutes);
+ }
+ }
+
+ function dayOfWeekCol(dayOfWeek) {
+ return ((dayOfWeek - Math.max(firstDay, nwe) + colCnt) % colCnt) * dis + dit;
+ }
+
+
+ // generating dates from cell row & columns
+
+ function dayColDate(col) {
+ return addDays(cloneDate(view.visStart), col * dis + dit);
+ }
+
+ function slotCellDate(row, col) {
+ var d = dayColDate(col);
+ addMinutes(d, minMinute + row * options.slotMinutes);
+ return d;
+ }
+
+
+ }
+
+
+ // count the number of colliding, higher-level segments (for event squishing)
+
+ function countForwardSegs(levels) {
+ var i, j, k, level, segForward, segBack;
+ for (i = levels.length - 1; i > 0; i--) {
+ level = levels[i];
+ for (j = 0; j < level.length; j++) {
+ segForward = level[j];
+ for (k = 0; k < levels[i - 1].length; k++) {
+ segBack = levels[i - 1][k];
+ if (segsCollide(segForward, segBack)) {
+ segBack.forward = Math.max(segBack.forward || 0, (segForward.forward || 0) + 1);
+ }
+ }
+ }
+ }
+ }
+
+
+ /* Methods & Utilities for All Views
+ -----------------------------------------------------------------------------*/
+
+ var viewMethods = {
+
+ /*
+ * Objects inheriting these methods must implement the following properties/methods:
+ * - title
+ * - start
+ * - end
+ * - visStart
+ * - visEnd
+ * - defaultEventEnd(event)
+ * - render(events)
+ * - rerenderEvents()
+ *
+ *
+ * z-index reservations:
+ * 3 - day-overlay
+ * 8 - events
+ * 9 - dragging/resizing events
+ *
+ */
+
+
+
+ init: function(element, options) {
+ this.element = element;
+ this.options = options;
+ this.eventsByID = {};
+ this.eventElements = [];
+ this.eventElementsByID = {};
+ this.usedOverlays = [];
+ this.unusedOverlays = [];
+ },
- init: function(element, options) {
- this.element = element;
- this.options = options;
- this.eventsByID = {};
- this.eventElements = [];
- this.eventElementsByID = {};
- },
-
-
-
- // triggers an event handler, always append view as last arg
-
- trigger: function(name, thisObj) {
- if (this.options[name]) {
- return this.options[name].apply(thisObj || this, Array.prototype.slice.call(arguments, 2).concat([this]));
- }
- },
-
-
-
- // returns a Date object for an event's end
-
- eventEnd: function(event) {
- return event.end ? cloneDate(event.end) : this.defaultEventEnd(event); // TODO: make sure always using copies
- },
-
-
-
- // report when view receives new events
-
- reportEvents: function(events) { // events are already normalized at this point
- var i, len=events.length, event,
- eventsByID = this.eventsByID = {};
- for (i=0; i
")
- .appendTo(this.element);
- }
- var o = this.element.offset();
- this.dayOverlay
- .css({
- top: props.top - o.top,
- left: props.left - o.left,
- width: props.width,
- height: props.height
- })
- .show();
- },
-
- hideOverlay: function() {
- if (this.dayOverlay) {
- this.dayOverlay.hide();
- }
- },
-
-
-
- // common horizontal event resizing
-
- resizableDayEvent: function(event, eventElement, colWidth) {
- var view = this;
- if (!view.options.disableResizing && eventElement.resizable) {
- eventElement.resizable({
- handles: view.options.isRTL ? {w:'div.ui-resizable-w'} : {e:'div.ui-resizable-e'},
- grid: colWidth,
- minWidth: colWidth/2, // need this or else IE throws errors when too small
- containment: view.element.parent().parent(), // the main element...
- // ... a fix. wouldn't allow extending to last column in agenda views (jq ui bug?)
- start: function(ev, ui) {
- eventElement.css('z-index', 9);
- view.hideEvents(event, eventElement);
- view.trigger('eventResizeStart', this, event, ev, ui);
- },
- stop: function(ev, ui) {
- view.trigger('eventResizeStop', this, event, ev, ui);
- // ui.size.width wasn't working with grid correctly, use .width()
- var dayDelta = Math.round((eventElement.width() - ui.originalSize.width) / colWidth);
- if (dayDelta) {
- view.eventResize(this, event, dayDelta, 0, ev, ui);
- }else{
- eventElement.css('z-index', 8);
- view.showEvents(event, eventElement);
- }
- }
- });
- }
- },
-
-
-
- // attaches eventClick, eventMouseover, eventMouseout
-
- eventElementHandlers: function(event, eventElement) {
- var view = this;
- eventElement
- .click(function(ev) {
- if (!eventElement.hasClass('ui-draggable-dragging') &&
- !eventElement.hasClass('ui-resizable-resizing')) {
- return view.trigger('eventClick', this, event, ev);
- }
- })
- .hover(
- function(ev) {
- view.trigger('eventMouseover', this, event, ev);
- },
- function(ev) {
- view.trigger('eventMouseout', this, event, ev);
- }
- );
- },
-
-
-
- // get a property from the 'options' object, using smart view naming
-
- option: function(name, viewName) {
- var v = this.options[name];
- if (typeof v == 'object') {
- return smartProperty(v, viewName || this.name);
- }
- return v;
- },
-
-
-
- // event rendering utilities
-
- sliceSegs: function(events, visEventEnds, start, end) {
- var segs = [],
- i, len=events.length, event,
- eventStart, eventEnd,
- segStart, segEnd,
- isStart, isEnd;
- for (i=0; i
start && eventStart < end) {
- if (eventStart < start) {
- segStart = cloneDate(start);
- isStart = false;
- }else{
- segStart = eventStart;
- isStart = true;
- }
- if (eventEnd > end) {
- segEnd = cloneDate(end);
- isEnd = false;
- }else{
- segEnd = eventEnd;
- isEnd = true;
- }
- segs.push({
- event: event,
- start: segStart,
- end: segEnd,
- isStart: isStart,
- isEnd: isEnd,
- msLength: segEnd - segStart
- });
- }
- }
- return segs.sort(segCmp);
- }
-
-
-};
-
-
-
-function lazySegBind(container, segs, bindHandlers) {
- container.unbind('mouseover').mouseover(function(ev) {
- var parent=ev.target, e,
- i, seg;
- while (parent != this) {
- e = parent;
- parent = parent.parentNode;
- }
- if ((i = e._fci) != undefined) {
- e._fci = undefined;
- seg = segs[i];
- bindHandlers(seg.event, seg.element, seg);
- $(ev.target).trigger(ev);
- }
- ev.stopPropagation();
- });
-}
-
-
-
-// event rendering calculation utilities
-
-function stackSegs(segs) {
- var levels = [],
- i, len = segs.length, seg,
- j, collide, k;
- for (i=0; i seg2.start && seg1.start < seg2.end;
-}
-
-
-
-
-/* Date Math
------------------------------------------------------------------------------*/
-
-var DAY_MS = 86400000,
- HOUR_MS = 3600000,
- MINUTE_MS = 60000;
-
-function addYears(d, n, keepTime) {
- d.setFullYear(d.getFullYear() + n);
- if (!keepTime) {
- clearTime(d);
- }
- return d;
-}
-
-function addMonths(d, n, keepTime) { // prevents day overflow/underflow
- if (+d) { // prevent infinite looping on invalid dates
- var m = d.getMonth() + n,
- check = cloneDate(d);
- check.setDate(1);
- check.setMonth(m);
- d.setMonth(m);
- if (!keepTime) {
- clearTime(d);
- }
- while (d.getMonth() != check.getMonth()) {
- d.setDate(d.getDate() + (d < check ? 1 : -1));
- }
- }
- return d;
-}
-
-function addDays(d, n, keepTime) { // deals with daylight savings
- if (+d) {
- var dd = d.getDate() + n,
- check = cloneDate(d);
- check.setHours(9); // set to middle of day
- check.setDate(dd);
- d.setDate(dd);
- if (!keepTime) {
- clearTime(d);
- }
- fixDate(d, check);
- }
- return d;
-}
-fc.addDays = addDays;
-
-function fixDate(d, check) { // force d to be on check's YMD, for daylight savings purposes
- if (+d) { // prevent infinite looping on invalid dates
- while (d.getDate() != check.getDate()) {
- d.setTime(+d + (d < check ? 1 : -1) * HOUR_MS);
- }
- }
-}
-
-function addMinutes(d, n) {
- d.setMinutes(d.getMinutes() + n);
- return d;
-}
-
-function clearTime(d) {
- d.setHours(0);
- d.setMinutes(0);
- d.setSeconds(0);
- d.setMilliseconds(0);
- return d;
-}
-
-function cloneDate(d, dontKeepTime) {
- if (dontKeepTime) {
- return clearTime(new Date(+d));
- }
- return new Date(+d);
-}
-
-function zeroDate() { // returns a Date with time 00:00:00 and dateOfMonth=1
- var i=0, d;
- do {
- d = new Date(1970, i++, 1);
- } while (d.getHours() != 0);
- return d;
-}
-
-function skipWeekend(date, inc, excl) {
- inc = inc || 1;
- while (date.getDay()==0 || (excl && date.getDay()==1 || !excl && date.getDay()==6)) {
- addDays(date, inc);
- }
- return date;
-}
-
-
-
-/* Date Parsing
------------------------------------------------------------------------------*/
-
-var parseDate = fc.parseDate = function(s) {
- if (typeof s == 'object') { // already a Date object
- return s;
- }
- if (typeof s == 'number') { // a UNIX timestamp
- return new Date(s * 1000);
- }
- if (typeof s == 'string') {
- if (s.match(/^\d+$/)) { // a UNIX timestamp
- return new Date(parseInt(s) * 1000);
- }
- return parseISO8601(s, true) || (s ? new Date(s) : null);
- }
- // TODO: never return invalid dates (like from new Date()), return null instead
- return null;
-}
-
-var parseISO8601 = fc.parseISO8601 = function(s, ignoreTimezone) {
- // derived from http://delete.me.uk/2005/03/iso8601.html
- // TODO: for a know glitch/feature, read tests/issue_206_parseDate_dst.html
- var m = s.match(/^([0-9]{4})(-([0-9]{2})(-([0-9]{2})([T ]([0-9]{2}):([0-9]{2})(:([0-9]{2})(\.([0-9]+))?)?(Z|(([-+])([0-9]{2}):([0-9]{2})))?)?)?)?$/);
- if (!m) {
- return null;
- }
- var date = new Date(m[1], 0, 1),
- check = new Date(m[1], 0, 1, 9, 0),
- offset = 0;
- if (m[3]) {
- date.setMonth(m[3] - 1);
- check.setMonth(m[3] - 1);
- }
- if (m[5]) {
- date.setDate(m[5]);
- check.setDate(m[5]);
- }
- fixDate(date, check);
- if (m[7]) {
- date.setHours(m[7]);
- }
- if (m[8]) {
- date.setMinutes(m[8]);
- }
- if (m[10]) {
- date.setSeconds(m[10]);
- }
- if (m[12]) {
- date.setMilliseconds(Number("0." + m[12]) * 1000);
- }
- fixDate(date, check);
- if (!ignoreTimezone) {
- if (m[14]) {
- offset = Number(m[16]) * 60 + Number(m[17]);
- offset *= m[15] == '-' ? 1 : -1;
- }
- offset -= date.getTimezoneOffset();
- }
- return new Date(+date + (offset * 60 * 1000));
-}
-
-var parseTime = fc.parseTime = function(s) { // returns minutes since start of day
- if (typeof s == 'number') { // an hour
- return s * 60;
- }
- if (typeof s == 'object') { // a Date object
- return s.getHours() * 60 + s.getMinutes();
- }
- var m = s.match(/(\d+)(?::(\d+))?\s*(\w+)?/);
- if (m) {
- var h = parseInt(m[1]);
- if (m[3]) {
- h %= 12;
- if (m[3].toLowerCase().charAt(0) == 'p') {
- h += 12;
- }
- }
- return h * 60 + (m[2] ? parseInt(m[2]) : 0);
- }
-};
-
-
-
-/* Date Formatting
------------------------------------------------------------------------------*/
-
-var formatDate = fc.formatDate = function(date, format, options) {
- return formatDates(date, null, format, options);
-}
-
-var formatDates = fc.formatDates = function(date1, date2, format, options) {
- options = options || defaults;
- var date = date1,
- otherDate = date2,
- i, len = format.length, c,
- i2, formatter,
- res = '';
- for (i=0; ii; i2--) {
- if (formatter = dateFormatters[format.substring(i, i2)]) {
- if (date) {
- res += formatter(date, options);
- }
- i = i2 - 1;
- break;
- }
- }
- if (i2 == i) {
- if (date) {
- res += c;
- }
- }
- }
- }
- return res;
-}
-
-var dateFormatters = {
- s : function(d) { return d.getSeconds() },
- ss : function(d) { return zeroPad(d.getSeconds()) },
- m : function(d) { return d.getMinutes() },
- mm : function(d) { return zeroPad(d.getMinutes()) },
- h : function(d) { return d.getHours() % 12 || 12 },
- hh : function(d) { return zeroPad(d.getHours() % 12 || 12) },
- H : function(d) { return d.getHours() },
- HH : function(d) { return zeroPad(d.getHours()) },
- d : function(d) { return d.getDate() },
- dd : function(d) { return zeroPad(d.getDate()) },
- ddd : function(d,o) { return o.dayNamesShort[d.getDay()] },
- dddd: function(d,o) { return o.dayNames[d.getDay()] },
- M : function(d) { return d.getMonth() + 1 },
- MM : function(d) { return zeroPad(d.getMonth() + 1) },
- MMM : function(d,o) { return o.monthNamesShort[d.getMonth()] },
- MMMM: function(d,o) { return o.monthNames[d.getMonth()] },
- yy : function(d) { return (d.getFullYear()+'').substring(2) },
- yyyy: function(d) { return d.getFullYear() },
- t : function(d) { return d.getHours() < 12 ? 'a' : 'p' },
- tt : function(d) { return d.getHours() < 12 ? 'am' : 'pm' },
- T : function(d) { return d.getHours() < 12 ? 'A' : 'P' },
- TT : function(d) { return d.getHours() < 12 ? 'AM' : 'PM' },
- u : function(d) { return formatDate(d, "yyyy-MM-dd'T'HH:mm:ss'Z'") },
- S : function(d) {
- var date = d.getDate();
- if (date > 10 && date < 20) return 'th';
- return ['st', 'nd', 'rd'][date%10-1] || 'th';
- }
-};
-
-
-
-/* Element Dimensions
------------------------------------------------------------------------------*/
-
-function setOuterWidth(element, width, includeMargins) {
- element.each(function(i, _element) {
- _element.style.width = width - hsides(_element, includeMargins) + 'px';
- });
-}
-
-function setOuterHeight(element, height, includeMargins) {
- element.each(function(i, _element) {
- _element.style.height = height - vsides(_element, includeMargins) + 'px';
- });
-}
-
-
-function hsides(_element, includeMargins) {
- return (parseFloat(jQuery.curCSS(_element, 'paddingLeft', true)) || 0) +
- (parseFloat(jQuery.curCSS(_element, 'paddingRight', true)) || 0) +
- (parseFloat(jQuery.curCSS(_element, 'borderLeftWidth', true)) || 0) +
- (parseFloat(jQuery.curCSS(_element, 'borderRightWidth', true)) || 0) +
- (includeMargins ? hmargins(_element) : 0);
-}
-
-function hmargins(_element) {
- return (parseFloat(jQuery.curCSS(_element, 'marginLeft', true)) || 0) +
- (parseFloat(jQuery.curCSS(_element, 'marginRight', true)) || 0);
-}
-
-function vsides(_element, includeMargins) {
- return (parseFloat(jQuery.curCSS(_element, 'paddingTop', true)) || 0) +
- (parseFloat(jQuery.curCSS(_element, 'paddingBottom', true)) || 0) +
- (parseFloat(jQuery.curCSS(_element, 'borderTopWidth', true)) || 0) +
- (parseFloat(jQuery.curCSS(_element, 'borderBottomWidth', true)) || 0) +
- (includeMargins ? vmargins(_element) : 0);
-}
-
-function vmargins(_element) {
- return (parseFloat(jQuery.curCSS(_element, 'marginTop', true)) || 0) +
- (parseFloat(jQuery.curCSS(_element, 'marginBottom', true)) || 0);
-}
-
-
-
-
-function setMinHeight(element, h) {
- h = typeof h == 'number' ? h + 'px' : h;
- element[0].style.cssText += ';min-height:' + h + ';_height:' + h;
-}
-
-
-
-/* Position Calculation
------------------------------------------------------------------------------*/
-// nasty bugs in opera 9.25
-// position()'s top returning incorrectly with TR/TD or elements within TD
-
-var topBug;
-
-function topCorrect(tr) { // tr/th/td or anything else
- if (topBug !== false) {
- var cell;
- if (tr.is('th,td')) {
- tr = (cell = tr).parent();
- }
- if (topBug == undefined && tr.is('tr')) {
- topBug = tr.position().top != tr.children().position().top;
- }
- if (topBug) {
- return tr.parent().position().top + (cell ? tr.position().top - cell.position().top : 0);
- }
- }
- return 0;
-}
-
-
-
-/* Hover Matrix
------------------------------------------------------------------------------*/
-
-function HoverMatrix(changeCallback) {
-
- var t=this,
- tops=[], lefts=[],
- prevRowE, prevColE,
- origRow, origCol,
- currRow, currCol;
-
- t.row = function(e) {
- prevRowE = $(e);
- tops.push(prevRowE.offset().top + topCorrect(prevRowE));
- };
-
- t.col = function(e) {
- prevColE = $(e);
- lefts.push(prevColE.offset().left);
- };
-
- t.mouse = function(x, y) {
- if (origRow == undefined) {
- tops.push(tops[tops.length-1] + prevRowE.outerHeight());
- lefts.push(lefts[lefts.length-1] + prevColE.outerWidth());
- currRow = currCol = -1;
- }
- var r, c;
- for (r=0; r=tops[r]; r++) ;
- for (c=0; c=lefts[c]; c++) ;
- r = r >= tops.length ? -1 : r - 1;
- c = c >= lefts.length ? -1 : c - 1;
- if (r != currRow || c != currCol) {
- currRow = r;
- currCol = c;
- if (r == -1 || c == -1) {
- t.cell = null;
- }else{
- if (origRow == undefined) {
- origRow = r;
- origCol = c;
- }
- t.cell = {
- row: r,
- col: c,
- top: tops[r],
- left: lefts[c],
- width: lefts[c+1] - lefts[c],
- height: tops[r+1] - tops[r],
- isOrig: r==origRow && c==origCol,
- rowDelta: r-origRow,
- colDelta: c-origCol
- };
- }
- changeCallback(t.cell);
- }
- };
-
-}
-
-
-
-/* Misc Utils
------------------------------------------------------------------------------*/
-
-var undefined,
- dayIDs = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'],
- arrayPop = Array.prototype.pop;
-
-function zeroPad(n) {
- return (n < 10 ? '0' : '') + n;
-}
-
-function smartProperty(obj, name) { // get a camel-cased/namespaced property of an object
- if (obj[name] != undefined) {
- return obj[name];
- }
- var parts = name.split(/(?=[A-Z])/),
- i=parts.length-1, res;
- for (; i>=0; i--) {
- res = obj[parts[i].toLowerCase()];
- if (res != undefined) {
- return res;
- }
- }
- return obj[''];
-}
-
-function htmlEscape(s) {
- return s
- .replace(/&/g, '&')
- .replace(//g, '>')
- .replace(/'/g, ''')
- .replace(/"/g, '"')
-}
-
-
-
-function HorizontalPositionCache(getElement) {
-
- var t = this,
- elements = {},
- lefts = {},
- rights = {};
-
- function e(i) {
- return elements[i] =
- elements[i] || getElement(i);
- }
-
- t.left = function(i) {
- return lefts[i] =
- lefts[i] == undefined ? e(i).position().left : lefts[i];
- };
-
- t.right = function(i) {
- return rights[i] =
- rights[i] == undefined ? t.left(i) + e(i).width() : rights[i];
- };
-
- t.clear = function() {
- elements = {};
- lefts = {};
- rights = {};
- };
-
-}
-
-
-
-function cssKey(_element) {
- return _element.id + '/' + _element.className + '/' + _element.style.cssText.replace(/(^|;)\s*(top|left|width|height)\s*:[^;]*/ig, '');
-}
+ // triggers an event handler, always append view as last arg
+
+ trigger: function(name, thisObj) {
+ if (this.options[name]) {
+ return this.options[name].apply(thisObj || this, Array.prototype.slice.call(arguments, 2).concat([this]));
+ }
+ },
+
+
+ // returns a Date object for an event's end
+ eventEnd: function(event) {
+ return event.end ? cloneDate(event.end) : this.defaultEventEnd(event); // TODO: make sure always using copies
+ },
+
+
+
+ // report when view receives new events
+
+ reportEvents: function(events) { // events are already normalized at this point
+ var i, len = events.length, event,
+ eventsByID = this.eventsByID = {};
+ for (i = 0; i < len; i++) {
+ event = events[i];
+ if (eventsByID[event._id]) {
+ eventsByID[event._id].push(event);
+ } else {
+ eventsByID[event._id] = [event];
+ }
+ }
+ },
+
+
+
+ // report when view creates an element for an event
+
+ reportEventElement: function(event, element) {
+ this.eventElements.push(element);
+ var eventElementsByID = this.eventElementsByID;
+ if (eventElementsByID[event._id]) {
+ eventElementsByID[event._id].push(element);
+ } else {
+ eventElementsByID[event._id] = [element];
+ }
+ },
+
+
+
+ // event element manipulation
+
+ _clearEvents: function() { // only resets hashes
+ this.eventElements = [];
+ this.eventElementsByID = {};
+ },
+
+ showEvents: function(event, exceptElement) {
+ this._eee(event, exceptElement, 'show');
+ },
+
+ hideEvents: function(event, exceptElement) {
+ this._eee(event, exceptElement, 'hide');
+ },
+
+ _eee: function(event, exceptElement, funcName) { // event-element-each
+ var elements = this.eventElementsByID[event._id],
+ i, len = elements.length;
+ for (i = 0; i < len; i++) {
+ if (elements[i][0] != exceptElement[0]) { // AHAHAHAHAHAHAHAH
+ elements[i][funcName]();
+ }
+ }
+ },
+
+
+
+ // event modification reporting
+
+ eventDrop: function(e, event, dayDelta, minuteDelta, allDay, ev, ui) {
+ var view = this,
+ oldAllDay = event.allDay,
+ eventId = event._id;
+ view.moveEvents(view.eventsByID[eventId], dayDelta, minuteDelta, allDay);
+ view.trigger('eventDrop', e, event, dayDelta, minuteDelta, allDay, function() { // TODO: change docs
+ // TODO: investigate cases where this inverse technique might not work
+ view.moveEvents(view.eventsByID[eventId], -dayDelta, -minuteDelta, oldAllDay);
+ view.rerenderEvents();
+ }, ev, ui);
+ view.eventsChanged = true;
+ view.rerenderEvents(eventId);
+ },
+
+ eventResize: function(e, event, dayDelta, minuteDelta, ev, ui) {
+ var view = this,
+ eventId = event._id;
+ view.elongateEvents(view.eventsByID[eventId], dayDelta, minuteDelta);
+ view.trigger('eventResize', e, event, dayDelta, minuteDelta, function() {
+ // TODO: investigate cases where this inverse technique might not work
+ view.elongateEvents(view.eventsByID[eventId], -dayDelta, -minuteDelta);
+ view.rerenderEvents();
+ }, ev, ui);
+ view.eventsChanged = true;
+ view.rerenderEvents(eventId);
+ },
+
+
+
+ // event modification
+
+ moveEvents: function(events, dayDelta, minuteDelta, allDay) {
+ minuteDelta = minuteDelta || 0;
+ for (var e, len = events.length, i = 0; i < len; i++) {
+ e = events[i];
+ if (allDay !== undefined) {
+ e.allDay = allDay;
+ }
+ addMinutes(addDays(e.start, dayDelta, true), minuteDelta);
+ if (e.end) {
+ e.end = addMinutes(addDays(e.end, dayDelta, true), minuteDelta);
+ }
+ normalizeEvent(e, this.options);
+ }
+ },
+
+ elongateEvents: function(events, dayDelta, minuteDelta) {
+ minuteDelta = minuteDelta || 0;
+ for (var e, len = events.length, i = 0; i < len; i++) {
+ e = events[i];
+ e.end = addMinutes(addDays(this.eventEnd(e), dayDelta, true), minuteDelta);
+ normalizeEvent(e, this.options);
+ }
+ },
+
+
+
+ // semi-transparent overlay (while dragging or selecting)
+
+ renderOverlay: function(rect, parent) {
+ var e = this.unusedOverlays.shift();
+ if (!e) {
+ e = $("");
+ }
+ if (e[0].parentNode != parent[0]) {
+ e.appendTo(parent);
+ }
+ this.usedOverlays.push(e.css(rect).show());
+ return e;
+ },
+
+ clearOverlays: function() {
+ var e;
+ while (e = this.usedOverlays.shift()) {
+ this.unusedOverlays.push(e.hide().unbind());
+ }
+ },
+
+
+
+
+ // common horizontal event resizing
+
+ resizableDayEvent: function(event, eventElement, colWidth) {
+ var view = this;
+ if (!view.options.disableResizing && eventElement.resizable) {
+ eventElement.resizable({
+ handles: view.options.isRTL ? {w:'div.ui-resizable-w'} : {e:'div.ui-resizable-e'},
+ grid: colWidth,
+ minWidth: colWidth / 2, // need this or else IE throws errors when too small
+ containment: view.element.parent().parent(), // the main element...
+ // ... a fix. wouldn't allow extending to last column in agenda views (jq ui bug?)
+ start: function(ev, ui) {
+ eventElement.css('z-index', 9);
+ view.hideEvents(event, eventElement);
+ view.trigger('eventResizeStart', this, event, ev, ui);
+ },
+ stop: function(ev, ui) {
+ view.trigger('eventResizeStop', this, event, ev, ui);
+ // ui.size.width wasn't working with grid correctly, use .width()
+ var dayDelta = Math.round((eventElement.width() - ui.originalSize.width) / colWidth);
+ if (dayDelta) {
+ view.eventResize(this, event, dayDelta, 0, ev, ui);
+ } else {
+ eventElement.css('z-index', 8);
+ view.showEvents(event, eventElement);
+ }
+ }
+ });
+ }
+ },
+
+
+
+ // attaches eventClick, eventMouseover, eventMouseout
+
+ eventElementHandlers: function(event, eventElement) {
+ var view = this;
+ eventElement
+ .click(function(ev) {
+ if (!eventElement.hasClass('ui-draggable-dragging') &&
+ !eventElement.hasClass('ui-resizable-resizing')) {
+ return view.trigger('eventClick', this, event, ev);
+ }
+ })
+ .hover(
+ function(ev) {
+ view.trigger('eventMouseover', this, event, ev);
+ },
+ function(ev) {
+ view.trigger('eventMouseout', this, event, ev);
+ }
+ );
+ },
+
+
+
+ // get a property from the 'options' object, using smart view naming
+
+ option: function(name, viewName) {
+ var v = this.options[name];
+ if (typeof v == 'object') {
+ return smartProperty(v, viewName || this.name);
+ }
+ return v;
+ },
+
+
+
+ // event rendering utilities
+
+ sliceSegs: function(events, visEventEnds, start, end) {
+ var segs = [],
+ i, len = events.length, event,
+ eventStart, eventEnd,
+ segStart, segEnd,
+ isStart, isEnd;
+ for (i = 0; i < len; i++) {
+ event = events[i];
+ eventStart = event.start;
+ eventEnd = visEventEnds[i];
+ if (eventEnd > start && eventStart < end) {
+ if (eventStart < start) {
+ segStart = cloneDate(start);
+ isStart = false;
+ } else {
+ segStart = eventStart;
+ isStart = true;
+ }
+ if (eventEnd > end) {
+ segEnd = cloneDate(end);
+ isEnd = false;
+ } else {
+ segEnd = eventEnd;
+ isEnd = true;
+ }
+ segs.push({
+ event: event,
+ start: segStart,
+ end: segEnd,
+ isStart: isStart,
+ isEnd: isEnd,
+ msLength: segEnd - segStart
+ });
+ }
+ }
+ return segs.sort(segCmp);
+ }
+
+
+ };
+
+
+ function lazySegBind(container, segs, bindHandlers) {
+ container.unbind('mouseover').mouseover(function(ev) {
+ var parent = ev.target, e,
+ i, seg;
+ while (parent != this) {
+ e = parent;
+ parent = parent.parentNode;
+ }
+ if ((i = e._fci) !== undefined) {
+ e._fci = undefined;
+ seg = segs[i];
+ bindHandlers(seg.event, seg.element, seg);
+ $(ev.target).trigger(ev);
+ }
+ ev.stopPropagation();
+ });
+ }
+
+
+ // event rendering calculation utilities
+
+ function stackSegs(segs) {
+ var levels = [],
+ i, len = segs.length, seg,
+ j, collide, k;
+ for (i = 0; i < len; i++) {
+ seg = segs[i];
+ j = 0; // the level index where seg should belong
+ while (true) {
+ collide = false;
+ if (levels[j]) {
+ for (k = 0; k < levels[j].length; k++) {
+ if (segsCollide(levels[j][k], seg)) {
+ collide = true;
+ break;
+ }
+ }
+ }
+ if (collide) {
+ j++;
+ } else {
+ break;
+ }
+ }
+ if (levels[j]) {
+ levels[j].push(seg);
+ } else {
+ levels[j] = [seg];
+ }
+ }
+ return levels;
+ }
+
+ function segCmp(a, b) {
+ return (b.msLength - a.msLength) * 100 + (a.event.start - b.event.start);
+ }
+
+ function segsCollide(seg1, seg2) {
+ return seg1.end > seg2.start && seg1.start < seg2.end;
+ }
+
+
+ function SelectionManager(view, initFunc, displayFunc, clearFunc) {
+
+ var t = this;
+ var selected = false;
+ var initialElement;
+ var initialRange;
+ var start;
+ var end;
+ var allDay;
+
+
+ t.dragStart = function(ev) {
+ initFunc();
+ start = end = undefined;
+ initialRange = undefined;
+ initialElement = ev.currentTarget;
+ };
+
+
+ t.drag = function(currentStart, currentEnd, currentAllDay) {
+ if (currentStart) {
+ var range = [currentStart, currentEnd];
+ if (!initialRange) {
+ initialRange = range;
+ }
+ var dates = initialRange.concat(range).sort(cmp);
+ start = dates[0];
+ end = dates[3];
+ allDay = currentAllDay;
+ clearFunc();
+ displayFunc(cloneDate(start), cloneDate(end), allDay);
+ } else {
+ // called with no arguments
+ start = end = undefined;
+ clearFunc();
+ }
+ };
+
+
+ t.dragStop = function(ev) {
+ if (start) {
+ if (+initialRange[0] == +start && +initialRange[1] == +end) {
+ view.trigger('dayClick', initialElement, start, allDay, ev);
+ }
+ _select();
+ }
+ };
+
+
+ t.select = function(newStart, newEnd, newAllDay) {
+ initFunc();
+ start = newStart;
+ end = newEnd;
+ allDay = newAllDay;
+ displayFunc(cloneDate(start), cloneDate(end), allDay);
+ _select();
+ };
+
+
+ function _select() { // just set the selected flag, and trigger
+ selected = true;
+ view.trigger('select', view, start, end, allDay);
+ }
+
+
+ function unselect() {
+ if (selected) {
+ selected = false;
+ start = end = undefined;
+ clearFunc();
+ view.trigger('unselect', view);
+ }
+ }
+
+ t.unselect = unselect;
+
+ }
+
+
+ function documentDragHelp(mousemove, mouseup) {
+ function _mouseup(ev) {
+ mouseup(ev);
+ $(document)
+ .unbind('mousemove', mousemove)
+ .unbind('mouseup', _mouseup);
+ }
+
+ $(document)
+ .mousemove(mousemove)
+ .mouseup(_mouseup);
+ }
+
+
+ function documentUnselectAuto(view, unselectFunc) {
+ if (view.option('selectable') && view.option('unselectAuto')) {
+ $(document).mousedown(function(ev) {
+ var ignore = view.option('unselectCancel');
+ if (ignore) {
+ if ($(ev.target).parents(ignore).length) { // could be optimized to stop after first match
+ return;
+ }
+ }
+ unselectFunc();
+ });
+ }
+ }
+
+
+ /* Date Math
+ -----------------------------------------------------------------------------*/
+
+ var DAY_MS = 86400000,
+ HOUR_MS = 3600000,
+ MINUTE_MS = 60000;
+
+ function addYears(d, n, keepTime) {
+ d.setFullYear(d.getFullYear() + n);
+ if (!keepTime) {
+ clearTime(d);
+ }
+ return d;
+ }
+
+ function addMonths(d, n, keepTime) { // prevents day overflow/underflow
+ if (+d) { // prevent infinite looping on invalid dates
+ var m = d.getMonth() + n,
+ check = cloneDate(d);
+ check.setDate(1);
+ check.setMonth(m);
+ d.setMonth(m);
+ if (!keepTime) {
+ clearTime(d);
+ }
+ while (d.getMonth() != check.getMonth()) {
+ d.setDate(d.getDate() + (d < check ? 1 : -1));
+ }
+ }
+ return d;
+ }
+
+ function addDays(d, n, keepTime) { // deals with daylight savings
+ if (+d) {
+ var dd = d.getDate() + n,
+ check = cloneDate(d);
+ check.setHours(9); // set to middle of day
+ check.setDate(dd);
+ d.setDate(dd);
+ if (!keepTime) {
+ clearTime(d);
+ }
+ fixDate(d, check);
+ }
+ return d;
+ }
+
+ fc.addDays = addDays;
+
+ function fixDate(d, check) { // force d to be on check's YMD, for daylight savings purposes
+ if (+d) { // prevent infinite looping on invalid dates
+ while (d.getDate() != check.getDate()) {
+ d.setTime(+d + (d < check ? 1 : -1) * HOUR_MS);
+ }
+ }
+ }
+
+ function addMinutes(d, n) {
+ d.setMinutes(d.getMinutes() + n);
+ return d;
+ }
+
+ function clearTime(d) {
+ d.setHours(0);
+ d.setMinutes(0);
+ d.setSeconds(0);
+ d.setMilliseconds(0);
+ return d;
+ }
+
+ function cloneDate(d, dontKeepTime) {
+ if (dontKeepTime) {
+ return clearTime(new Date(+d));
+ }
+ return new Date(+d);
+ }
+
+ fc.cloneDate = cloneDate;
+
+ function zeroDate() { // returns a Date with time 00:00:00 and dateOfMonth=1
+ var i = 0, d;
+ do {
+ d = new Date(1970, i++, 1);
+ } while (d.getHours()); // != 0
+ return d;
+ }
+
+ function skipWeekend(date, inc, excl) {
+ inc = inc || 1;
+ while (!date.getDay() || (excl && date.getDay() == 1 || !excl && date.getDay() == 6)) {
+ addDays(date, inc);
+ }
+ return date;
+ }
+
+ function dayDiff(d1, d2) { // d1 - d2
+ return Math.round((cloneDate(d1, true) - cloneDate(d2, true)) / DAY_MS);
+ }
+
+
+ /* Date Parsing
+ -----------------------------------------------------------------------------*/
+
+ var parseDate = fc.parseDate = function(s) {
+ if (typeof s == 'object') { // already a Date object
+ return s;
+ }
+ if (typeof s == 'number') { // a UNIX timestamp
+ return new Date(s * 1000);
+ }
+ if (typeof s == 'string') {
+ if (s.match(/^\d+$/)) { // a UNIX timestamp
+ return new Date(parseInt(s) * 1000);
+ }
+ return parseISO8601(s, true) || (s ? new Date(s) : null);
+ }
+ // TODO: never return invalid dates (like from new Date()), return null instead
+ return null;
+ };
+
+ var parseISO8601 = fc.parseISO8601 = function(s, ignoreTimezone) {
+ // derived from http://delete.me.uk/2005/03/iso8601.html
+ // TODO: for a know glitch/feature, read tests/issue_206_parseDate_dst.html
+ var m = s.match(/^([0-9]{4})(-([0-9]{2})(-([0-9]{2})([T ]([0-9]{2}):([0-9]{2})(:([0-9]{2})(\.([0-9]+))?)?(Z|(([-+])([0-9]{2}):([0-9]{2})))?)?)?)?$/);
+ if (!m) {
+ return null;
+ }
+ var date = new Date(m[1], 0, 1),
+ check = new Date(m[1], 0, 1, 9, 0),
+ offset = 0;
+ if (m[3]) {
+ date.setMonth(m[3] - 1);
+ check.setMonth(m[3] - 1);
+ }
+ if (m[5]) {
+ date.setDate(m[5]);
+ check.setDate(m[5]);
+ }
+ fixDate(date, check);
+ if (m[7]) {
+ date.setHours(m[7]);
+ }
+ if (m[8]) {
+ date.setMinutes(m[8]);
+ }
+ if (m[10]) {
+ date.setSeconds(m[10]);
+ }
+ if (m[12]) {
+ date.setMilliseconds(Number("0." + m[12]) * 1000);
+ }
+ fixDate(date, check);
+ if (!ignoreTimezone) {
+ if (m[14]) {
+ offset = Number(m[16]) * 60 + Number(m[17]);
+ offset *= m[15] == '-' ? 1 : -1;
+ }
+ offset -= date.getTimezoneOffset();
+ }
+ return new Date(+date + (offset * 60 * 1000));
+ };
+
+ var parseTime = fc.parseTime = function(s) { // returns minutes since start of day
+ if (typeof s == 'number') { // an hour
+ return s * 60;
+ }
+ if (typeof s == 'object') { // a Date object
+ return s.getHours() * 60 + s.getMinutes();
+ }
+ var m = s.match(/(\d+)(?::(\d+))?\s*(\w+)?/);
+ if (m) {
+ var h = parseInt(m[1]);
+ if (m[3]) {
+ h %= 12;
+ if (m[3].toLowerCase().charAt(0) == 'p') {
+ h += 12;
+ }
+ }
+ return h * 60 + (m[2] ? parseInt(m[2]) : 0);
+ }
+ };
+
+
+ /* Date Formatting
+ -----------------------------------------------------------------------------*/
+
+ var formatDate = fc.formatDate = function(date, format, options) {
+ return formatDates(date, null, format, options);
+ };
+
+ var formatDates = fc.formatDates = function(date1, date2, format, options) {
+ options = options || defaults;
+ var date = date1,
+ otherDate = date2,
+ i, len = format.length, c,
+ i2, formatter,
+ res = '';
+ for (i = 0; i < len; i++) {
+ c = format.charAt(i);
+ if (c == "'") {
+ for (i2 = i + 1; i2 < len; i2++) {
+ if (format.charAt(i2) == "'") {
+ if (date) {
+ if (i2 == i + 1) {
+ res += "'";
+ } else {
+ res += format.substring(i + 1, i2);
+ }
+ i = i2;
+ }
+ break;
+ }
+ }
+ }
+ else if (c == '(') {
+ for (i2 = i + 1; i2 < len; i2++) {
+ if (format.charAt(i2) == ')') {
+ var subres = formatDate(date, format.substring(i + 1, i2), options);
+ if (parseInt(subres.replace(/\D/, ''))) {
+ res += subres;
+ }
+ i = i2;
+ break;
+ }
+ }
+ }
+ else if (c == '[') {
+ for (i2 = i + 1; i2 < len; i2++) {
+ if (format.charAt(i2) == ']') {
+ var subformat = format.substring(i + 1, i2);
+ var subres = formatDate(date, subformat, options);
+ if (subres != formatDate(otherDate, subformat, options)) {
+ res += subres;
+ }
+ i = i2;
+ break;
+ }
+ }
+ }
+ else if (c == '{') {
+ date = date2;
+ otherDate = date1;
+ }
+ else if (c == '}') {
+ date = date1;
+ otherDate = date2;
+ }
+ else {
+ for (i2 = len; i2 > i; i2--) {
+ if (formatter = dateFormatters[format.substring(i, i2)]) {
+ if (date) {
+ res += formatter(date, options);
+ }
+ i = i2 - 1;
+ break;
+ }
+ }
+ if (i2 == i) {
+ if (date) {
+ res += c;
+ }
+ }
+ }
+ }
+ return res;
+ };
+
+ var dateFormatters = {
+ s : function(d) {
+ return d.getSeconds()
+ },
+ ss : function(d) {
+ return zeroPad(d.getSeconds())
+ },
+ m : function(d) {
+ return d.getMinutes()
+ },
+ mm : function(d) {
+ return zeroPad(d.getMinutes())
+ },
+ h : function(d) {
+ return d.getHours() % 12 || 12
+ },
+ hh : function(d) {
+ return zeroPad(d.getHours() % 12 || 12)
+ },
+ H : function(d) {
+ return d.getHours()
+ },
+ HH : function(d) {
+ return zeroPad(d.getHours())
+ },
+ d : function(d) {
+ return d.getDate()
+ },
+ dd : function(d) {
+ return zeroPad(d.getDate())
+ },
+ ddd : function(d, o) {
+ return o.dayNamesShort[d.getDay()]
+ },
+ dddd: function(d, o) {
+ return o.dayNames[d.getDay()]
+ },
+ M : function(d) {
+ return d.getMonth() + 1
+ },
+ MM : function(d) {
+ return zeroPad(d.getMonth() + 1)
+ },
+ MMM : function(d, o) {
+ return o.monthNamesShort[d.getMonth()]
+ },
+ MMMM: function(d, o) {
+ return o.monthNames[d.getMonth()]
+ },
+ yy : function(d) {
+ return (d.getFullYear() + '').substring(2)
+ },
+ yyyy: function(d) {
+ return d.getFullYear()
+ },
+ t : function(d) {
+ return d.getHours() < 12 ? 'a' : 'p'
+ },
+ tt : function(d) {
+ return d.getHours() < 12 ? 'am' : 'pm'
+ },
+ T : function(d) {
+ return d.getHours() < 12 ? 'A' : 'P'
+ },
+ TT : function(d) {
+ return d.getHours() < 12 ? 'AM' : 'PM'
+ },
+ u : function(d) {
+ return formatDate(d, "yyyy-MM-dd'T'HH:mm:ss'Z'")
+ },
+ S : function(d) {
+ var date = d.getDate();
+ if (date > 10 && date < 20) {
+ return 'th';
+ }
+ return ['st', 'nd', 'rd'][date % 10 - 1] || 'th';
+ }
+ };
+
+
+ /* Element Dimensions
+ -----------------------------------------------------------------------------*/
+
+ function setOuterWidth(element, width, includeMargins) {
+ element.each(function(i, _element) {
+ _element.style.width = width - hsides(_element, includeMargins) + 'px';
+ });
+ }
+
+ function setOuterHeight(element, height, includeMargins) {
+ element.each(function(i, _element) {
+ _element.style.height = height - vsides(_element, includeMargins) + 'px';
+ });
+ }
+
+
+ function hsides(_element, includeMargins) {
+ return (parseFloat(jQuery.curCSS(_element, 'paddingLeft', true)) || 0) +
+ (parseFloat(jQuery.curCSS(_element, 'paddingRight', true)) || 0) +
+ (parseFloat(jQuery.curCSS(_element, 'borderLeftWidth', true)) || 0) +
+ (parseFloat(jQuery.curCSS(_element, 'borderRightWidth', true)) || 0) +
+ (includeMargins ? hmargins(_element) : 0);
+ }
+
+ function hmargins(_element) {
+ return (parseFloat(jQuery.curCSS(_element, 'marginLeft', true)) || 0) +
+ (parseFloat(jQuery.curCSS(_element, 'marginRight', true)) || 0);
+ }
+
+ function vsides(_element, includeMargins) {
+ return (parseFloat(jQuery.curCSS(_element, 'paddingTop', true)) || 0) +
+ (parseFloat(jQuery.curCSS(_element, 'paddingBottom', true)) || 0) +
+ (parseFloat(jQuery.curCSS(_element, 'borderTopWidth', true)) || 0) +
+ (parseFloat(jQuery.curCSS(_element, 'borderBottomWidth', true)) || 0) +
+ (includeMargins ? vmargins(_element) : 0);
+ }
+
+ function vmargins(_element) {
+ return (parseFloat(jQuery.curCSS(_element, 'marginTop', true)) || 0) +
+ (parseFloat(jQuery.curCSS(_element, 'marginBottom', true)) || 0);
+ }
+
+
+ function setMinHeight(element, h) {
+ h = typeof h == 'number' ? h + 'px' : h;
+ element[0].style.cssText += ';min-height:' + h + ';_height:' + h;
+ }
+
+
+ /* Position Calculation
+ -----------------------------------------------------------------------------*/
+ // nasty bugs in opera 9.25
+ // position()'s top returning incorrectly with TR/TD or elements within TD
+
+ var topBug;
+
+ function topCorrect(tr) { // tr/th/td or anything else
+ if (topBug !== false) {
+ var cell;
+ if (tr.is('th,td')) {
+ tr = (cell = tr).parent();
+ }
+ if (topBug === undefined && tr.is('tr')) {
+ topBug = tr.position().top != tr.children().position().top;
+ }
+ if (topBug) {
+ return tr.parent().position().top + (cell ? tr.position().top - cell.position().top : 0);
+ }
+ }
+ return 0;
+ }
+
+
+ /* Hover Matrix
+ -----------------------------------------------------------------------------*/
+
+ function HoverMatrix(rowElements, colElements, changeCallback) {
+
+ var t = this,
+ tops = [], lefts = [],
+ origRow, origCol,
+ currRow, currCol,
+ e;
+
+ $.each(rowElements, function(i, _e) {
+ e = $(_e);
+ tops.push(e.offset().top + topCorrect(e));
+ });
+ tops.push(tops[tops.length - 1] + e.outerHeight());
+ $.each(colElements, function(i, _e) {
+ e = $(_e);
+ lefts.push(e.offset().left);
+ });
+ lefts.push(lefts[lefts.length - 1] + e.outerWidth());
+
+
+ t.mouse = function(ev) {
+ var x = ev.pageX;
+ var y = ev.pageY;
+ var r, c;
+ for (r = 0; r < tops.length && y >= tops[r]; r++) {
+ }
+ for (c = 0; c < lefts.length && x >= lefts[c]; c++) {
+ }
+ r = r >= tops.length ? -1 : r - 1;
+ c = c >= lefts.length ? -1 : c - 1;
+ if (r != currRow || c != currCol) {
+ currRow = r;
+ currCol = c;
+ if (r == -1 || c == -1) {
+ t.cell = null;
+ } else {
+ if (origRow === undefined) {
+ origRow = r;
+ origCol = c;
+ }
+ t.cell = {
+ row: r,
+ col: c,
+ top: tops[r],
+ left: lefts[c],
+ width: lefts[c + 1] - lefts[c],
+ height: tops[r + 1] - tops[r],
+ origRow: origRow,
+ origCol: origCol,
+ isOrig: r == origRow && c == origCol,
+ rowDelta: r - origRow,
+ colDelta: c - origCol
+ };
+ }
+ changeCallback(t.cell);
+ }
+ };
+
+ t.rect = function(row0, col0, row1, col1, originElement) { // row1,col1 are exclusive
+ var origin = originElement.offset();
+ return {
+ top: tops[row0] - origin.top,
+ left: lefts[col0] - origin.left,
+ width: lefts[col1] - lefts[col0],
+ height: tops[row1] - tops[row0]
+ };
+ };
+
+ }
+
+
+ /* Misc Utils
+ -----------------------------------------------------------------------------*/
+
+ var undefined,
+ dayIDs = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+
+ function zeroPad(n) {
+ return (n < 10 ? '0' : '') + n;
+ }
+
+ function smartProperty(obj, name) { // get a camel-cased/namespaced property of an object
+ if (obj[name] !== undefined) {
+ return obj[name];
+ }
+ var parts = name.split(/(?=[A-Z])/),
+ i = parts.length - 1, res;
+ for (; i >= 0; i--) {
+ res = obj[parts[i].toLowerCase()];
+ if (res !== undefined) {
+ return res;
+ }
+ }
+ return obj[''];
+ }
+
+ function htmlEscape(s) {
+ return s
+ .replace(/&/g, '&')
+ .replace(//g, '>')
+ .replace(/'/g, ''')
+ .replace(/"/g, '"');
+ }
+
+
+ function HorizontalPositionCache(getElement) {
+
+ var t = this,
+ elements = {},
+ lefts = {},
+ rights = {};
+
+ function e(i) {
+ return elements[i] = elements[i] || getElement(i);
+ }
+
+ t.left = function(i) {
+ return lefts[i] = lefts[i] === undefined ? e(i).position().left : lefts[i];
+ };
+
+ t.right = function(i) {
+ return rights[i] = rights[i] === undefined ? t.left(i) + e(i).width() : rights[i];
+ };
+
+ t.clear = function() {
+ elements = {};
+ lefts = {};
+ rights = {};
+ };
+
+ }
+
+
+ function cssKey(_element) {
+ return _element.id + '/' + _element.className + '/' + _element.style.cssText.replace(/(^|;)\s*(top|left|width|height)\s*:[^;]*/ig, '');
+ }
+
+
+ function cmp(a, b) {
+ return a - b;
+ }
+
+
+ function exclEndDay(event) {
+ if (event.end) {
+ return _exclEndDay(event.end, event.allDay);
+ } else {
+ return addDays(cloneDate(event.start), 1);
+ }
+ }
+
+ function _exclEndDay(end, allDay) {
+ end = cloneDate(end);
+ return allDay || end.getHours() || end.getMinutes() ? addDays(end, 1) : end;
+ }
+
+
+ function disableTextSelection(element) {
+ element
+ .attr('unselectable', 'on')
+ .css('MozUserSelect', 'none')
+ .bind('selectstart.ui', function() {
+ return false;
+ });
+ }
+
+ /*
+ function enableTextSelection(element) {
+ element
+ .attr('unselectable', 'off')
+ .css('MozUserSelect', '')
+ .unbind('selectstart.ui');
+ }
+ */
})(jQuery);
\ No newline at end of file
diff --git a/src/main/resources/org/richfaces/renderkit/html/scripts/richfaces.schedule.js b/src/main/resources/org/richfaces/renderkit/html/scripts/richfaces.schedule.js
index c08b637..67581d8 100644
--- a/src/main/resources/org/richfaces/renderkit/html/scripts/richfaces.schedule.js
+++ b/src/main/resources/org/richfaces/renderkit/html/scripts/richfaces.schedule.js
@@ -4,14 +4,15 @@ window.RichFaces.Schedule = (function() {
return Math.round(date.getTime() / 1000);
};
- return function(id, locale, options, loadItemsEventName, itemSelectedEventName, itemMovedEventName, itemResizedEventName, viewChangedEventName, daySelectedEventName, submitEventFunction) {
+ return function(id, locale, options, loadItemsEventName, itemSelectedEventName, itemMovedEventName, itemResizedEventName, viewChangedEventName, daySelectedEventName, dateRangeSelectedEventName, submitEventFunction) {
this.id = id;
+ var component;
/**
* submitEventFunction should have following params:
* event,view,eventType,itemId,startDate,endDate,dayDelta,minuteDelta,allDay,callback
*/
this.submitEventFunction = submitEventFunction;
- options = jQuery.extend(options, this.messages[locale]);
+ options = jQuery.extend(this.messages[locale], options);
var elt = document.getElementById(id);
if (!elt) {
throw "No element with id '" + id + "' found.";
@@ -190,6 +191,30 @@ window.RichFaces.Schedule = (function() {
}
selectedView = view;
};
+ var onDateRangeSelected = function(startDate, endDate, allDay) {
+ if (!component.fullCalendar('option', 'selectable')) {
+ return;
+ }
+ if (options.onDateRangeSelected != null) {
+ var result = eval("(function(){" + options.onDateRangeSelected + "})()");
+ if (result != null) {
+ return;
+ }
+ }
+ if (_this.submitEventFunction != null) {
+ _this.submitEventFunction({},
+ null,
+ dateRangeSelectedEventName,
+ null, formatDateParam(startDate), formatDateParam(endDate), null, null, allDay,
+ function(request, event, data) {
+ component.fullCalendar('refetchEvents');
+ component.fullCalendar('unselect');
+ }
+ );
+ } else {
+ component.fullCalendar('unselect');
+ }
+ };
options = jQuery.extend({
events: fillCalendarFunction,
eventDragStart: itemDragStart,
@@ -202,11 +227,13 @@ window.RichFaces.Schedule = (function() {
eventMouseover: itemMouseover,
eventMouseout: itemMouseout,
viewDisplay: viewDisplay,
- dayClick: dayClick
+ dayClick: dayClick,
+ select: onDateRangeSelected
}, options);
jQuery(document).ready(function() {
- jQuery(elt).fullCalendar(options);
+ component = jQuery(elt).fullCalendar(options);
});
};
}());
+window.RichFaces.Schedule.prototype.messages = {};
\ No newline at end of file
diff --git a/src/main/templates/org/richfaces/htmlSchedule.jspx b/src/main/templates/org/richfaces/htmlSchedule.jspx
index 6406fb3..8228c98 100644
--- a/src/main/templates/org/richfaces/htmlSchedule.jspx
+++ b/src/main/templates/org/richfaces/htmlSchedule.jspx
@@ -1,16 +1,16 @@
+ xmlns:f="http://jsf.exadel.com/template"
+ xmlns:vcp=" http://jsf.exadel.com/vcp"
+ xmlns:ui=" http://jsf.exadel.com/ui"
+ xmlns:x=" http://jsf.exadel.com/vcp"
+ xmlns:u="http://jsf.exadel.com/util"
+ xmlns:h="http://jsf.exadel.com/header"
+ xmlns:jsp="http://java.sun.com/JSP/Page"
+ xmlns:c="http://java.sun.com/jstl/core"
+ class="org.richfaces.renderkit.html.ScheduleRenderer"
+ baseclass="org.richfaces.renderkit.ScheduleRendererBase"
+ component="org.richfaces.component.UISchedule">
/org/richfaces/renderkit/html/css/fullcalendar.css
org.ajax4jsf.javascript.AjaxScript,
@@ -21,18 +21,18 @@
/org/richfaces/renderkit/html/scripts/ui.draggable.js,
/org/richfaces/renderkit/html/scripts/ui.resizable.js,
/org/richfaces/renderkit/html/scripts/fullcalendar.js,
- /org/richfaces/renderkit/html/scripts/richfaces.schedule.js
+ /org/richfaces/renderkit/html/scripts/richfaces.schedule.js,
+ org.richfaces.renderkit.html.scripts.ScheduleMessages
-
-
-
-
-
+
-
+
\ No newline at end of file