mirror of
https://github.com/wassname/fullcalendar.git
synced 2026-06-27 16:10:13 +08:00
Adding new files
This commit is contained in:
sean kenny
+10
@@ -0,0 +1,10 @@
|
||||
$.fullCalendar.lang("id", {
|
||||
defaultButtonText: {
|
||||
month: "Bulan",
|
||||
week: "Minggu",
|
||||
day: "Hari",
|
||||
list: "Agenda"
|
||||
},
|
||||
allDayHtml: "Sehari<br/>penuh",
|
||||
eventLimitText: "lebih"
|
||||
});
|
||||
@@ -0,0 +1,142 @@
|
||||
|
||||
/* A "coordinate map" converts pixel coordinates into an associated cell, which has an associated date
|
||||
------------------------------------------------------------------------------------------------------------------------
|
||||
Common interface:
|
||||
|
||||
CoordMap.prototype = {
|
||||
build: function() {},
|
||||
getCell: function(x, y) {}
|
||||
};
|
||||
|
||||
*/
|
||||
|
||||
/* Coordinate map for a grid component
|
||||
----------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
function GridCoordMap(grid) {
|
||||
this.grid = grid;
|
||||
}
|
||||
|
||||
|
||||
GridCoordMap.prototype = {
|
||||
|
||||
grid: null, // reference to the Grid
|
||||
rows: null, // the top-to-bottom y coordinates. including the bottom of the last item
|
||||
cols: null, // the left-to-right x coordinates. including the right of the last item
|
||||
|
||||
containerEl: null, // container element that all coordinates are constrained to. optionally assigned
|
||||
minX: null,
|
||||
maxX: null, // exclusive
|
||||
minY: null,
|
||||
maxY: null, // exclusive
|
||||
|
||||
|
||||
// Queries the grid for the coordinates of all the cells
|
||||
build: function() {
|
||||
this.grid.buildCoords(
|
||||
this.rows = [],
|
||||
this.cols = []
|
||||
);
|
||||
this.computeBounds();
|
||||
},
|
||||
|
||||
|
||||
// Given a coordinate of the document, gets the associated cell. If no cell is underneath, returns null
|
||||
getCell: function(x, y) {
|
||||
var cell = null;
|
||||
var rows = this.rows;
|
||||
var cols = this.cols;
|
||||
var r = -1;
|
||||
var c = -1;
|
||||
var i;
|
||||
|
||||
if (this.inBounds(x, y)) {
|
||||
|
||||
for (i = 0; i < rows.length; i++) {
|
||||
if (y >= rows[i][0] && y < rows[i][1]) {
|
||||
r = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < cols.length; i++) {
|
||||
if (x >= cols[i][0] && x < cols[i][1]) {
|
||||
c = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (r >= 0 && c >= 0) {
|
||||
cell = { row: r, col: c };
|
||||
cell.grid = this.grid;
|
||||
cell.date = this.grid.getCellDate(cell);
|
||||
}
|
||||
}
|
||||
|
||||
return cell;
|
||||
},
|
||||
|
||||
|
||||
// If there is a containerEl, compute the bounds into min/max values
|
||||
computeBounds: function() {
|
||||
var containerOffset;
|
||||
|
||||
if (this.containerEl) {
|
||||
containerOffset = this.containerEl.offset();
|
||||
this.minX = containerOffset.left;
|
||||
this.maxX = containerOffset.left + this.containerEl.outerWidth();
|
||||
this.minY = containerOffset.top;
|
||||
this.maxY = containerOffset.top + this.containerEl.outerHeight();
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Determines if the given coordinates are in bounds. If no `containerEl`, always true
|
||||
inBounds: function(x, y) {
|
||||
if (this.containerEl) {
|
||||
return x >= this.minX && x < this.maxX && y >= this.minY && y < this.maxY;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
/* Coordinate map that is a combination of multiple other coordinate maps
|
||||
----------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
function ComboCoordMap(coordMaps) {
|
||||
this.coordMaps = coordMaps;
|
||||
}
|
||||
|
||||
|
||||
ComboCoordMap.prototype = {
|
||||
|
||||
coordMaps: null, // an array of CoordMaps
|
||||
|
||||
|
||||
// Builds all coordMaps
|
||||
build: function() {
|
||||
var coordMaps = this.coordMaps;
|
||||
var i;
|
||||
|
||||
for (i = 0; i < coordMaps.length; i++) {
|
||||
coordMaps[i].build();
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Queries all coordMaps for the cell underneath the given coordinates, returning the first result
|
||||
getCell: function(x, y) {
|
||||
var coordMaps = this.coordMaps;
|
||||
var cell = null;
|
||||
var i;
|
||||
|
||||
for (i = 0; i < coordMaps.length && !cell; i++) {
|
||||
cell = coordMaps[i].getCell(x, y);
|
||||
}
|
||||
|
||||
return cell;
|
||||
}
|
||||
|
||||
};
|
||||
@@ -0,0 +1,290 @@
|
||||
|
||||
/* Event-rendering methods for the DayGrid class
|
||||
----------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
$.extend(DayGrid.prototype, {
|
||||
|
||||
segs: null,
|
||||
rowStructs: null, // an array of objects, each holding information about a row's event-rendering
|
||||
|
||||
|
||||
// Render the given events onto the Grid and return the rendered segments
|
||||
renderEvents: function(events) {
|
||||
var rowStructs = this.rowStructs = this.renderEventRows(events);
|
||||
var segs = [];
|
||||
|
||||
// append to each row's content skeleton
|
||||
this.rowEls.each(function(i, rowNode) {
|
||||
$(rowNode).find('.fc-content-skeleton > table').append(
|
||||
rowStructs[i].tbodyEl
|
||||
);
|
||||
segs.push.apply(segs, rowStructs[i].segs);
|
||||
});
|
||||
|
||||
this.segs = segs;
|
||||
},
|
||||
|
||||
|
||||
// Retrieves all segment objects that have been rendered
|
||||
getSegs: function() {
|
||||
return (this.segs || []).concat(
|
||||
this.popoverSegs || [] // segs rendered in the "more" events popover
|
||||
);
|
||||
},
|
||||
|
||||
|
||||
// Removes all rendered event elements
|
||||
destroyEvents: function() {
|
||||
var rowStructs;
|
||||
var rowStruct;
|
||||
|
||||
Grid.prototype.destroyEvents.call(this); // call the super-method
|
||||
|
||||
rowStructs = this.rowStructs || [];
|
||||
while ((rowStruct = rowStructs.pop())) {
|
||||
rowStruct.tbodyEl.remove();
|
||||
}
|
||||
|
||||
this.segs = null;
|
||||
this.destroySegPopover(); // removes the "more.." events popover
|
||||
},
|
||||
|
||||
|
||||
// Uses the given events array to generate <tbody> elements that should be appended to each row's content skeleton.
|
||||
// Returns an array of rowStruct objects (see the bottom of `renderEventRow`).
|
||||
renderEventRows: function(events) {
|
||||
var segs = this.eventsToSegs(events);
|
||||
var rowStructs = [];
|
||||
var segRows;
|
||||
var row;
|
||||
|
||||
segs = this.renderSegs(segs); // returns a new array with only visible segments
|
||||
segRows = this.groupSegRows(segs); // group into nested arrays
|
||||
|
||||
// iterate each row of segment groupings
|
||||
for (row = 0; row < segRows.length; row++) {
|
||||
rowStructs.push(
|
||||
this.renderEventRow(row, segRows[row])
|
||||
);
|
||||
}
|
||||
|
||||
return rowStructs;
|
||||
},
|
||||
|
||||
|
||||
// Builds the HTML to be used for the default element for an individual segment
|
||||
renderSegHtml: function(seg, disableResizing) {
|
||||
var view = this.view;
|
||||
var isRTL = view.opt('isRTL');
|
||||
var event = seg.event;
|
||||
var isDraggable = view.isEventDraggable(event);
|
||||
var isResizable = !disableResizing && event.allDay && seg.isEnd && view.isEventResizable(event);
|
||||
var classes = this.getSegClasses(seg, isDraggable, isResizable);
|
||||
var skinCss = this.getEventSkinCss(event);
|
||||
var timeHtml = '';
|
||||
var titleHtml;
|
||||
|
||||
classes.unshift('fc-day-grid-event');
|
||||
|
||||
// Only display a timed events time if it is the starting segment
|
||||
if (!event.allDay && seg.isStart) {
|
||||
timeHtml = '<span class="fc-time">' + htmlEscape(view.getEventTimeText(event)) + '</span>';
|
||||
}
|
||||
|
||||
titleHtml =
|
||||
'<span class="fc-title">' +
|
||||
(htmlEscape(event.title || '') || ' ') + // we always want one line of height
|
||||
'</span>';
|
||||
|
||||
return '<a class="' + classes.join(' ') + '"' +
|
||||
(event.url ?
|
||||
' href="' + htmlEscape(event.url) + '"' :
|
||||
''
|
||||
) +
|
||||
(skinCss ?
|
||||
' style="' + skinCss + '"' :
|
||||
''
|
||||
) +
|
||||
'>' +
|
||||
'<div class="fc-content">' +
|
||||
(isRTL ?
|
||||
titleHtml + ' ' + timeHtml : // put a natural space in between
|
||||
timeHtml + ' ' + titleHtml //
|
||||
) +
|
||||
'</div>' +
|
||||
(isResizable ?
|
||||
'<div class="fc-resizer"/>' :
|
||||
''
|
||||
) +
|
||||
'</a>';
|
||||
},
|
||||
|
||||
|
||||
// Given a row # and an array of segments all in the same row, render a <tbody> element, a skeleton that contains
|
||||
// the segments. Returns object with a bunch of internal data about how the render was calculated.
|
||||
renderEventRow: function(row, rowSegs) {
|
||||
var view = this.view;
|
||||
var colCnt = view.colCnt;
|
||||
var segLevels = this.buildSegLevels(rowSegs); // group into sub-arrays of levels
|
||||
var levelCnt = Math.max(1, segLevels.length); // ensure at least one level
|
||||
var tbody = $('<tbody/>');
|
||||
var segMatrix = []; // lookup for which segments are rendered into which level+col cells
|
||||
var cellMatrix = []; // lookup for all <td> elements of the level+col matrix
|
||||
var loneCellMatrix = []; // lookup for <td> elements that only take up a single column
|
||||
var i, levelSegs;
|
||||
var col;
|
||||
var tr;
|
||||
var j, seg;
|
||||
var td;
|
||||
|
||||
// populates empty cells from the current column (`col`) to `endCol`
|
||||
function emptyCellsUntil(endCol) {
|
||||
while (col < endCol) {
|
||||
// try to grab a cell from the level above and extend its rowspan. otherwise, create a fresh cell
|
||||
td = (loneCellMatrix[i - 1] || [])[col];
|
||||
if (td) {
|
||||
td.attr(
|
||||
'rowspan',
|
||||
parseInt(td.attr('rowspan') || 1, 10) + 1
|
||||
);
|
||||
}
|
||||
else {
|
||||
td = $('<td/>');
|
||||
tr.append(td);
|
||||
}
|
||||
cellMatrix[i][col] = td;
|
||||
loneCellMatrix[i][col] = td;
|
||||
col++;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < levelCnt; i++) { // iterate through all levels
|
||||
levelSegs = segLevels[i];
|
||||
col = 0;
|
||||
tr = $('<tr/>');
|
||||
|
||||
segMatrix.push([]);
|
||||
cellMatrix.push([]);
|
||||
loneCellMatrix.push([]);
|
||||
|
||||
// levelCnt might be 1 even though there are no actual levels. protect against this.
|
||||
// this single empty row is useful for styling.
|
||||
if (levelSegs) {
|
||||
for (j = 0; j < levelSegs.length; j++) { // iterate through segments in level
|
||||
seg = levelSegs[j];
|
||||
|
||||
emptyCellsUntil(seg.leftCol);
|
||||
|
||||
// create a container that occupies or more columns. append the event element.
|
||||
td = $('<td class="fc-event-container"/>').append(seg.el);
|
||||
if (seg.leftCol != seg.rightCol) {
|
||||
td.attr('colspan', seg.rightCol - seg.leftCol + 1);
|
||||
}
|
||||
else { // a single-column segment
|
||||
loneCellMatrix[i][col] = td;
|
||||
}
|
||||
|
||||
while (col <= seg.rightCol) {
|
||||
cellMatrix[i][col] = td;
|
||||
segMatrix[i][col] = seg;
|
||||
col++;
|
||||
}
|
||||
|
||||
tr.append(td);
|
||||
}
|
||||
}
|
||||
|
||||
emptyCellsUntil(colCnt); // finish off the row
|
||||
this.bookendCells(tr, 'eventSkeleton');
|
||||
tbody.append(tr);
|
||||
}
|
||||
|
||||
return { // a "rowStruct"
|
||||
row: row, // the row number
|
||||
tbodyEl: tbody,
|
||||
cellMatrix: cellMatrix,
|
||||
segMatrix: segMatrix,
|
||||
segLevels: segLevels,
|
||||
segs: rowSegs
|
||||
};
|
||||
},
|
||||
|
||||
|
||||
// Stacks a flat array of segments, which are all assumed to be in the same row, into subarrays of vertical levels.
|
||||
buildSegLevels: function(segs) {
|
||||
var levels = [];
|
||||
var i, seg;
|
||||
var j;
|
||||
|
||||
// Give preference to elements with certain criteria, so they have
|
||||
// a chance to be closer to the top.
|
||||
segs.sort(compareSegs);
|
||||
|
||||
for (i = 0; i < segs.length; i++) {
|
||||
seg = segs[i];
|
||||
|
||||
// loop through levels, starting with the topmost, until the segment doesn't collide with other segments
|
||||
for (j = 0; j < levels.length; j++) {
|
||||
if (!isDaySegCollision(seg, levels[j])) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// `j` now holds the desired subrow index
|
||||
seg.level = j;
|
||||
|
||||
// create new level array if needed and append segment
|
||||
(levels[j] || (levels[j] = [])).push(seg);
|
||||
}
|
||||
|
||||
// order segments left-to-right. very important if calendar is RTL
|
||||
for (j = 0; j < levels.length; j++) {
|
||||
levels[j].sort(compareDaySegCols);
|
||||
}
|
||||
|
||||
return levels;
|
||||
},
|
||||
|
||||
|
||||
// Given a flat array of segments, return an array of sub-arrays, grouped by each segment's row
|
||||
groupSegRows: function(segs) {
|
||||
var view = this.view;
|
||||
var segRows = [];
|
||||
var i;
|
||||
|
||||
for (i = 0; i < view.rowCnt; i++) {
|
||||
segRows.push([]);
|
||||
}
|
||||
|
||||
for (i = 0; i < segs.length; i++) {
|
||||
segRows[segs[i].row].push(segs[i]);
|
||||
}
|
||||
|
||||
return segRows;
|
||||
}
|
||||
|
||||
});
|
||||
|
||||
|
||||
// Computes whether two segments' columns collide. They are assumed to be in the same row.
|
||||
function isDaySegCollision(seg, otherSegs) {
|
||||
var i, otherSeg;
|
||||
|
||||
for (i = 0; i < otherSegs.length; i++) {
|
||||
otherSeg = otherSegs[i];
|
||||
|
||||
if (
|
||||
otherSeg.leftCol <= seg.rightCol &&
|
||||
otherSeg.rightCol >= seg.leftCol
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
// A cmp function for determining the leftmost event
|
||||
function compareDaySegCols(a, b) {
|
||||
return a.leftCol - b.leftCol;
|
||||
}
|
||||
@@ -0,0 +1,304 @@
|
||||
|
||||
/* A component that renders a grid of whole-days that runs horizontally. There can be multiple rows, one per week.
|
||||
----------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
function DayGrid(view) {
|
||||
Grid.call(this, view); // call the super-constructor
|
||||
}
|
||||
|
||||
|
||||
DayGrid.prototype = createObject(Grid.prototype); // declare the super-class
|
||||
$.extend(DayGrid.prototype, {
|
||||
|
||||
numbersVisible: false, // should render a row for day/week numbers? manually set by the view
|
||||
cellDuration: moment.duration({ days: 1 }), // required for Grid.event.js. Each cell is always a single day
|
||||
bottomCoordPadding: 0, // hack for extending the hit area for the last row of the coordinate grid
|
||||
|
||||
rowEls: null, // set of fake row elements
|
||||
dayEls: null, // set of whole-day elements comprising the row's background
|
||||
helperEls: null, // set of cell skeleton elements for rendering the mock event "helper"
|
||||
highlightEls: null, // set of cell skeleton elements for rendering the highlight
|
||||
|
||||
|
||||
// Renders the rows and columns into the component's `this.el`, which should already be assigned.
|
||||
// isRigid determins whether the individual rows should ignore the contents and be a constant height.
|
||||
// Relies on the view's colCnt and rowCnt. In the future, this component should probably be self-sufficient.
|
||||
render: function(isRigid) {
|
||||
var view = this.view;
|
||||
var html = '';
|
||||
var row;
|
||||
|
||||
for (row = 0; row < view.rowCnt; row++) {
|
||||
html += this.dayRowHtml(row, isRigid);
|
||||
}
|
||||
this.el.html(html);
|
||||
|
||||
this.rowEls = this.el.find('.fc-row');
|
||||
this.dayEls = this.el.find('.fc-day');
|
||||
|
||||
// run all the day cells through the dayRender callback
|
||||
this.dayEls.each(function(i, node) {
|
||||
var date = view.cellToDate(Math.floor(i / view.colCnt), i % view.colCnt);
|
||||
view.trigger('dayRender', null, date, $(node));
|
||||
});
|
||||
|
||||
Grid.prototype.render.call(this); // call the super-method
|
||||
},
|
||||
|
||||
|
||||
destroy: function() {
|
||||
this.destroySegPopover();
|
||||
},
|
||||
|
||||
|
||||
// Generates the HTML for a single row. `row` is the row number.
|
||||
dayRowHtml: function(row, isRigid) {
|
||||
var view = this.view;
|
||||
var classes = [ 'fc-row', 'fc-week', view.widgetContentClass ];
|
||||
|
||||
if (isRigid) {
|
||||
classes.push('fc-rigid');
|
||||
}
|
||||
|
||||
return '' +
|
||||
'<div class="' + classes.join(' ') + '">' +
|
||||
'<div class="fc-bg">' +
|
||||
'<table>' +
|
||||
this.rowHtml('day', row) + // leverages RowRenderer. calls dayCellHtml()
|
||||
'</table>' +
|
||||
'</div>' +
|
||||
'<div class="fc-content-skeleton">' +
|
||||
'<table>' +
|
||||
(this.numbersVisible ?
|
||||
'<thead>' +
|
||||
this.rowHtml('number', row) + // leverages RowRenderer. View will define render method
|
||||
'</thead>' :
|
||||
''
|
||||
) +
|
||||
'</table>' +
|
||||
'</div>' +
|
||||
'</div>';
|
||||
},
|
||||
|
||||
|
||||
// Renders the HTML for a whole-day cell. Will eventually end up in the day-row's background.
|
||||
// We go through a 'day' row type instead of just doing a 'bg' row type so that the View can do custom rendering
|
||||
// specifically for whole-day rows, whereas a 'bg' might also be used for other purposes (TimeGrid bg for example).
|
||||
dayCellHtml: function(row, col, date) {
|
||||
return this.bgCellHtml(row, col, date);
|
||||
},
|
||||
|
||||
|
||||
/* Coordinates & Cells
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Populates the empty `rows` and `cols` arrays with coordinates of the cells. For CoordGrid.
|
||||
buildCoords: function(rows, cols) {
|
||||
var colCnt = this.view.colCnt;
|
||||
var e, n, p;
|
||||
|
||||
this.dayEls.slice(0, colCnt).each(function(i, _e) { // iterate the first row of day elements
|
||||
e = $(_e);
|
||||
n = e.offset().left;
|
||||
if (i) {
|
||||
p[1] = n;
|
||||
}
|
||||
p = [ n ];
|
||||
cols[i] = p;
|
||||
});
|
||||
p[1] = n + e.outerWidth();
|
||||
|
||||
this.rowEls.each(function(i, _e) {
|
||||
e = $(_e);
|
||||
n = e.offset().top;
|
||||
if (i) {
|
||||
p[1] = n;
|
||||
}
|
||||
p = [ n ];
|
||||
rows[i] = p;
|
||||
});
|
||||
p[1] = n + e.outerHeight() + this.bottomCoordPadding; // hack to extend hit area of last row
|
||||
},
|
||||
|
||||
|
||||
// Converts a cell to a date
|
||||
getCellDate: function(cell) {
|
||||
return this.view.cellToDate(cell); // leverages the View's cell system
|
||||
},
|
||||
|
||||
|
||||
// Gets the whole-day element associated with the cell
|
||||
getCellDayEl: function(cell) {
|
||||
return this.dayEls.eq(cell.row * this.view.colCnt + cell.col);
|
||||
},
|
||||
|
||||
|
||||
// Converts a range with an inclusive `start` and an exclusive `end` into an array of segment objects
|
||||
rangeToSegs: function(start, end) {
|
||||
return this.view.rangeToSegments(start, end); // leverages the View's cell system
|
||||
},
|
||||
|
||||
|
||||
/* Event Drag Visualization
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Renders a visual indication of an event hovering over the given date(s).
|
||||
// `end` can be null, as well as `seg`. See View's documentation on renderDrag for more info.
|
||||
// A returned value of `true` signals that a mock "helper" event has been rendered.
|
||||
renderDrag: function(start, end, seg) {
|
||||
var opacity;
|
||||
|
||||
// always render a highlight underneath
|
||||
this.renderHighlight(
|
||||
start,
|
||||
end || this.view.calendar.getDefaultEventEnd(true, start)
|
||||
);
|
||||
|
||||
// if a segment from the same calendar but another component is being dragged, render a helper event
|
||||
if (seg && !seg.el.closest(this.el).length) {
|
||||
|
||||
this.renderRangeHelper(start, end, seg);
|
||||
|
||||
opacity = this.view.opt('dragOpacity');
|
||||
if (opacity !== undefined) {
|
||||
this.helperEls.css('opacity', opacity);
|
||||
}
|
||||
|
||||
return true; // a helper has been rendered
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Unrenders any visual indication of a hovering event
|
||||
destroyDrag: function() {
|
||||
this.destroyHighlight();
|
||||
this.destroyHelper();
|
||||
},
|
||||
|
||||
|
||||
/* Event Resize Visualization
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Renders a visual indication of an event being resized
|
||||
renderResize: function(start, end, seg) {
|
||||
this.renderHighlight(start, end);
|
||||
this.renderRangeHelper(start, end, seg);
|
||||
},
|
||||
|
||||
|
||||
// Unrenders a visual indication of an event being resized
|
||||
destroyResize: function() {
|
||||
this.destroyHighlight();
|
||||
this.destroyHelper();
|
||||
},
|
||||
|
||||
|
||||
/* Event Helper
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Renders a mock "helper" event. `sourceSeg` is the associated internal segment object. It can be null.
|
||||
renderHelper: function(event, sourceSeg) {
|
||||
var helperNodes = [];
|
||||
var rowStructs = this.renderEventRows([ event ]);
|
||||
|
||||
// inject each new event skeleton into each associated row
|
||||
this.rowEls.each(function(row, rowNode) {
|
||||
var rowEl = $(rowNode); // the .fc-row
|
||||
var skeletonEl = $('<div class="fc-helper-skeleton"><table/></div>'); // will be absolutely positioned
|
||||
var skeletonTop;
|
||||
|
||||
// If there is an original segment, match the top position. Otherwise, put it at the row's top level
|
||||
if (sourceSeg && sourceSeg.row === row) {
|
||||
skeletonTop = sourceSeg.el.position().top;
|
||||
}
|
||||
else {
|
||||
skeletonTop = rowEl.find('.fc-content-skeleton tbody').position().top;
|
||||
}
|
||||
|
||||
skeletonEl.css('top', skeletonTop)
|
||||
.find('table')
|
||||
.append(rowStructs[row].tbodyEl);
|
||||
|
||||
rowEl.append(skeletonEl);
|
||||
helperNodes.push(skeletonEl[0]);
|
||||
});
|
||||
|
||||
this.helperEls = $(helperNodes); // array -> jQuery set
|
||||
},
|
||||
|
||||
|
||||
// Unrenders any visual indication of a mock helper event
|
||||
destroyHelper: function() {
|
||||
if (this.helperEls) {
|
||||
this.helperEls.remove();
|
||||
this.helperEls = null;
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
/* Highlighting
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Renders an emphasis on the given date range. `start` is an inclusive, `end` is exclusive.
|
||||
renderHighlight: function(start, end) {
|
||||
var segs = this.rangeToSegs(start, end);
|
||||
var highlightNodes = [];
|
||||
var i, seg;
|
||||
var el;
|
||||
|
||||
// build an event skeleton for each row that needs it
|
||||
for (i = 0; i < segs.length; i++) {
|
||||
seg = segs[i];
|
||||
el = $(
|
||||
this.highlightSkeletonHtml(seg.leftCol, seg.rightCol + 1) // make end exclusive
|
||||
);
|
||||
el.appendTo(this.rowEls[seg.row]);
|
||||
highlightNodes.push(el[0]);
|
||||
}
|
||||
|
||||
this.highlightEls = $(highlightNodes); // array -> jQuery set
|
||||
},
|
||||
|
||||
|
||||
// Unrenders any visual emphasis on a date range
|
||||
destroyHighlight: function() {
|
||||
if (this.highlightEls) {
|
||||
this.highlightEls.remove();
|
||||
this.highlightEls = null;
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Generates the HTML used to build a single-row "highlight skeleton", a table that frames highlight cells
|
||||
highlightSkeletonHtml: function(startCol, endCol) {
|
||||
var colCnt = this.view.colCnt;
|
||||
var cellHtml = '';
|
||||
|
||||
if (startCol > 0) {
|
||||
cellHtml += '<td colspan="' + startCol + '"/>';
|
||||
}
|
||||
if (endCol > startCol) {
|
||||
cellHtml += '<td colspan="' + (endCol - startCol) + '" class="fc-highlight" />';
|
||||
}
|
||||
if (colCnt > endCol) {
|
||||
cellHtml += '<td colspan="' + (colCnt - endCol) + '"/>';
|
||||
}
|
||||
|
||||
cellHtml = this.bookendCells(cellHtml, 'highlight');
|
||||
|
||||
return '' +
|
||||
'<div class="fc-highlight-skeleton">' +
|
||||
'<table>' +
|
||||
'<tr>' +
|
||||
cellHtml +
|
||||
'</tr>' +
|
||||
'</table>' +
|
||||
'</div>';
|
||||
}
|
||||
|
||||
});
|
||||
@@ -0,0 +1,344 @@
|
||||
|
||||
/* Methods relate to limiting the number events for a given day on a DayGrid
|
||||
----------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
$.extend(DayGrid.prototype, {
|
||||
|
||||
|
||||
segPopover: null, // the Popover that holds events that can't fit in a cell. null when not visible
|
||||
popoverSegs: null, // an array of segment objects that the segPopover holds. null when not visible
|
||||
|
||||
|
||||
destroySegPopover: function() {
|
||||
if (this.segPopover) {
|
||||
this.segPopover.hide(); // will trigger destruction of `segPopover` and `popoverSegs`
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Limits the number of "levels" (vertically stacking layers of events) for each row of the grid.
|
||||
// `levelLimit` can be false (don't limit), a number, or true (should be computed).
|
||||
limitRows: function(levelLimit) {
|
||||
var rowStructs = this.rowStructs || [];
|
||||
var row; // row #
|
||||
var rowLevelLimit;
|
||||
|
||||
for (row = 0; row < rowStructs.length; row++) {
|
||||
this.unlimitRow(row);
|
||||
|
||||
if (!levelLimit) {
|
||||
rowLevelLimit = false;
|
||||
}
|
||||
else if (typeof levelLimit === 'number') {
|
||||
rowLevelLimit = levelLimit;
|
||||
}
|
||||
else {
|
||||
rowLevelLimit = this.computeRowLevelLimit(row);
|
||||
}
|
||||
|
||||
if (rowLevelLimit !== false) {
|
||||
this.limitRow(row, rowLevelLimit);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Computes the number of levels a row will accomodate without going outside its bounds.
|
||||
// Assumes the row is "rigid" (maintains a constant height regardless of what is inside).
|
||||
// `row` is the row number.
|
||||
computeRowLevelLimit: function(row) {
|
||||
var rowEl = this.rowEls.eq(row); // the containing "fake" row div
|
||||
var rowHeight = rowEl.height(); // TODO: cache somehow?
|
||||
var trEls = this.rowStructs[row].tbodyEl.children();
|
||||
var i, trEl;
|
||||
|
||||
// Reveal one level <tr> at a time and stop when we find one out of bounds
|
||||
for (i = 0; i < trEls.length; i++) {
|
||||
trEl = trEls.eq(i).removeClass('fc-limited'); // get and reveal
|
||||
if (trEl.position().top + trEl.outerHeight() > rowHeight) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return false; // should not limit at all
|
||||
},
|
||||
|
||||
|
||||
// Limits the given grid row to the maximum number of levels and injects "more" links if necessary.
|
||||
// `row` is the row number.
|
||||
// `levelLimit` is a number for the maximum (inclusive) number of levels allowed.
|
||||
limitRow: function(row, levelLimit) {
|
||||
var _this = this;
|
||||
var view = this.view;
|
||||
var rowStruct = this.rowStructs[row];
|
||||
var moreNodes = []; // array of "more" <a> links and <td> DOM nodes
|
||||
var col = 0; // col #
|
||||
var cell;
|
||||
var levelSegs; // array of segment objects in the last allowable level, ordered left-to-right
|
||||
var cellMatrix; // a matrix (by level, then column) of all <td> jQuery elements in the row
|
||||
var limitedNodes; // array of temporarily hidden level <tr> and segment <td> DOM nodes
|
||||
var i, seg;
|
||||
var segsBelow; // array of segment objects below `seg` in the current `col`
|
||||
var totalSegsBelow; // total number of segments below `seg` in any of the columns `seg` occupies
|
||||
var colSegsBelow; // array of segment arrays, below seg, one for each column (offset from segs's first column)
|
||||
var td, rowspan;
|
||||
var segMoreNodes; // array of "more" <td> cells that will stand-in for the current seg's cell
|
||||
var j;
|
||||
var moreTd, moreWrap, moreLink;
|
||||
|
||||
// Iterates through empty level cells and places "more" links inside if need be
|
||||
function emptyCellsUntil(endCol) { // goes from current `col` to `endCol`
|
||||
while (col < endCol) {
|
||||
cell = { row: row, col: col };
|
||||
segsBelow = _this.getCellSegs(cell, levelLimit);
|
||||
if (segsBelow.length) {
|
||||
td = cellMatrix[levelLimit - 1][col];
|
||||
moreLink = _this.renderMoreLink(cell, segsBelow);
|
||||
moreWrap = $('<div/>').append(moreLink);
|
||||
td.append(moreWrap);
|
||||
moreNodes.push(moreWrap[0]);
|
||||
}
|
||||
col++;
|
||||
}
|
||||
}
|
||||
|
||||
if (levelLimit && levelLimit < rowStruct.segLevels.length) { // is it actually over the limit?
|
||||
levelSegs = rowStruct.segLevels[levelLimit - 1];
|
||||
cellMatrix = rowStruct.cellMatrix;
|
||||
|
||||
limitedNodes = rowStruct.tbodyEl.children().slice(levelLimit) // get level <tr> elements past the limit
|
||||
.addClass('fc-limited').get(); // hide elements and get a simple DOM-nodes array
|
||||
|
||||
// iterate though segments in the last allowable level
|
||||
for (i = 0; i < levelSegs.length; i++) {
|
||||
seg = levelSegs[i];
|
||||
emptyCellsUntil(seg.leftCol); // process empty cells before the segment
|
||||
|
||||
// determine *all* segments below `seg` that occupy the same columns
|
||||
colSegsBelow = [];
|
||||
totalSegsBelow = 0;
|
||||
while (col <= seg.rightCol) {
|
||||
cell = { row: row, col: col };
|
||||
segsBelow = this.getCellSegs(cell, levelLimit);
|
||||
colSegsBelow.push(segsBelow);
|
||||
totalSegsBelow += segsBelow.length;
|
||||
col++;
|
||||
}
|
||||
|
||||
if (totalSegsBelow) { // do we need to replace this segment with one or many "more" links?
|
||||
td = cellMatrix[levelLimit - 1][seg.leftCol]; // the segment's parent cell
|
||||
rowspan = td.attr('rowspan') || 1;
|
||||
segMoreNodes = [];
|
||||
|
||||
// make a replacement <td> for each column the segment occupies. will be one for each colspan
|
||||
for (j = 0; j < colSegsBelow.length; j++) {
|
||||
moreTd = $('<td class="fc-more-cell"/>').attr('rowspan', rowspan);
|
||||
segsBelow = colSegsBelow[j];
|
||||
cell = { row: row, col: seg.leftCol + j };
|
||||
moreLink = this.renderMoreLink(cell, [ seg ].concat(segsBelow)); // count seg as hidden too
|
||||
moreWrap = $('<div/>').append(moreLink);
|
||||
moreTd.append(moreWrap);
|
||||
segMoreNodes.push(moreTd[0]);
|
||||
moreNodes.push(moreTd[0]);
|
||||
}
|
||||
|
||||
td.addClass('fc-limited').after($(segMoreNodes)); // hide original <td> and inject replacements
|
||||
limitedNodes.push(td[0]);
|
||||
}
|
||||
}
|
||||
|
||||
emptyCellsUntil(view.colCnt); // finish off the level
|
||||
rowStruct.moreEls = $(moreNodes); // for easy undoing later
|
||||
rowStruct.limitedEls = $(limitedNodes); // for easy undoing later
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Reveals all levels and removes all "more"-related elements for a grid's row.
|
||||
// `row` is a row number.
|
||||
unlimitRow: function(row) {
|
||||
var rowStruct = this.rowStructs[row];
|
||||
|
||||
if (rowStruct.moreEls) {
|
||||
rowStruct.moreEls.remove();
|
||||
rowStruct.moreEls = null;
|
||||
}
|
||||
|
||||
if (rowStruct.limitedEls) {
|
||||
rowStruct.limitedEls.removeClass('fc-limited');
|
||||
rowStruct.limitedEls = null;
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Renders an <a> element that represents hidden event element for a cell.
|
||||
// Responsible for attaching click handler as well.
|
||||
renderMoreLink: function(cell, hiddenSegs) {
|
||||
var _this = this;
|
||||
var view = this.view;
|
||||
|
||||
return $('<a class="fc-more"/>')
|
||||
.text(
|
||||
this.getMoreLinkText(hiddenSegs.length)
|
||||
)
|
||||
.on('click', function(ev) {
|
||||
var clickOption = view.opt('eventLimitClick');
|
||||
var date = view.cellToDate(cell);
|
||||
var moreEl = $(this);
|
||||
var dayEl = _this.getCellDayEl(cell);
|
||||
var allSegs = _this.getCellSegs(cell);
|
||||
|
||||
// rescope the segments to be within the cell's date
|
||||
var reslicedAllSegs = _this.resliceDaySegs(allSegs, date);
|
||||
var reslicedHiddenSegs = _this.resliceDaySegs(hiddenSegs, date);
|
||||
|
||||
if (typeof clickOption === 'function') {
|
||||
// the returned value can be an atomic option
|
||||
clickOption = view.trigger('eventLimitClick', null, {
|
||||
date: date,
|
||||
dayEl: dayEl,
|
||||
moreEl: moreEl,
|
||||
segs: reslicedAllSegs,
|
||||
hiddenSegs: reslicedHiddenSegs
|
||||
}, ev);
|
||||
}
|
||||
|
||||
if (clickOption === 'popover') {
|
||||
_this.showSegPopover(date, cell, moreEl, reslicedAllSegs);
|
||||
}
|
||||
else if (typeof clickOption === 'string') { // a view name
|
||||
view.calendar.zoomTo(date, clickOption);
|
||||
}
|
||||
});
|
||||
},
|
||||
|
||||
|
||||
// Reveals the popover that displays all events within a cell
|
||||
showSegPopover: function(date, cell, moreLink, segs) {
|
||||
var _this = this;
|
||||
var view = this.view;
|
||||
var moreWrap = moreLink.parent(); // the <div> wrapper around the <a>
|
||||
var topEl; // the element we want to match the top coordinate of
|
||||
var options;
|
||||
|
||||
if (view.rowCnt == 1) {
|
||||
topEl = this.view.el; // will cause the popover to cover any sort of header
|
||||
}
|
||||
else {
|
||||
topEl = this.rowEls.eq(cell.row); // will align with top of row
|
||||
}
|
||||
|
||||
options = {
|
||||
className: 'fc-more-popover',
|
||||
content: this.renderSegPopoverContent(date, segs),
|
||||
parentEl: this.el,
|
||||
top: topEl.offset().top,
|
||||
autoHide: true, // when the user clicks elsewhere, hide the popover
|
||||
viewportConstrain: view.opt('popoverViewportConstrain'),
|
||||
hide: function() {
|
||||
// destroy everything when the popover is hidden
|
||||
_this.segPopover.destroy();
|
||||
_this.segPopover = null;
|
||||
_this.popoverSegs = null;
|
||||
}
|
||||
};
|
||||
|
||||
// Determine horizontal coordinate.
|
||||
// We use the moreWrap instead of the <td> to avoid border confusion.
|
||||
if (view.opt('isRTL')) {
|
||||
options.right = moreWrap.offset().left + moreWrap.outerWidth() + 1; // +1 to be over cell border
|
||||
}
|
||||
else {
|
||||
options.left = moreWrap.offset().left - 1; // -1 to be over cell border
|
||||
}
|
||||
|
||||
this.segPopover = new Popover(options);
|
||||
this.segPopover.show();
|
||||
},
|
||||
|
||||
|
||||
// Builds the inner DOM contents of the segment popover
|
||||
renderSegPopoverContent: function(date, segs) {
|
||||
var view = this.view;
|
||||
var isTheme = view.opt('theme');
|
||||
var title = date.format(view.opt('dayPopoverFormat'));
|
||||
var content = $(
|
||||
'<div class="fc-header ' + view.widgetHeaderClass + '">' +
|
||||
'<span class="fc-close ' +
|
||||
(isTheme ? 'ui-icon ui-icon-closethick' : 'fc-icon fc-icon-x') +
|
||||
'"></span>' +
|
||||
'<span class="fc-title">' +
|
||||
htmlEscape(title) +
|
||||
'</span>' +
|
||||
'<div class="fc-clear"/>' +
|
||||
'</div>' +
|
||||
'<div class="fc-body ' + view.widgetContentClass + '">' +
|
||||
'<div class="fc-event-container"></div>' +
|
||||
'</div>'
|
||||
);
|
||||
var segContainer = content.find('.fc-event-container');
|
||||
var i;
|
||||
|
||||
// render each seg's `el` and only return the visible segs
|
||||
segs = this.renderSegs(segs, true); // disableResizing=true
|
||||
this.popoverSegs = segs;
|
||||
|
||||
for (i = 0; i < segs.length; i++) {
|
||||
|
||||
// because segments in the popover are not part of a grid coordinate system, provide a hint to any
|
||||
// grids that want to do drag-n-drop about which cell it came from
|
||||
segs[i].cellDate = date;
|
||||
|
||||
segContainer.append(segs[i].el);
|
||||
}
|
||||
|
||||
return content;
|
||||
},
|
||||
|
||||
|
||||
// Given the events within an array of segment objects, reslice them to be in a single day
|
||||
resliceDaySegs: function(segs, dayDate) {
|
||||
var events = $.map(segs, function(seg) {
|
||||
return seg.event;
|
||||
});
|
||||
var dayStart = dayDate.clone().stripTime();
|
||||
var dayEnd = dayStart.clone().add(1, 'days');
|
||||
|
||||
return this.eventsToSegs(events, dayStart, dayEnd);
|
||||
},
|
||||
|
||||
|
||||
// Generates the text that should be inside a "more" link, given the number of events it represents
|
||||
getMoreLinkText: function(num) {
|
||||
var view = this.view;
|
||||
var opt = view.opt('eventLimitText');
|
||||
|
||||
if (typeof opt === 'function') {
|
||||
return opt(num);
|
||||
}
|
||||
else {
|
||||
return '+' + num + ' ' + opt;
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Returns segments within a given cell.
|
||||
// If `startLevel` is specified, returns only events including and below that level. Otherwise returns all segs.
|
||||
getCellSegs: function(cell, startLevel) {
|
||||
var segMatrix = this.rowStructs[cell.row].segMatrix;
|
||||
var level = startLevel || 0;
|
||||
var segs = [];
|
||||
var seg;
|
||||
|
||||
while (level < segMatrix.length) {
|
||||
seg = segMatrix[level][cell.col];
|
||||
if (seg) {
|
||||
segs.push(seg);
|
||||
}
|
||||
level++;
|
||||
}
|
||||
|
||||
return segs;
|
||||
}
|
||||
|
||||
});
|
||||
@@ -0,0 +1,427 @@
|
||||
|
||||
/* Tracks mouse movements over a CoordMap and raises events about which cell the mouse is over.
|
||||
----------------------------------------------------------------------------------------------------------------------*/
|
||||
// TODO: implement scrolling
|
||||
|
||||
function DragListener(coordMap, options) {
|
||||
this.coordMap = coordMap;
|
||||
this.options = options || {};
|
||||
}
|
||||
|
||||
|
||||
DragListener.prototype = {
|
||||
|
||||
coordMap: null,
|
||||
options: null,
|
||||
|
||||
isListening: false,
|
||||
isDragging: false,
|
||||
|
||||
// the cell/date the mouse was over when listening started
|
||||
origCell: null,
|
||||
origDate: null,
|
||||
|
||||
// the cell/date the mouse is over
|
||||
cell: null,
|
||||
date: null,
|
||||
|
||||
// coordinates of the initial mousedown
|
||||
mouseX0: null,
|
||||
mouseY0: null,
|
||||
|
||||
// handler attached to the document, bound to the DragListener's `this`
|
||||
mousemoveProxy: null,
|
||||
mouseupProxy: null,
|
||||
|
||||
scrollEl: null,
|
||||
scrollBounds: null, // { top, bottom, left, right }
|
||||
scrollTopVel: null, // pixels per second
|
||||
scrollLeftVel: null, // pixels per second
|
||||
scrollIntervalId: null, // ID of setTimeout for scrolling animation loop
|
||||
scrollHandlerProxy: null, // this-scoped function for handling when scrollEl is scrolled
|
||||
|
||||
scrollSensitivity: 30, // pixels from edge for scrolling to start
|
||||
scrollSpeed: 200, // pixels per second, at maximum speed
|
||||
scrollIntervalMs: 50, // millisecond wait between scroll increment
|
||||
|
||||
|
||||
// Call this when the user does a mousedown. Will probably lead to startListening
|
||||
mousedown: function(ev) {
|
||||
if (isPrimaryMouseButton(ev)) {
|
||||
|
||||
ev.preventDefault(); // prevents native selection in most browsers
|
||||
|
||||
this.startListening(ev);
|
||||
|
||||
// start the drag immediately if there is no minimum distance for a drag start
|
||||
if (!this.options.distance) {
|
||||
this.startDrag(ev);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Call this to start tracking mouse movements
|
||||
startListening: function(ev) {
|
||||
var scrollParent;
|
||||
var cell;
|
||||
|
||||
if (!this.isListening) {
|
||||
|
||||
// grab scroll container and attach handler
|
||||
if (ev && this.options.scroll) {
|
||||
scrollParent = getScrollParent($(ev.target));
|
||||
if (!scrollParent.is(window) && !scrollParent.is(document)) {
|
||||
this.scrollEl = scrollParent;
|
||||
|
||||
// scope to `this`, and use `debounce` to make sure rapid calls don't happen
|
||||
this.scrollHandlerProxy = debounce($.proxy(this, 'scrollHandler'), 100);
|
||||
this.scrollEl.on('scroll', this.scrollHandlerProxy);
|
||||
}
|
||||
}
|
||||
|
||||
this.computeCoords(); // relies on `scrollEl`
|
||||
|
||||
// get info on the initial cell, date, and coordinates
|
||||
if (ev) {
|
||||
cell = this.getCell(ev);
|
||||
this.origCell = cell;
|
||||
this.origDate = cell ? cell.date : null;
|
||||
|
||||
this.mouseX0 = ev.pageX;
|
||||
this.mouseY0 = ev.pageY;
|
||||
}
|
||||
|
||||
$(document)
|
||||
.on('mousemove', this.mousemoveProxy = $.proxy(this, 'mousemove'))
|
||||
.on('mouseup', this.mouseupProxy = $.proxy(this, 'mouseup'))
|
||||
.on('selectstart', this.preventDefault); // prevents native selection in IE<=8
|
||||
|
||||
this.isListening = true;
|
||||
this.trigger('listenStart', ev);
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Recomputes the drag-critical positions of elements
|
||||
computeCoords: function() {
|
||||
this.coordMap.build();
|
||||
this.computeScrollBounds();
|
||||
},
|
||||
|
||||
|
||||
// Called when the user moves the mouse
|
||||
mousemove: function(ev) {
|
||||
var minDistance;
|
||||
var distanceSq; // current distance from mouseX0/mouseY0, squared
|
||||
|
||||
if (!this.isDragging) { // if not already dragging...
|
||||
// then start the drag if the minimum distance criteria is met
|
||||
minDistance = this.options.distance || 1;
|
||||
distanceSq = Math.pow(ev.pageX - this.mouseX0, 2) + Math.pow(ev.pageY - this.mouseY0, 2);
|
||||
if (distanceSq >= minDistance * minDistance) { // use pythagorean theorem
|
||||
this.startDrag(ev);
|
||||
}
|
||||
}
|
||||
|
||||
if (this.isDragging) {
|
||||
this.drag(ev); // report a drag, even if this mousemove initiated the drag
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Call this to initiate a legitimate drag.
|
||||
// This function is called internally from this class, but can also be called explicitly from outside
|
||||
startDrag: function(ev) {
|
||||
var cell;
|
||||
|
||||
if (!this.isListening) { // startDrag must have manually initiated
|
||||
this.startListening();
|
||||
}
|
||||
|
||||
if (!this.isDragging) {
|
||||
this.isDragging = true;
|
||||
this.trigger('dragStart', ev);
|
||||
|
||||
// report the initial cell the mouse is over
|
||||
cell = this.getCell(ev);
|
||||
if (cell) {
|
||||
this.cellOver(cell, true);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Called while the mouse is being moved and when we know a legitimate drag is taking place
|
||||
drag: function(ev) {
|
||||
var cell;
|
||||
|
||||
if (this.isDragging) {
|
||||
cell = this.getCell(ev);
|
||||
|
||||
if (!isCellsEqual(cell, this.cell)) { // a different cell than before?
|
||||
if (this.cell) {
|
||||
this.cellOut();
|
||||
}
|
||||
if (cell) {
|
||||
this.cellOver(cell);
|
||||
}
|
||||
}
|
||||
|
||||
this.dragScroll(ev); // will possibly cause scrolling
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Called when a the mouse has just moved over a new cell
|
||||
cellOver: function(cell) {
|
||||
this.cell = cell;
|
||||
this.date = cell.date;
|
||||
this.trigger('cellOver', cell, cell.date);
|
||||
},
|
||||
|
||||
|
||||
// Called when the mouse has just moved out of a cell
|
||||
cellOut: function() {
|
||||
if (this.cell) {
|
||||
this.trigger('cellOut', this.cell);
|
||||
this.cell = null;
|
||||
this.date = null;
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Called when the user does a mouseup
|
||||
mouseup: function(ev) {
|
||||
this.stopDrag(ev);
|
||||
this.stopListening(ev);
|
||||
},
|
||||
|
||||
|
||||
// Called when the drag is over. Will not cause listening to stop however.
|
||||
// A concluding 'cellOut' event will NOT be triggered.
|
||||
stopDrag: function(ev) {
|
||||
if (this.isDragging) {
|
||||
this.stopScrolling();
|
||||
this.trigger('dragStop', ev);
|
||||
this.isDragging = false;
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Call this to stop listening to the user's mouse events
|
||||
stopListening: function(ev) {
|
||||
if (this.isListening) {
|
||||
|
||||
// remove the scroll handler if there is a scrollEl
|
||||
if (this.scrollEl) {
|
||||
this.scrollEl.off('scroll', this.scrollHandlerProxy);
|
||||
this.scrollHandlerProxy = null;
|
||||
}
|
||||
|
||||
$(document)
|
||||
.off('mousemove', this.mousemoveProxy)
|
||||
.off('mouseup', this.mouseupProxy)
|
||||
.off('selectstart', this.preventDefault);
|
||||
|
||||
this.mousemoveProxy = null;
|
||||
this.mouseupProxy = null;
|
||||
|
||||
this.isListening = false;
|
||||
this.trigger('listenStop', ev);
|
||||
|
||||
this.origCell = this.cell = null;
|
||||
this.origDate = this.date = null;
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Gets the cell underneath the coordinates for the given mouse event
|
||||
getCell: function(ev) {
|
||||
return this.coordMap.getCell(ev.pageX, ev.pageY);
|
||||
},
|
||||
|
||||
|
||||
// Triggers a callback. Calls a function in the option hash of the same name.
|
||||
// Arguments beyond the first `name` are forwarded on.
|
||||
trigger: function(name) {
|
||||
if (this.options[name]) {
|
||||
this.options[name].apply(this, Array.prototype.slice.call(arguments, 1));
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Stops a given mouse event from doing it's native browser action. In our case, text selection.
|
||||
preventDefault: function(ev) {
|
||||
ev.preventDefault();
|
||||
},
|
||||
|
||||
|
||||
/* Scrolling
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Computes and stores the bounding rectangle of scrollEl
|
||||
computeScrollBounds: function() {
|
||||
var el = this.scrollEl;
|
||||
var offset;
|
||||
|
||||
if (el) {
|
||||
offset = el.offset();
|
||||
this.scrollBounds = {
|
||||
top: offset.top,
|
||||
left: offset.left,
|
||||
bottom: offset.top + el.outerHeight(),
|
||||
right: offset.left + el.outerWidth()
|
||||
};
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Called when the dragging is in progress and scrolling should be updated
|
||||
dragScroll: function(ev) {
|
||||
var sensitivity = this.scrollSensitivity;
|
||||
var bounds = this.scrollBounds;
|
||||
var topCloseness, bottomCloseness;
|
||||
var leftCloseness, rightCloseness;
|
||||
var topVel = 0;
|
||||
var leftVel = 0;
|
||||
|
||||
if (bounds) { // only scroll if scrollEl exists
|
||||
|
||||
// compute closeness to edges. valid range is from 0.0 - 1.0
|
||||
topCloseness = (sensitivity - (ev.pageY - bounds.top)) / sensitivity;
|
||||
bottomCloseness = (sensitivity - (bounds.bottom - ev.pageY)) / sensitivity;
|
||||
leftCloseness = (sensitivity - (ev.pageX - bounds.left)) / sensitivity;
|
||||
rightCloseness = (sensitivity - (bounds.right - ev.pageX)) / sensitivity;
|
||||
|
||||
// translate vertical closeness into velocity.
|
||||
// mouse must be completely in bounds for velocity to happen.
|
||||
if (topCloseness >= 0 && topCloseness <= 1) {
|
||||
topVel = topCloseness * this.scrollSpeed * -1; // negative. for scrolling up
|
||||
}
|
||||
else if (bottomCloseness >= 0 && bottomCloseness <= 1) {
|
||||
topVel = bottomCloseness * this.scrollSpeed;
|
||||
}
|
||||
|
||||
// translate horizontal closeness into velocity
|
||||
if (leftCloseness >= 0 && leftCloseness <= 1) {
|
||||
leftVel = leftCloseness * this.scrollSpeed * -1; // negative. for scrolling left
|
||||
}
|
||||
else if (rightCloseness >= 0 && rightCloseness <= 1) {
|
||||
leftVel = rightCloseness * this.scrollSpeed;
|
||||
}
|
||||
}
|
||||
|
||||
this.setScrollVel(topVel, leftVel);
|
||||
},
|
||||
|
||||
|
||||
// Sets the speed-of-scrolling for the scrollEl
|
||||
setScrollVel: function(topVel, leftVel) {
|
||||
|
||||
this.scrollTopVel = topVel;
|
||||
this.scrollLeftVel = leftVel;
|
||||
|
||||
this.constrainScrollVel(); // massages into realistic values
|
||||
|
||||
// if there is non-zero velocity, and an animation loop hasn't already started, then START
|
||||
if ((this.scrollTopVel || this.scrollLeftVel) && !this.scrollIntervalId) {
|
||||
this.scrollIntervalId = setInterval(
|
||||
$.proxy(this, 'scrollIntervalFunc'), // scope to `this`
|
||||
this.scrollIntervalMs
|
||||
);
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Forces scrollTopVel and scrollLeftVel to be zero if scrolling has already gone all the way
|
||||
constrainScrollVel: function() {
|
||||
var el = this.scrollEl;
|
||||
|
||||
if (this.scrollTopVel < 0) { // scrolling up?
|
||||
if (el.scrollTop() <= 0) { // already scrolled all the way up?
|
||||
this.scrollTopVel = 0;
|
||||
}
|
||||
}
|
||||
else if (this.scrollTopVel > 0) { // scrolling down?
|
||||
if (el.scrollTop() + el[0].clientHeight >= el[0].scrollHeight) { // already scrolled all the way down?
|
||||
this.scrollTopVel = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (this.scrollLeftVel < 0) { // scrolling left?
|
||||
if (el.scrollLeft() <= 0) { // already scrolled all the left?
|
||||
this.scrollLeftVel = 0;
|
||||
}
|
||||
}
|
||||
else if (this.scrollLeftVel > 0) { // scrolling right?
|
||||
if (el.scrollLeft() + el[0].clientWidth >= el[0].scrollWidth) { // already scrolled all the way right?
|
||||
this.scrollLeftVel = 0;
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// This function gets called during every iteration of the scrolling animation loop
|
||||
scrollIntervalFunc: function() {
|
||||
var el = this.scrollEl;
|
||||
var frac = this.scrollIntervalMs / 1000; // considering animation frequency, what the vel should be mult'd by
|
||||
|
||||
// change the value of scrollEl's scroll
|
||||
if (this.scrollTopVel) {
|
||||
el.scrollTop(el.scrollTop() + this.scrollTopVel * frac);
|
||||
}
|
||||
if (this.scrollLeftVel) {
|
||||
el.scrollLeft(el.scrollLeft() + this.scrollLeftVel * frac);
|
||||
}
|
||||
|
||||
this.constrainScrollVel(); // since the scroll values changed, recompute the velocities
|
||||
|
||||
// if scrolled all the way, which causes the vels to be zero, stop the animation loop
|
||||
if (!this.scrollTopVel && !this.scrollLeftVel) {
|
||||
this.stopScrolling();
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Kills any existing scrolling animation loop
|
||||
stopScrolling: function() {
|
||||
if (this.scrollIntervalId) {
|
||||
clearInterval(this.scrollIntervalId);
|
||||
this.scrollIntervalId = null;
|
||||
|
||||
// when all done with scrolling, recompute positions since they probably changed
|
||||
this.computeCoords();
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Get called when the scrollEl is scrolled (NOTE: this is delayed via debounce)
|
||||
scrollHandler: function() {
|
||||
// recompute all coordinates, but *only* if this is *not* part of our scrolling animation
|
||||
if (!this.scrollIntervalId) {
|
||||
this.computeCoords();
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
// Returns `true` if the cells are identically equal. `false` otherwise.
|
||||
// They must have the same row, col, and be from the same grid.
|
||||
// Two null values will be considered equal, as two "out of the grid" states are the same.
|
||||
function isCellsEqual(cell1, cell2) {
|
||||
|
||||
if (!cell1 && !cell2) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (cell1 && cell2) {
|
||||
return cell1.grid === cell2.grid &&
|
||||
cell1.row === cell2.row &&
|
||||
cell1.col === cell2.col;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
@@ -0,0 +1,421 @@
|
||||
|
||||
/* Event-rendering and event-interaction methods for the abstract Grid class
|
||||
----------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
$.extend(Grid.prototype, {
|
||||
|
||||
mousedOverSeg: null, // the segment object the user's mouse is over. null if over nothing
|
||||
isDraggingSeg: false, // is a segment being dragged? boolean
|
||||
isResizingSeg: false, // is a segment being resized? boolean
|
||||
|
||||
|
||||
// Renders the given events onto the grid
|
||||
renderEvents: function(events) {
|
||||
// subclasses must implement
|
||||
},
|
||||
|
||||
|
||||
// Retrieves all rendered segment objects in this grid
|
||||
getSegs: function() {
|
||||
// subclasses must implement
|
||||
},
|
||||
|
||||
|
||||
// Unrenders all events. Subclasses should implement, calling this super-method first.
|
||||
destroyEvents: function() {
|
||||
this.triggerSegMouseout(); // trigger an eventMouseout if user's mouse is over an event
|
||||
},
|
||||
|
||||
|
||||
// Renders a `el` property for each seg, and only returns segments that successfully rendered
|
||||
renderSegs: function(segs, disableResizing) {
|
||||
var view = this.view;
|
||||
var html = '';
|
||||
var renderedSegs = [];
|
||||
var i;
|
||||
|
||||
// build a large concatenation of event segment HTML
|
||||
for (i = 0; i < segs.length; i++) {
|
||||
html += this.renderSegHtml(segs[i], disableResizing);
|
||||
}
|
||||
|
||||
// Grab individual elements from the combined HTML string. Use each as the default rendering.
|
||||
// Then, compute the 'el' for each segment. An el might be null if the eventRender callback returned false.
|
||||
$(html).each(function(i, node) {
|
||||
var seg = segs[i];
|
||||
var el = view.resolveEventEl(seg.event, $(node));
|
||||
if (el) {
|
||||
el.data('fc-seg', seg); // used by handlers
|
||||
seg.el = el;
|
||||
renderedSegs.push(seg);
|
||||
}
|
||||
});
|
||||
|
||||
return renderedSegs;
|
||||
},
|
||||
|
||||
|
||||
// Generates the HTML for the default rendering of a segment
|
||||
renderSegHtml: function(seg, disableResizing) {
|
||||
// subclasses must implement
|
||||
},
|
||||
|
||||
|
||||
// Converts an array of event objects into an array of segment objects
|
||||
eventsToSegs: function(events, intervalStart, intervalEnd) {
|
||||
var _this = this;
|
||||
|
||||
return $.map(events, function(event) {
|
||||
return _this.eventToSegs(event, intervalStart, intervalEnd); // $.map flattens all returned arrays together
|
||||
});
|
||||
},
|
||||
|
||||
|
||||
// Slices a single event into an array of event segments.
|
||||
// When `intervalStart` and `intervalEnd` are specified, intersect the events with that interval.
|
||||
// Otherwise, let the subclass decide how it wants to slice the segments over the grid.
|
||||
eventToSegs: function(event, intervalStart, intervalEnd) {
|
||||
var eventStart = event.start.clone().stripZone(); // normalize
|
||||
var eventEnd = this.view.calendar.getEventEnd(event).stripZone(); // compute (if necessary) and normalize
|
||||
var segs;
|
||||
var i, seg;
|
||||
|
||||
if (intervalStart && intervalEnd) {
|
||||
seg = intersectionToSeg(eventStart, eventEnd, intervalStart, intervalEnd);
|
||||
segs = seg ? [ seg ] : [];
|
||||
}
|
||||
else {
|
||||
segs = this.rangeToSegs(eventStart, eventEnd); // defined by the subclass
|
||||
}
|
||||
|
||||
// assign extra event-related properties to the segment objects
|
||||
for (i = 0; i < segs.length; i++) {
|
||||
seg = segs[i];
|
||||
seg.event = event;
|
||||
seg.eventStartMS = +eventStart;
|
||||
seg.eventDurationMS = eventEnd - eventStart;
|
||||
}
|
||||
|
||||
return segs;
|
||||
},
|
||||
|
||||
|
||||
/* Handlers
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Attaches event-element-related handlers to the container element and leverage bubbling
|
||||
bindSegHandlers: function() {
|
||||
var _this = this;
|
||||
var view = this.view;
|
||||
|
||||
$.each(
|
||||
{
|
||||
mouseenter: function(seg, ev) {
|
||||
_this.triggerSegMouseover(seg, ev);
|
||||
},
|
||||
mouseleave: function(seg, ev) {
|
||||
_this.triggerSegMouseout(seg, ev);
|
||||
},
|
||||
click: function(seg, ev) {
|
||||
return view.trigger('eventClick', this, seg.event, ev); // can return `false` to cancel
|
||||
},
|
||||
mousedown: function(seg, ev) {
|
||||
if ($(ev.target).is('.fc-resizer') && view.isEventResizable(seg.event)) {
|
||||
_this.segResizeMousedown(seg, ev);
|
||||
}
|
||||
else if (view.isEventDraggable(seg.event)) {
|
||||
_this.segDragMousedown(seg, ev);
|
||||
}
|
||||
}
|
||||
},
|
||||
function(name, func) {
|
||||
// attach the handler to the container element and only listen for real event elements via bubbling
|
||||
_this.el.on(name, '.fc-event-container > *', function(ev) {
|
||||
var seg = $(this).data('fc-seg'); // grab segment data. put there by View::renderEvents
|
||||
|
||||
// only call the handlers if there is not a drag/resize in progress
|
||||
if (seg && !_this.isDraggingSeg && !_this.isResizingSeg) {
|
||||
return func.call(this, seg, ev); // `this` will be the event element
|
||||
}
|
||||
});
|
||||
}
|
||||
);
|
||||
},
|
||||
|
||||
|
||||
// Updates internal state and triggers handlers for when an event element is moused over
|
||||
triggerSegMouseover: function(seg, ev) {
|
||||
if (!this.mousedOverSeg) {
|
||||
this.mousedOverSeg = seg;
|
||||
this.view.trigger('eventMouseover', seg.el[0], seg.event, ev);
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Updates internal state and triggers handlers for when an event element is moused out.
|
||||
// Can be given no arguments, in which case it will mouseout the segment that was previously moused over.
|
||||
triggerSegMouseout: function(seg, ev) {
|
||||
ev = ev || {}; // if given no args, make a mock mouse event
|
||||
|
||||
if (this.mousedOverSeg) {
|
||||
seg = seg || this.mousedOverSeg; // if given no args, use the currently moused-over segment
|
||||
this.mousedOverSeg = null;
|
||||
this.view.trigger('eventMouseout', seg.el[0], seg.event, ev);
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
/* Dragging
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Called when the user does a mousedown on an event, which might lead to dragging.
|
||||
// Generic enough to work with any type of Grid.
|
||||
segDragMousedown: function(seg, ev) {
|
||||
var _this = this;
|
||||
var view = this.view;
|
||||
var el = seg.el;
|
||||
var event = seg.event;
|
||||
var newStart, newEnd;
|
||||
|
||||
// A clone of the original element that will move with the mouse
|
||||
var mouseFollower = new MouseFollower(seg.el, {
|
||||
parentEl: view.el,
|
||||
opacity: view.opt('dragOpacity'),
|
||||
revertDuration: view.opt('dragRevertDuration'),
|
||||
zIndex: 2 // one above the .fc-view
|
||||
});
|
||||
|
||||
// Tracks mouse movement over the *view's* coordinate map. Allows dragging and dropping between subcomponents
|
||||
// of the view.
|
||||
var dragListener = new DragListener(view.coordMap, {
|
||||
distance: 5,
|
||||
scroll: view.opt('dragScroll'),
|
||||
listenStart: function(ev) {
|
||||
mouseFollower.hide(); // don't show until we know this is a real drag
|
||||
mouseFollower.start(ev);
|
||||
},
|
||||
dragStart: function(ev) {
|
||||
_this.triggerSegMouseout(seg, ev); // ensure a mouseout on the manipulated event has been reported
|
||||
_this.isDraggingSeg = true;
|
||||
view.hideEvent(event); // hide all event segments. our mouseFollower will take over
|
||||
view.trigger('eventDragStart', el[0], event, ev, {}); // last argument is jqui dummy
|
||||
},
|
||||
cellOver: function(cell, date) {
|
||||
var origDate = seg.cellDate || dragListener.origDate;
|
||||
var res = _this.computeDraggedEventDates(seg, origDate, date);
|
||||
newStart = res.start;
|
||||
newEnd = res.end;
|
||||
|
||||
if (view.renderDrag(newStart, newEnd, seg)) { // have the view render a visual indication
|
||||
mouseFollower.hide(); // if the view is already using a mock event "helper", hide our own
|
||||
}
|
||||
else {
|
||||
mouseFollower.show();
|
||||
}
|
||||
},
|
||||
cellOut: function() { // called before mouse moves to a different cell OR moved out of all cells
|
||||
newStart = null;
|
||||
view.destroyDrag(); // unrender whatever was done in view.renderDrag
|
||||
mouseFollower.show(); // show in case we are moving out of all cells
|
||||
},
|
||||
dragStop: function(ev) {
|
||||
var hasChanged = newStart && !newStart.isSame(event.start);
|
||||
|
||||
// do revert animation if hasn't changed. calls a callback when finished (whether animation or not)
|
||||
mouseFollower.stop(!hasChanged, function() {
|
||||
_this.isDraggingSeg = false;
|
||||
view.destroyDrag();
|
||||
view.showEvent(event);
|
||||
view.trigger('eventDragStop', el[0], event, ev, {}); // last argument is jqui dummy
|
||||
|
||||
if (hasChanged) {
|
||||
view.eventDrop(el[0], event, newStart, ev); // will rerender all events...
|
||||
}
|
||||
});
|
||||
},
|
||||
listenStop: function() {
|
||||
mouseFollower.stop(); // put in listenStop in case there was a mousedown but the drag never started
|
||||
}
|
||||
});
|
||||
|
||||
dragListener.mousedown(ev); // start listening, which will eventually lead to a dragStart
|
||||
},
|
||||
|
||||
|
||||
// Given a segment, the dates where a drag began and ended, calculates the Event Object's new start and end dates
|
||||
computeDraggedEventDates: function(seg, dragStartDate, dropDate) {
|
||||
var view = this.view;
|
||||
var event = seg.event;
|
||||
var start = event.start;
|
||||
var end = view.calendar.getEventEnd(event);
|
||||
var delta;
|
||||
var newStart;
|
||||
var newEnd;
|
||||
|
||||
if (dropDate.hasTime() === dragStartDate.hasTime()) {
|
||||
delta = dayishDiff(dropDate, dragStartDate);
|
||||
newStart = start.clone().add(delta);
|
||||
if (event.end === null) { // do we need to compute an end?
|
||||
newEnd = null;
|
||||
}
|
||||
else {
|
||||
newEnd = end.clone().add(delta);
|
||||
}
|
||||
}
|
||||
else {
|
||||
// if switching from day <-> timed, start should be reset to the dropped date, and the end cleared
|
||||
newStart = dropDate;
|
||||
newEnd = null; // end should be cleared
|
||||
}
|
||||
|
||||
return { start: newStart, end: newEnd };
|
||||
},
|
||||
|
||||
|
||||
/* Resizing
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Called when the user does a mousedown on an event's resizer, which might lead to resizing.
|
||||
// Generic enough to work with any type of Grid.
|
||||
segResizeMousedown: function(seg, ev) {
|
||||
var _this = this;
|
||||
var view = this.view;
|
||||
var el = seg.el;
|
||||
var event = seg.event;
|
||||
var start = event.start;
|
||||
var end = view.calendar.getEventEnd(event);
|
||||
var newEnd = null;
|
||||
var dragListener;
|
||||
|
||||
function destroy() { // resets the rendering
|
||||
_this.destroyResize();
|
||||
view.showEvent(event);
|
||||
}
|
||||
|
||||
// Tracks mouse movement over the *grid's* coordinate map
|
||||
dragListener = new DragListener(this.coordMap, {
|
||||
distance: 5,
|
||||
scroll: view.opt('dragScroll'),
|
||||
dragStart: function(ev) {
|
||||
_this.triggerSegMouseout(seg, ev); // ensure a mouseout on the manipulated event has been reported
|
||||
_this.isResizingSeg = true;
|
||||
view.trigger('eventResizeStart', el[0], event, ev, {}); // last argument is jqui dummy
|
||||
},
|
||||
cellOver: function(cell, date) {
|
||||
// compute the new end. don't allow it to go before the event's start
|
||||
if (date.isBefore(start)) { // allows comparing ambig to non-ambig
|
||||
date = start;
|
||||
}
|
||||
newEnd = date.clone().add(_this.cellDuration); // make it an exclusive end
|
||||
|
||||
if (newEnd.isSame(end)) {
|
||||
newEnd = null;
|
||||
destroy();
|
||||
}
|
||||
else {
|
||||
_this.renderResize(start, newEnd, seg);
|
||||
view.hideEvent(event);
|
||||
}
|
||||
},
|
||||
cellOut: function() { // called before mouse moves to a different cell OR moved out of all cells
|
||||
newEnd = null;
|
||||
destroy();
|
||||
},
|
||||
dragStop: function(ev) {
|
||||
_this.isResizingSeg = false;
|
||||
destroy();
|
||||
view.trigger('eventResizeStop', el[0], event, ev, {}); // last argument is jqui dummy
|
||||
|
||||
if (newEnd) {
|
||||
view.eventResize(el[0], event, newEnd, ev); // will rerender all events...
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
dragListener.mousedown(ev); // start listening, which will eventually lead to a dragStart
|
||||
},
|
||||
|
||||
|
||||
/* Rendering Utils
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Generic utility for generating the HTML classNames for an event segment's element
|
||||
getSegClasses: function(seg, isDraggable, isResizable) {
|
||||
var event = seg.event;
|
||||
var classes = [
|
||||
'fc-event',
|
||||
seg.isStart ? 'fc-start' : 'fc-not-start',
|
||||
seg.isEnd ? 'fc-end' : 'fc-not-end'
|
||||
].concat(
|
||||
event.className,
|
||||
event.source ? event.source.className : []
|
||||
);
|
||||
|
||||
if (isDraggable) {
|
||||
classes.push('fc-draggable');
|
||||
}
|
||||
if (isResizable) {
|
||||
classes.push('fc-resizable');
|
||||
}
|
||||
|
||||
return classes;
|
||||
},
|
||||
|
||||
|
||||
// Utility for generating a CSS string with all the event skin-related properties
|
||||
getEventSkinCss: function(event) {
|
||||
var view = this.view;
|
||||
var source = event.source || {};
|
||||
var eventColor = event.color;
|
||||
var sourceColor = source.color;
|
||||
var optionColor = view.opt('eventColor');
|
||||
var backgroundColor =
|
||||
event.backgroundColor ||
|
||||
eventColor ||
|
||||
source.backgroundColor ||
|
||||
sourceColor ||
|
||||
view.opt('eventBackgroundColor') ||
|
||||
optionColor;
|
||||
var borderColor =
|
||||
event.borderColor ||
|
||||
eventColor ||
|
||||
source.borderColor ||
|
||||
sourceColor ||
|
||||
view.opt('eventBorderColor') ||
|
||||
optionColor;
|
||||
var textColor =
|
||||
event.textColor ||
|
||||
source.textColor ||
|
||||
view.opt('eventTextColor');
|
||||
var statements = [];
|
||||
if (backgroundColor) {
|
||||
statements.push('background-color:' + backgroundColor);
|
||||
}
|
||||
if (borderColor) {
|
||||
statements.push('border-color:' + borderColor);
|
||||
}
|
||||
if (textColor) {
|
||||
statements.push('color:' + textColor);
|
||||
}
|
||||
return statements.join(';');
|
||||
}
|
||||
|
||||
});
|
||||
|
||||
|
||||
/* Event Segment Utilities
|
||||
----------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// A cmp function for determining which segments should take visual priority
|
||||
function compareSegs(seg1, seg2) {
|
||||
return seg1.eventStartMS - seg2.eventStartMS || // earlier events go first
|
||||
seg2.eventDurationMS - seg1.eventDurationMS || // tie? longer events go first
|
||||
seg2.event.allDay - seg1.event.allDay || // tie? put all-day events first (booleans cast to 0/1)
|
||||
(seg1.event.title || '').localeCompare(seg2.event.title); // tie? alphabetically by title
|
||||
}
|
||||
|
||||
@@ -0,0 +1,320 @@
|
||||
|
||||
/* An abstract class comprised of a "grid" of cells that each represent a specific datetime
|
||||
----------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
function Grid(view) {
|
||||
RowRenderer.call(this, view); // call the super-constructor
|
||||
this.coordMap = new GridCoordMap(this);
|
||||
}
|
||||
|
||||
|
||||
Grid.prototype = createObject(RowRenderer.prototype); // declare the super-class
|
||||
$.extend(Grid.prototype, {
|
||||
|
||||
el: null, // the containing element
|
||||
coordMap: null, // a GridCoordMap that converts pixel values to datetimes
|
||||
cellDuration: null, // a cell's duration. subclasses must assign this ASAP
|
||||
|
||||
|
||||
// Renders the grid into the `el` element.
|
||||
// Subclasses should override and call this super-method when done.
|
||||
render: function() {
|
||||
this.bindHandlers();
|
||||
},
|
||||
|
||||
|
||||
// Called when the grid's resources need to be cleaned up
|
||||
destroy: function() {
|
||||
// subclasses can implement
|
||||
},
|
||||
|
||||
|
||||
/* Coordinates & Cells
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Populates the given empty arrays with the y and x coordinates of the cells
|
||||
buildCoords: function(rows, cols) {
|
||||
// subclasses must implement
|
||||
},
|
||||
|
||||
|
||||
// Given a cell object, returns the date for that cell
|
||||
getCellDate: function(cell) {
|
||||
// subclasses must implement
|
||||
},
|
||||
|
||||
|
||||
// Given a cell object, returns the element that represents the cell's whole-day
|
||||
getCellDayEl: function(cell) {
|
||||
// subclasses must implement
|
||||
},
|
||||
|
||||
|
||||
// Converts a range with an inclusive `start` and an exclusive `end` into an array of segment objects
|
||||
rangeToSegs: function(start, end) {
|
||||
// subclasses must implement
|
||||
},
|
||||
|
||||
|
||||
/* Handlers
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Attach handlers to `this.el`, using bubbling to listen to all ancestors.
|
||||
// We don't need to undo any of this in a "destroy" method, because the view will simply remove `this.el` from the
|
||||
// DOM and jQuery will be smart enough to garbage collect the handlers.
|
||||
bindHandlers: function() {
|
||||
var _this = this;
|
||||
|
||||
this.el.on('mousedown', function(ev) {
|
||||
if (
|
||||
!$(ev.target).is('.fc-event-container *, .fc-more') && // not an an event element, or "more.." link
|
||||
!$(ev.target).closest('.fc-popover').length // not on a popover (like the "more.." events one)
|
||||
) {
|
||||
_this.dayMousedown(ev);
|
||||
}
|
||||
});
|
||||
|
||||
this.bindSegHandlers(); // attach event-element-related handlers. in Grid.events.js
|
||||
},
|
||||
|
||||
|
||||
// Process a mousedown on an element that represents a day. For day clicking and selecting.
|
||||
dayMousedown: function(ev) {
|
||||
var _this = this;
|
||||
var view = this.view;
|
||||
var isSelectable = view.opt('selectable');
|
||||
var dates = null; // the inclusive dates of the selection. will be null if no selection
|
||||
var start; // the inclusive start of the selection
|
||||
var end; // the *exclusive* end of the selection
|
||||
var dayEl;
|
||||
|
||||
// this listener tracks a mousedown on a day element, and a subsequent drag.
|
||||
// if the drag ends on the same day, it is a 'dayClick'.
|
||||
// if 'selectable' is enabled, this listener also detects selections.
|
||||
var dragListener = new DragListener(this.coordMap, {
|
||||
//distance: 5, // needs more work if we want dayClick to fire correctly
|
||||
scroll: view.opt('dragScroll'),
|
||||
dragStart: function() {
|
||||
view.unselect(); // since we could be rendering a new selection, we want to clear any old one
|
||||
},
|
||||
cellOver: function(cell, date) {
|
||||
if (dragListener.origDate) { // click needs to have started on a cell
|
||||
|
||||
dayEl = _this.getCellDayEl(cell);
|
||||
|
||||
dates = [ date, dragListener.origDate ].sort(dateCompare);
|
||||
start = dates[0];
|
||||
end = dates[1].clone().add(_this.cellDuration);
|
||||
|
||||
if (isSelectable) {
|
||||
_this.renderSelection(start, end);
|
||||
}
|
||||
}
|
||||
},
|
||||
cellOut: function(cell, date) {
|
||||
dates = null;
|
||||
_this.destroySelection();
|
||||
},
|
||||
listenStop: function(ev) {
|
||||
if (dates) { // started and ended on a cell?
|
||||
if (dates[0].isSame(dates[1])) {
|
||||
view.trigger('dayClick', dayEl[0], start, ev);
|
||||
}
|
||||
if (isSelectable) {
|
||||
// the selection will already have been rendered. just report it
|
||||
view.reportSelection(start, end, ev);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
dragListener.mousedown(ev); // start listening, which will eventually initiate a dragStart
|
||||
},
|
||||
|
||||
|
||||
/* Event Dragging
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Renders a visual indication of a event being dragged over the given date(s).
|
||||
// `end` can be null, as well as `seg`. See View's documentation on renderDrag for more info.
|
||||
// A returned value of `true` signals that a mock "helper" event has been rendered.
|
||||
renderDrag: function(start, end, seg) {
|
||||
// subclasses must implement
|
||||
},
|
||||
|
||||
|
||||
// Unrenders a visual indication of an event being dragged
|
||||
destroyDrag: function() {
|
||||
// subclasses must implement
|
||||
},
|
||||
|
||||
|
||||
/* Event Resizing
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Renders a visual indication of an event being resized.
|
||||
// `start` and `end` are the updated dates of the event. `seg` is the original segment object involved in the drag.
|
||||
renderResize: function(start, end, seg) {
|
||||
// subclasses must implement
|
||||
},
|
||||
|
||||
|
||||
// Unrenders a visual indication of an event being resized.
|
||||
destroyResize: function() {
|
||||
// subclasses must implement
|
||||
},
|
||||
|
||||
|
||||
/* Event Helper
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Renders a mock event over the given date(s).
|
||||
// `end` can be null, in which case the mock event that is rendered will have a null end time.
|
||||
// `sourceSeg` is the internal segment object involved in the drag. If null, something external is dragging.
|
||||
renderRangeHelper: function(start, end, sourceSeg) {
|
||||
var view = this.view;
|
||||
var fakeEvent;
|
||||
|
||||
// compute the end time if forced to do so (this is what EventManager does)
|
||||
if (!end && view.opt('forceEventDuration')) {
|
||||
end = view.calendar.getDefaultEventEnd(!start.hasTime(), start);
|
||||
}
|
||||
|
||||
fakeEvent = sourceSeg ? createObject(sourceSeg.event) : {}; // mask the original event object if possible
|
||||
fakeEvent.start = start;
|
||||
fakeEvent.end = end;
|
||||
fakeEvent.allDay = !(start.hasTime() || (end && end.hasTime())); // freshly compute allDay
|
||||
|
||||
// this extra className will be useful for differentiating real events from mock events in CSS
|
||||
fakeEvent.className = (fakeEvent.className || []).concat('fc-helper');
|
||||
|
||||
// if something external is being dragged in, don't render a resizer
|
||||
if (!sourceSeg) {
|
||||
fakeEvent.editable = false;
|
||||
}
|
||||
|
||||
this.renderHelper(fakeEvent, sourceSeg); // do the actual rendering
|
||||
},
|
||||
|
||||
|
||||
// Renders a mock event
|
||||
renderHelper: function(event, sourceSeg) {
|
||||
// subclasses must implement
|
||||
},
|
||||
|
||||
|
||||
// Unrenders a mock event
|
||||
destroyHelper: function() {
|
||||
// subclasses must implement
|
||||
},
|
||||
|
||||
|
||||
/* Selection
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Renders a visual indication of a selection. Will highlight by default but can be overridden by subclasses.
|
||||
renderSelection: function(start, end) {
|
||||
this.renderHighlight(start, end);
|
||||
},
|
||||
|
||||
|
||||
// Unrenders any visual indications of a selection. Will unrender a highlight by default.
|
||||
destroySelection: function() {
|
||||
this.destroyHighlight();
|
||||
},
|
||||
|
||||
|
||||
/* Highlight
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Puts visual emphasis on a certain date range
|
||||
renderHighlight: function(start, end) {
|
||||
// subclasses should implement
|
||||
},
|
||||
|
||||
|
||||
// Removes visual emphasis on a date range
|
||||
destroyHighlight: function() {
|
||||
// subclasses should implement
|
||||
},
|
||||
|
||||
|
||||
|
||||
/* Generic rendering utilities for subclasses
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Renders a day-of-week header row
|
||||
headHtml: function() {
|
||||
return '' +
|
||||
'<div class="fc-row ' + this.view.widgetHeaderClass + '">' +
|
||||
'<table>' +
|
||||
'<thead>' +
|
||||
this.rowHtml('head') + // leverages RowRenderer
|
||||
'</thead>' +
|
||||
'</table>' +
|
||||
'</div>';
|
||||
},
|
||||
|
||||
|
||||
// Used by the `headHtml` method, via RowRenderer, for rendering the HTML of a day-of-week header cell
|
||||
headCellHtml: function(row, col, date) {
|
||||
var view = this.view;
|
||||
var calendar = view.calendar;
|
||||
var colFormat = view.opt('columnFormat');
|
||||
|
||||
return '' +
|
||||
'<th class="fc-day-header ' + view.widgetHeaderClass + ' fc-' + dayIDs[date.day()] + '">' +
|
||||
htmlEscape(calendar.formatDate(date, colFormat)) +
|
||||
'</th>';
|
||||
},
|
||||
|
||||
|
||||
// Renders the HTML for a single-day background cell
|
||||
bgCellHtml: function(row, col, date) {
|
||||
var view = this.view;
|
||||
var classes = this.getDayClasses(date);
|
||||
|
||||
classes.unshift('fc-day', view.widgetContentClass);
|
||||
|
||||
return '<td class="' + classes.join(' ') + '" data-date="' + date.format() + '"></td>';
|
||||
},
|
||||
|
||||
|
||||
// Computes HTML classNames for a single-day cell
|
||||
getDayClasses: function(date) {
|
||||
var view = this.view;
|
||||
var today = view.calendar.getNow().stripTime();
|
||||
var classes = [ 'fc-' + dayIDs[date.day()] ];
|
||||
|
||||
if (
|
||||
view.name === 'month' &&
|
||||
date.month() != view.intervalStart.month()
|
||||
) {
|
||||
classes.push('fc-other-month');
|
||||
}
|
||||
|
||||
if (date.isSame(today, 'day')) {
|
||||
classes.push(
|
||||
'fc-today',
|
||||
view.highlightStateClass
|
||||
);
|
||||
}
|
||||
else if (date < today) {
|
||||
classes.push('fc-past');
|
||||
}
|
||||
else {
|
||||
classes.push('fc-future');
|
||||
}
|
||||
|
||||
return classes;
|
||||
}
|
||||
|
||||
});
|
||||
@@ -0,0 +1,186 @@
|
||||
|
||||
/* Creates a clone of an element and lets it track the mouse as it moves
|
||||
----------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
function MouseFollower(sourceEl, options) {
|
||||
this.options = options = options || {};
|
||||
this.sourceEl = sourceEl;
|
||||
this.parentEl = options.parentEl ? $(options.parentEl) : sourceEl.parent(); // default to sourceEl's parent
|
||||
}
|
||||
|
||||
|
||||
MouseFollower.prototype = {
|
||||
|
||||
options: null,
|
||||
|
||||
sourceEl: null, // the element that will be cloned and made to look like it is dragging
|
||||
el: null, // the clone of `sourceEl` that will track the mouse
|
||||
parentEl: null, // the element that `el` (the clone) will be attached to
|
||||
|
||||
// the initial position of el, relative to the offset parent. made to match the initial offset of sourceEl
|
||||
top0: null,
|
||||
left0: null,
|
||||
|
||||
// the initial position of the mouse
|
||||
mouseY0: null,
|
||||
mouseX0: null,
|
||||
|
||||
// the number of pixels the mouse has moved from its initial position
|
||||
topDelta: null,
|
||||
leftDelta: null,
|
||||
|
||||
mousemoveProxy: null, // document mousemove handler, bound to the MouseFollower's `this`
|
||||
|
||||
isFollowing: false,
|
||||
isHidden: false,
|
||||
isAnimating: false, // doing the revert animation?
|
||||
|
||||
|
||||
// Causes the element to start following the mouse
|
||||
start: function(ev) {
|
||||
if (!this.isFollowing) {
|
||||
this.isFollowing = true;
|
||||
|
||||
this.mouseY0 = ev.pageY;
|
||||
this.mouseX0 = ev.pageX;
|
||||
this.topDelta = 0;
|
||||
this.leftDelta = 0;
|
||||
|
||||
if (!this.isHidden) {
|
||||
this.updatePosition();
|
||||
}
|
||||
|
||||
$(document).on('mousemove', this.mousemoveProxy = $.proxy(this, 'mousemove'));
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Causes the element to stop following the mouse. If shouldRevert is true, will animate back to original position.
|
||||
// `callback` gets invoked when the animation is complete. If no animation, it is invoked immediately.
|
||||
stop: function(shouldRevert, callback) {
|
||||
var _this = this;
|
||||
var revertDuration = this.options.revertDuration;
|
||||
|
||||
function complete() {
|
||||
this.isAnimating = false;
|
||||
_this.destroyEl();
|
||||
|
||||
this.top0 = this.left0 = null; // reset state for future updatePosition calls
|
||||
|
||||
if (callback) {
|
||||
callback();
|
||||
}
|
||||
}
|
||||
|
||||
if (this.isFollowing && !this.isAnimating) { // disallow more than one stop animation at a time
|
||||
this.isFollowing = false;
|
||||
|
||||
$(document).off('mousemove', this.mousemoveProxy);
|
||||
|
||||
if (shouldRevert && revertDuration && !this.isHidden) { // do a revert animation?
|
||||
this.isAnimating = true;
|
||||
this.el.animate({
|
||||
top: this.top0,
|
||||
left: this.left0
|
||||
}, {
|
||||
duration: revertDuration,
|
||||
complete: complete
|
||||
});
|
||||
}
|
||||
else {
|
||||
complete();
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Gets the tracking element. Create it if necessary
|
||||
getEl: function() {
|
||||
var el = this.el;
|
||||
|
||||
if (!el) {
|
||||
this.sourceEl.width(); // hack to force IE8 to compute correct bounding box
|
||||
el = this.el = this.sourceEl.clone()
|
||||
.css({
|
||||
position: 'absolute',
|
||||
visibility: '', // in case original element was hidden (commonly through hideEvents())
|
||||
display: this.isHidden ? 'none' : '', // for when initially hidden
|
||||
margin: 0,
|
||||
right: 'auto', // erase and set width instead
|
||||
bottom: 'auto', // erase and set height instead
|
||||
width: this.sourceEl.width(), // explicit height in case there was a 'right' value
|
||||
height: this.sourceEl.height(), // explicit width in case there was a 'bottom' value
|
||||
opacity: this.options.opacity || '',
|
||||
zIndex: this.options.zIndex
|
||||
})
|
||||
.appendTo(this.parentEl);
|
||||
}
|
||||
|
||||
return el;
|
||||
},
|
||||
|
||||
|
||||
// Removes the tracking element if it has already been created
|
||||
destroyEl: function() {
|
||||
if (this.el) {
|
||||
this.el.remove();
|
||||
this.el = null;
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Update the CSS position of the tracking element
|
||||
updatePosition: function() {
|
||||
var sourceOffset;
|
||||
var origin;
|
||||
|
||||
this.getEl(); // ensure this.el
|
||||
|
||||
// make sure origin info was computed
|
||||
if (this.top0 === null) {
|
||||
this.sourceEl.width(); // hack to force IE8 to compute correct bounding box
|
||||
sourceOffset = this.sourceEl.offset();
|
||||
origin = this.el.offsetParent().offset();
|
||||
this.top0 = sourceOffset.top - origin.top;
|
||||
this.left0 = sourceOffset.left - origin.left;
|
||||
}
|
||||
|
||||
this.el.css({
|
||||
top: this.top0 + this.topDelta,
|
||||
left: this.left0 + this.leftDelta
|
||||
});
|
||||
},
|
||||
|
||||
|
||||
// Gets called when the user moves the mouse
|
||||
mousemove: function(ev) {
|
||||
this.topDelta = ev.pageY - this.mouseY0;
|
||||
this.leftDelta = ev.pageX - this.mouseX0;
|
||||
|
||||
if (!this.isHidden) {
|
||||
this.updatePosition();
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Temporarily makes the tracking element invisible. Can be called before following starts
|
||||
hide: function() {
|
||||
if (!this.isHidden) {
|
||||
this.isHidden = true;
|
||||
if (this.el) {
|
||||
this.el.hide();
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Show the tracking element after it has been temporarily hidden
|
||||
show: function() {
|
||||
if (this.isHidden) {
|
||||
this.isHidden = false;
|
||||
this.updatePosition();
|
||||
this.getEl().show();
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
@@ -0,0 +1,167 @@
|
||||
|
||||
/* A rectangular panel that is absolutely positioned over other content
|
||||
------------------------------------------------------------------------------------------------------------------------
|
||||
Options:
|
||||
- className (string)
|
||||
- content (HTML string or jQuery element set)
|
||||
- parentEl
|
||||
- top
|
||||
- left
|
||||
- right (the x coord of where the right edge should be. not a "CSS" right)
|
||||
- autoHide (boolean)
|
||||
- show (callback)
|
||||
- hide (callback)
|
||||
*/
|
||||
|
||||
function Popover(options) {
|
||||
this.options = options || {};
|
||||
}
|
||||
|
||||
|
||||
Popover.prototype = {
|
||||
|
||||
isHidden: true,
|
||||
options: null,
|
||||
el: null, // the container element for the popover. generated by this object
|
||||
documentMousedownProxy: null, // document mousedown handler bound to `this`
|
||||
margin: 10, // the space required between the popover and the edges of the scroll container
|
||||
|
||||
|
||||
// Shows the popover on the specified position. Renders it if not already
|
||||
show: function() {
|
||||
if (this.isHidden) {
|
||||
if (!this.el) {
|
||||
this.render();
|
||||
}
|
||||
this.el.show();
|
||||
this.position();
|
||||
this.isHidden = false;
|
||||
this.trigger('show');
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Hides the popover, through CSS, but does not remove it from the DOM
|
||||
hide: function() {
|
||||
if (!this.isHidden) {
|
||||
this.el.hide();
|
||||
this.isHidden = true;
|
||||
this.trigger('hide');
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Creates `this.el` and renders content inside of it
|
||||
render: function() {
|
||||
var _this = this;
|
||||
var options = this.options;
|
||||
|
||||
this.el = $('<div class="fc-popover"/>')
|
||||
.addClass(options.className || '')
|
||||
.css({
|
||||
// position initially to the top left to avoid creating scrollbars
|
||||
top: 0,
|
||||
left: 0
|
||||
})
|
||||
.append(options.content)
|
||||
.appendTo(options.parentEl);
|
||||
|
||||
// when a click happens on anything inside with a 'fc-close' className, hide the popover
|
||||
this.el.on('click', '.fc-close', function() {
|
||||
_this.hide();
|
||||
});
|
||||
|
||||
if (options.autoHide) {
|
||||
$(document).on('mousedown', this.documentMousedownProxy = $.proxy(this, 'documentMousedown'));
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Triggered when the user clicks *anywhere* in the document, for the autoHide feature
|
||||
documentMousedown: function(ev) {
|
||||
// only hide the popover if the click happened outside the popover
|
||||
if (this.el && !$(ev.target).closest(this.el).length) {
|
||||
this.hide();
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Hides and unregisters any handlers
|
||||
destroy: function() {
|
||||
this.hide();
|
||||
|
||||
if (this.el) {
|
||||
this.el.remove();
|
||||
this.el = null;
|
||||
}
|
||||
|
||||
$(document).off('mousedown', this.documentMousedownProxy);
|
||||
},
|
||||
|
||||
|
||||
// Positions the popover optimally, using the top/left/right options
|
||||
position: function() {
|
||||
var options = this.options;
|
||||
var origin = this.el.offsetParent().offset();
|
||||
var width = this.el.outerWidth();
|
||||
var height = this.el.outerHeight();
|
||||
var windowEl = $(window);
|
||||
var viewportEl = getScrollParent(this.el);
|
||||
var viewportTop;
|
||||
var viewportLeft;
|
||||
var viewportOffset;
|
||||
var top; // the "position" (not "offset") values for the popover
|
||||
var left; //
|
||||
|
||||
// compute top and left
|
||||
top = options.top || 0;
|
||||
if (options.left !== undefined) {
|
||||
left = options.left;
|
||||
}
|
||||
else if (options.right !== undefined) {
|
||||
left = options.right - width; // derive the left value from the right value
|
||||
}
|
||||
else {
|
||||
left = 0;
|
||||
}
|
||||
|
||||
if (viewportEl.is(window) || viewportEl.is(document)) { // normalize getScrollParent's result
|
||||
viewportEl = windowEl;
|
||||
viewportTop = 0; // the window is always at the top left
|
||||
viewportLeft = 0; // (and .offset() won't work if called here)
|
||||
}
|
||||
else {
|
||||
viewportOffset = viewportEl.offset();
|
||||
viewportTop = viewportOffset.top;
|
||||
viewportLeft = viewportOffset.left;
|
||||
}
|
||||
|
||||
// if the window is scrolled, it causes the visible area to be further down
|
||||
viewportTop += windowEl.scrollTop();
|
||||
viewportLeft += windowEl.scrollLeft();
|
||||
|
||||
// constrain to the view port. if constrained by two edges, give precedence to top/left
|
||||
if (options.viewportConstrain !== false) {
|
||||
top = Math.min(top, viewportTop + viewportEl.outerHeight() - height - this.margin);
|
||||
top = Math.max(top, viewportTop + this.margin);
|
||||
left = Math.min(left, viewportLeft + viewportEl.outerWidth() - width - this.margin);
|
||||
left = Math.max(left, viewportLeft + this.margin);
|
||||
}
|
||||
|
||||
this.el.css({
|
||||
top: top - origin.top,
|
||||
left: left - origin.left
|
||||
});
|
||||
},
|
||||
|
||||
|
||||
// Triggers a callback. Calls a function in the option hash of the same name.
|
||||
// Arguments beyond the first `name` are forwarded on.
|
||||
// TODO: better code reuse for this. Repeat code
|
||||
trigger: function(name) {
|
||||
if (this.options[name]) {
|
||||
this.options[name].apply(this, Array.prototype.slice.call(arguments, 1));
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
@@ -0,0 +1,103 @@
|
||||
|
||||
/* A utility class for rendering <tr> rows.
|
||||
----------------------------------------------------------------------------------------------------------------------*/
|
||||
// It leverages methods of the subclass and the View to determine custom rendering behavior for each row "type"
|
||||
// (such as highlight rows, day rows, helper rows, etc).
|
||||
|
||||
function RowRenderer(view) {
|
||||
this.view = view;
|
||||
}
|
||||
|
||||
|
||||
RowRenderer.prototype = {
|
||||
|
||||
view: null, // a View object
|
||||
cellHtml: '<td/>', // plain default HTML used for a cell when no other is available
|
||||
|
||||
|
||||
// Renders the HTML for a row, leveraging custom cell-HTML-renderers based on the `rowType`.
|
||||
// Also applies the "intro" and "outro" cells, which are specified by the subclass and views.
|
||||
// `row` is an optional row number.
|
||||
rowHtml: function(rowType, row) {
|
||||
var view = this.view;
|
||||
var renderCell = this.getHtmlRenderer('cell', rowType);
|
||||
var cellHtml = '';
|
||||
var col;
|
||||
var date;
|
||||
|
||||
row = row || 0;
|
||||
|
||||
for (col = 0; col < view.colCnt; col++) {
|
||||
date = view.cellToDate(row, col);
|
||||
cellHtml += renderCell(row, col, date);
|
||||
}
|
||||
|
||||
cellHtml = this.bookendCells(cellHtml, rowType, row); // apply intro and outro
|
||||
|
||||
return '<tr>' + cellHtml + '</tr>';
|
||||
},
|
||||
|
||||
|
||||
// Applies the "intro" and "outro" HTML to the given cells.
|
||||
// Intro means the leftmost cell when the calendar is LTR and the rightmost cell when RTL. Vice-versa for outro.
|
||||
// `cells` can be an HTML string of <td>'s or a jQuery <tr> element
|
||||
// `row` is an optional row number.
|
||||
bookendCells: function(cells, rowType, row) {
|
||||
var view = this.view;
|
||||
var intro = this.getHtmlRenderer('intro', rowType)(row || 0);
|
||||
var outro = this.getHtmlRenderer('outro', rowType)(row || 0);
|
||||
var isRTL = view.opt('isRTL');
|
||||
var prependHtml = isRTL ? outro : intro;
|
||||
var appendHtml = isRTL ? intro : outro;
|
||||
|
||||
if (typeof cells === 'string') {
|
||||
return prependHtml + cells + appendHtml;
|
||||
}
|
||||
else { // a jQuery <tr> element
|
||||
return cells.prepend(prependHtml).append(appendHtml);
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Returns an HTML-rendering function given a specific `rendererName` (like cell, intro, or outro) and a specific
|
||||
// `rowType` (like day, eventSkeleton, helperSkeleton), which is optional.
|
||||
// If a renderer for the specific rowType doesn't exist, it will fall back to a generic renderer.
|
||||
// We will query the View object first for any custom rendering functions, then the methods of the subclass.
|
||||
getHtmlRenderer: function(rendererName, rowType) {
|
||||
var view = this.view;
|
||||
var generalName; // like "cellHtml"
|
||||
var specificName; // like "dayCellHtml". based on rowType
|
||||
var provider; // either the View or the RowRenderer subclass, whichever provided the method
|
||||
var renderer;
|
||||
|
||||
generalName = rendererName + 'Html';
|
||||
if (rowType) {
|
||||
specificName = rowType + capitaliseFirstLetter(rendererName) + 'Html';
|
||||
}
|
||||
|
||||
if (specificName && (renderer = view[specificName])) {
|
||||
provider = view;
|
||||
}
|
||||
else if (specificName && (renderer = this[specificName])) {
|
||||
provider = this;
|
||||
}
|
||||
else if ((renderer = view[generalName])) {
|
||||
provider = view;
|
||||
}
|
||||
else if ((renderer = this[generalName])) {
|
||||
provider = this;
|
||||
}
|
||||
|
||||
if (typeof renderer === 'function') {
|
||||
return function(row) {
|
||||
return renderer.apply(provider, arguments) || ''; // use correct `this` and always return a string
|
||||
};
|
||||
}
|
||||
|
||||
// the rendered can be a plain string as well. if not specified, always an empty string.
|
||||
return function() {
|
||||
return renderer || '';
|
||||
};
|
||||
}
|
||||
|
||||
};
|
||||
@@ -0,0 +1,424 @@
|
||||
|
||||
/* Event-rendering methods for the TimeGrid class
|
||||
----------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
$.extend(TimeGrid.prototype, {
|
||||
|
||||
segs: null, // segment objects rendered in the component. null of events haven't been rendered yet
|
||||
eventSkeletonEl: null, // has cells with event-containers, which contain absolutely positioned event elements
|
||||
|
||||
|
||||
// Renders the events onto the grid and returns an array of segments that have been rendered
|
||||
renderEvents: function(events) {
|
||||
var res = this.renderEventTable(events);
|
||||
|
||||
this.eventSkeletonEl = $('<div class="fc-content-skeleton"/>').append(res.tableEl);
|
||||
this.el.append(this.eventSkeletonEl);
|
||||
|
||||
this.segs = res.segs;
|
||||
},
|
||||
|
||||
|
||||
// Retrieves rendered segment objects
|
||||
getSegs: function() {
|
||||
return this.segs || [];
|
||||
},
|
||||
|
||||
|
||||
// Removes all event segment elements from the view
|
||||
destroyEvents: function() {
|
||||
Grid.prototype.destroyEvents.call(this); // call the super-method
|
||||
|
||||
if (this.eventSkeletonEl) {
|
||||
this.eventSkeletonEl.remove();
|
||||
this.eventSkeletonEl = null;
|
||||
}
|
||||
|
||||
this.segs = null;
|
||||
},
|
||||
|
||||
|
||||
// Renders and returns the <table> portion of the event-skeleton.
|
||||
// Returns an object with properties 'tbodyEl' and 'segs'.
|
||||
renderEventTable: function(events) {
|
||||
var tableEl = $('<table><tr/></table>');
|
||||
var trEl = tableEl.find('tr');
|
||||
var segs = this.eventsToSegs(events);
|
||||
var segCols;
|
||||
var i, seg;
|
||||
var col, colSegs;
|
||||
var containerEl;
|
||||
|
||||
segs = this.renderSegs(segs); // returns only the visible segs
|
||||
segCols = this.groupSegCols(segs); // group into sub-arrays, and assigns 'col' to each seg
|
||||
|
||||
this.computeSegVerticals(segs); // compute and assign top/bottom
|
||||
|
||||
for (col = 0; col < segCols.length; col++) { // iterate each column grouping
|
||||
colSegs = segCols[col];
|
||||
placeSlotSegs(colSegs); // compute horizontal coordinates, z-index's, and reorder the array
|
||||
|
||||
containerEl = $('<div class="fc-event-container"/>');
|
||||
|
||||
// assign positioning CSS and insert into container
|
||||
for (i = 0; i < colSegs.length; i++) {
|
||||
seg = colSegs[i];
|
||||
seg.el.css(this.generateSegPositionCss(seg));
|
||||
|
||||
// if the height is short, add a className for alternate styling
|
||||
if (seg.bottom - seg.top < 30) {
|
||||
seg.el.addClass('fc-short');
|
||||
}
|
||||
|
||||
containerEl.append(seg.el);
|
||||
}
|
||||
|
||||
trEl.append($('<td/>').append(containerEl));
|
||||
}
|
||||
|
||||
this.bookendCells(trEl, 'eventSkeleton');
|
||||
|
||||
return {
|
||||
tableEl: tableEl,
|
||||
segs: segs
|
||||
};
|
||||
},
|
||||
|
||||
|
||||
// Refreshes the CSS top/bottom coordinates for each segment element. Probably after a window resize/zoom.
|
||||
updateSegVerticals: function() {
|
||||
var segs = this.segs;
|
||||
var i;
|
||||
|
||||
if (segs) {
|
||||
this.computeSegVerticals(segs);
|
||||
|
||||
for (i = 0; i < segs.length; i++) {
|
||||
segs[i].el.css(
|
||||
this.generateSegVerticalCss(segs[i])
|
||||
);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// For each segment in an array, computes and assigns its top and bottom properties
|
||||
computeSegVerticals: function(segs) {
|
||||
var i, seg;
|
||||
|
||||
for (i = 0; i < segs.length; i++) {
|
||||
seg = segs[i];
|
||||
seg.top = this.computeDateTop(seg.start, seg.start);
|
||||
seg.bottom = this.computeDateTop(seg.end, seg.start);
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Renders the HTML for a single event segment's default rendering
|
||||
renderSegHtml: function(seg, disableResizing) {
|
||||
var view = this.view;
|
||||
var event = seg.event;
|
||||
var isDraggable = view.isEventDraggable(event);
|
||||
var isResizable = !disableResizing && seg.isEnd && view.isEventResizable(event);
|
||||
var classes = this.getSegClasses(seg, isDraggable, isResizable);
|
||||
var skinCss = this.getEventSkinCss(event);
|
||||
var timeText;
|
||||
var fullTimeText; // more verbose time text. for the print stylesheet
|
||||
var startTimeText; // just the start time text
|
||||
|
||||
classes.unshift('fc-time-grid-event');
|
||||
|
||||
if (view.isMultiDayEvent(event)) { // if the event appears to span more than one day...
|
||||
// Don't display time text on segments that run entirely through a day.
|
||||
// That would appear as midnight-midnight and would look dumb.
|
||||
// Otherwise, display the time text for the *segment's* times (like 6pm-midnight or midnight-10am)
|
||||
if (seg.isStart || seg.isEnd) {
|
||||
timeText = view.getEventTimeText(seg.start, seg.end);
|
||||
fullTimeText = view.getEventTimeText(seg.start, seg.end, 'LT');
|
||||
startTimeText = view.getEventTimeText(seg.start, null);
|
||||
}
|
||||
} else {
|
||||
// Display the normal time text for the *event's* times
|
||||
timeText = view.getEventTimeText(event);
|
||||
fullTimeText = view.getEventTimeText(event, 'LT');
|
||||
startTimeText = view.getEventTimeText(event.start, null);
|
||||
}
|
||||
|
||||
return '<a class="' + classes.join(' ') + '"' +
|
||||
(event.url ?
|
||||
' href="' + htmlEscape(event.url) + '"' :
|
||||
''
|
||||
) +
|
||||
(skinCss ?
|
||||
' style="' + skinCss + '"' :
|
||||
''
|
||||
) +
|
||||
'>' +
|
||||
'<div class="fc-content">' +
|
||||
(timeText ?
|
||||
'<div class="fc-time"' +
|
||||
' data-start="' + htmlEscape(startTimeText) + '"' +
|
||||
' data-full="' + htmlEscape(fullTimeText) + '"' +
|
||||
'>' +
|
||||
'<span>' + htmlEscape(timeText) + '</span>' +
|
||||
'</div>' :
|
||||
''
|
||||
) +
|
||||
(event.title ?
|
||||
'<div class="fc-title">' +
|
||||
htmlEscape(event.title) +
|
||||
'</div>' :
|
||||
''
|
||||
) +
|
||||
'</div>' +
|
||||
'<div class="fc-bg"/>' +
|
||||
(isResizable ?
|
||||
'<div class="fc-resizer"/>' :
|
||||
''
|
||||
) +
|
||||
'</a>';
|
||||
},
|
||||
|
||||
|
||||
// Generates an object with CSS properties/values that should be applied to an event segment element.
|
||||
// Contains important positioning-related properties that should be applied to any event element, customized or not.
|
||||
generateSegPositionCss: function(seg) {
|
||||
var view = this.view;
|
||||
var isRTL = view.opt('isRTL');
|
||||
var shouldOverlap = view.opt('slotEventOverlap');
|
||||
var backwardCoord = seg.backwardCoord; // the left side if LTR. the right side if RTL. floating-point
|
||||
var forwardCoord = seg.forwardCoord; // the right side if LTR. the left side if RTL. floating-point
|
||||
var props = this.generateSegVerticalCss(seg); // get top/bottom first
|
||||
var left; // amount of space from left edge, a fraction of the total width
|
||||
var right; // amount of space from right edge, a fraction of the total width
|
||||
|
||||
if (shouldOverlap) {
|
||||
// double the width, but don't go beyond the maximum forward coordinate (1.0)
|
||||
forwardCoord = Math.min(1, backwardCoord + (forwardCoord - backwardCoord) * 2);
|
||||
}
|
||||
|
||||
if (isRTL) {
|
||||
left = 1 - forwardCoord;
|
||||
right = backwardCoord;
|
||||
}
|
||||
else {
|
||||
left = backwardCoord;
|
||||
right = 1 - forwardCoord;
|
||||
}
|
||||
|
||||
props.zIndex = seg.level + 1; // convert from 0-base to 1-based
|
||||
props.left = left * 100 + '%';
|
||||
props.right = right * 100 + '%';
|
||||
|
||||
if (shouldOverlap && seg.forwardPressure) {
|
||||
// add padding to the edge so that forward stacked events don't cover the resizer's icon
|
||||
props[isRTL ? 'marginLeft' : 'marginRight'] = 10 * 2; // 10 is a guesstimate of the icon's width
|
||||
}
|
||||
|
||||
return props;
|
||||
},
|
||||
|
||||
|
||||
// Generates an object with CSS properties for the top/bottom coordinates of a segment element
|
||||
generateSegVerticalCss: function(seg) {
|
||||
return {
|
||||
top: seg.top,
|
||||
bottom: -seg.bottom // flipped because needs to be space beyond bottom edge of event container
|
||||
};
|
||||
},
|
||||
|
||||
|
||||
// Given a flat array of segments, return an array of sub-arrays, grouped by each segment's col
|
||||
groupSegCols: function(segs) {
|
||||
var view = this.view;
|
||||
var segCols = [];
|
||||
var i;
|
||||
|
||||
for (i = 0; i < view.colCnt; i++) {
|
||||
segCols.push([]);
|
||||
}
|
||||
|
||||
for (i = 0; i < segs.length; i++) {
|
||||
segCols[segs[i].col].push(segs[i]);
|
||||
}
|
||||
|
||||
return segCols;
|
||||
}
|
||||
|
||||
});
|
||||
|
||||
|
||||
// Given an array of segments that are all in the same column, sets the backwardCoord and forwardCoord on each.
|
||||
// Also reorders the given array by date!
|
||||
function placeSlotSegs(segs) {
|
||||
var levels;
|
||||
var level0;
|
||||
var i;
|
||||
|
||||
segs.sort(compareSegs); // order by date
|
||||
levels = buildSlotSegLevels(segs);
|
||||
computeForwardSlotSegs(levels);
|
||||
|
||||
if ((level0 = levels[0])) {
|
||||
|
||||
for (i = 0; i < level0.length; i++) {
|
||||
computeSlotSegPressures(level0[i]);
|
||||
}
|
||||
|
||||
for (i = 0; i < level0.length; i++) {
|
||||
computeSlotSegCoords(level0[i], 0, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Builds an array of segments "levels". The first level will be the leftmost tier of segments if the calendar is
|
||||
// left-to-right, or the rightmost if the calendar is right-to-left. Assumes the segments are already ordered by date.
|
||||
function buildSlotSegLevels(segs) {
|
||||
var levels = [];
|
||||
var i, seg;
|
||||
var j;
|
||||
|
||||
for (i=0; i<segs.length; i++) {
|
||||
seg = segs[i];
|
||||
|
||||
// go through all the levels and stop on the first level where there are no collisions
|
||||
for (j=0; j<levels.length; j++) {
|
||||
if (!computeSlotSegCollisions(seg, levels[j]).length) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
seg.level = j;
|
||||
|
||||
(levels[j] || (levels[j] = [])).push(seg);
|
||||
}
|
||||
|
||||
return levels;
|
||||
}
|
||||
|
||||
|
||||
// For every segment, figure out the other segments that are in subsequent
|
||||
// levels that also occupy the same vertical space. Accumulate in seg.forwardSegs
|
||||
function computeForwardSlotSegs(levels) {
|
||||
var i, level;
|
||||
var j, seg;
|
||||
var k;
|
||||
|
||||
for (i=0; i<levels.length; i++) {
|
||||
level = levels[i];
|
||||
|
||||
for (j=0; j<level.length; j++) {
|
||||
seg = level[j];
|
||||
|
||||
seg.forwardSegs = [];
|
||||
for (k=i+1; k<levels.length; k++) {
|
||||
computeSlotSegCollisions(seg, levels[k], seg.forwardSegs);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Figure out which path forward (via seg.forwardSegs) results in the longest path until
|
||||
// the furthest edge is reached. The number of segments in this path will be seg.forwardPressure
|
||||
function computeSlotSegPressures(seg) {
|
||||
var forwardSegs = seg.forwardSegs;
|
||||
var forwardPressure = 0;
|
||||
var i, forwardSeg;
|
||||
|
||||
if (seg.forwardPressure === undefined) { // not already computed
|
||||
|
||||
for (i=0; i<forwardSegs.length; i++) {
|
||||
forwardSeg = forwardSegs[i];
|
||||
|
||||
// figure out the child's maximum forward path
|
||||
computeSlotSegPressures(forwardSeg);
|
||||
|
||||
// either use the existing maximum, or use the child's forward pressure
|
||||
// plus one (for the forwardSeg itself)
|
||||
forwardPressure = Math.max(
|
||||
forwardPressure,
|
||||
1 + forwardSeg.forwardPressure
|
||||
);
|
||||
}
|
||||
|
||||
seg.forwardPressure = forwardPressure;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Calculate seg.forwardCoord and seg.backwardCoord for the segment, where both values range
|
||||
// from 0 to 1. If the calendar is left-to-right, the seg.backwardCoord maps to "left" and
|
||||
// seg.forwardCoord maps to "right" (via percentage). Vice-versa if the calendar is right-to-left.
|
||||
//
|
||||
// The segment might be part of a "series", which means consecutive segments with the same pressure
|
||||
// who's width is unknown until an edge has been hit. `seriesBackwardPressure` is the number of
|
||||
// segments behind this one in the current series, and `seriesBackwardCoord` is the starting
|
||||
// coordinate of the first segment in the series.
|
||||
function computeSlotSegCoords(seg, seriesBackwardPressure, seriesBackwardCoord) {
|
||||
var forwardSegs = seg.forwardSegs;
|
||||
var i;
|
||||
|
||||
if (seg.forwardCoord === undefined) { // not already computed
|
||||
|
||||
if (!forwardSegs.length) {
|
||||
|
||||
// if there are no forward segments, this segment should butt up against the edge
|
||||
seg.forwardCoord = 1;
|
||||
}
|
||||
else {
|
||||
|
||||
// sort highest pressure first
|
||||
forwardSegs.sort(compareForwardSlotSegs);
|
||||
|
||||
// this segment's forwardCoord will be calculated from the backwardCoord of the
|
||||
// highest-pressure forward segment.
|
||||
computeSlotSegCoords(forwardSegs[0], seriesBackwardPressure + 1, seriesBackwardCoord);
|
||||
seg.forwardCoord = forwardSegs[0].backwardCoord;
|
||||
}
|
||||
|
||||
// calculate the backwardCoord from the forwardCoord. consider the series
|
||||
seg.backwardCoord = seg.forwardCoord -
|
||||
(seg.forwardCoord - seriesBackwardCoord) / // available width for series
|
||||
(seriesBackwardPressure + 1); // # of segments in the series
|
||||
|
||||
// use this segment's coordinates to computed the coordinates of the less-pressurized
|
||||
// forward segments
|
||||
for (i=0; i<forwardSegs.length; i++) {
|
||||
computeSlotSegCoords(forwardSegs[i], 0, seg.forwardCoord);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Find all the segments in `otherSegs` that vertically collide with `seg`.
|
||||
// Append into an optionally-supplied `results` array and return.
|
||||
function computeSlotSegCollisions(seg, otherSegs, results) {
|
||||
results = results || [];
|
||||
|
||||
for (var i=0; i<otherSegs.length; i++) {
|
||||
if (isSlotSegCollision(seg, otherSegs[i])) {
|
||||
results.push(otherSegs[i]);
|
||||
}
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
|
||||
// Do these segments occupy the same vertical space?
|
||||
function isSlotSegCollision(seg1, seg2) {
|
||||
return seg1.bottom > seg2.top && seg1.top < seg2.bottom;
|
||||
}
|
||||
|
||||
|
||||
// A cmp function for determining which forward segment to rely on more when computing coordinates.
|
||||
function compareForwardSlotSegs(seg1, seg2) {
|
||||
// put higher-pressure first
|
||||
return seg2.forwardPressure - seg1.forwardPressure ||
|
||||
// put segments that are closer to initial edge first (and favor ones with no coords yet)
|
||||
(seg1.backwardCoord || 0) - (seg2.backwardCoord || 0) ||
|
||||
// do normal sorting...
|
||||
compareSegs(seg1, seg2);
|
||||
}
|
||||
@@ -0,0 +1,461 @@
|
||||
|
||||
/* A component that renders one or more columns of vertical time slots
|
||||
----------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
function TimeGrid(view) {
|
||||
Grid.call(this, view); // call the super-constructor
|
||||
}
|
||||
|
||||
|
||||
TimeGrid.prototype = createObject(Grid.prototype); // define the super-class
|
||||
$.extend(TimeGrid.prototype, {
|
||||
|
||||
slotDuration: null, // duration of a "slot", a distinct time segment on given day, visualized by lines
|
||||
snapDuration: null, // granularity of time for dragging and selecting
|
||||
|
||||
minTime: null, // Duration object that denotes the first visible time of any given day
|
||||
maxTime: null, // Duration object that denotes the exclusive visible end time of any given day
|
||||
|
||||
dayEls: null, // cells elements in the day-row background
|
||||
slatEls: null, // elements running horizontally across all columns
|
||||
|
||||
slatTops: null, // an array of top positions, relative to the container. last item holds bottom of last slot
|
||||
|
||||
highlightEl: null, // cell skeleton element for rendering the highlight
|
||||
helperEl: null, // cell skeleton element for rendering the mock event "helper"
|
||||
|
||||
|
||||
// Renders the time grid into `this.el`, which should already be assigned.
|
||||
// Relies on the view's colCnt. In the future, this component should probably be self-sufficient.
|
||||
render: function() {
|
||||
this.processOptions();
|
||||
|
||||
this.el.html(this.renderHtml());
|
||||
|
||||
this.dayEls = this.el.find('.fc-day');
|
||||
this.slatEls = this.el.find('.fc-slats tr');
|
||||
|
||||
this.computeSlatTops();
|
||||
|
||||
Grid.prototype.render.call(this); // call the super-method
|
||||
},
|
||||
|
||||
|
||||
// Renders the basic HTML skeleton for the grid
|
||||
renderHtml: function() {
|
||||
return '' +
|
||||
'<div class="fc-bg">' +
|
||||
'<table>' +
|
||||
this.rowHtml('slotBg') + // leverages RowRenderer, which will call slotBgCellHtml
|
||||
'</table>' +
|
||||
'</div>' +
|
||||
'<div class="fc-slats">' +
|
||||
'<table>' +
|
||||
this.slatRowHtml() +
|
||||
'</table>' +
|
||||
'</div>';
|
||||
},
|
||||
|
||||
|
||||
// Renders the HTML for a vertical background cell behind the slots.
|
||||
// This method is distinct from 'bg' because we wanted a new `rowType` so the View could customize the rendering.
|
||||
slotBgCellHtml: function(row, col, date) {
|
||||
return this.bgCellHtml(row, col, date);
|
||||
},
|
||||
|
||||
|
||||
// Generates the HTML for the horizontal "slats" that run width-wise. Has a time axis on a side. Depends on RTL.
|
||||
slatRowHtml: function() {
|
||||
var view = this.view;
|
||||
var calendar = view.calendar;
|
||||
var isRTL = view.opt('isRTL');
|
||||
var html = '';
|
||||
var slotNormal = this.slotDuration.asMinutes() % 15 === 0;
|
||||
var slotTime = moment.duration(+this.minTime); // wish there was .clone() for durations
|
||||
var slotDate; // will be on the view's first day, but we only care about its time
|
||||
var minutes;
|
||||
var axisHtml;
|
||||
|
||||
// Calculate the time for each slot
|
||||
while (slotTime < this.maxTime) {
|
||||
slotDate = view.start.clone().time(slotTime); // will be in UTC but that's good. to avoid DST issues
|
||||
minutes = slotDate.minutes();
|
||||
|
||||
axisHtml =
|
||||
'<td class="fc-axis fc-time ' + view.widgetContentClass + '" ' + view.axisStyleAttr() + '>' +
|
||||
((!slotNormal || !minutes) ? // if irregular slot duration, or on the hour, then display the time
|
||||
'<span>' + // for matchCellWidths
|
||||
htmlEscape(calendar.formatDate(slotDate, view.opt('axisFormat'))) +
|
||||
'</span>' :
|
||||
''
|
||||
) +
|
||||
'</td>';
|
||||
|
||||
html +=
|
||||
'<tr ' + (!minutes ? '' : 'class="fc-minor"') + '>' +
|
||||
(!isRTL ? axisHtml : '') +
|
||||
'<td class="' + view.widgetContentClass + '"/>' +
|
||||
(isRTL ? axisHtml : '') +
|
||||
"</tr>";
|
||||
|
||||
slotTime.add(this.slotDuration);
|
||||
}
|
||||
|
||||
return html;
|
||||
},
|
||||
|
||||
|
||||
// Parses various options into properties of this object
|
||||
processOptions: function() {
|
||||
var view = this.view;
|
||||
var slotDuration = view.opt('slotDuration');
|
||||
var snapDuration = view.opt('snapDuration');
|
||||
|
||||
slotDuration = moment.duration(slotDuration);
|
||||
snapDuration = snapDuration ? moment.duration(snapDuration) : slotDuration;
|
||||
|
||||
this.slotDuration = slotDuration;
|
||||
this.snapDuration = snapDuration;
|
||||
this.cellDuration = snapDuration; // important to assign this for Grid.events.js
|
||||
|
||||
this.minTime = moment.duration(view.opt('minTime'));
|
||||
this.maxTime = moment.duration(view.opt('maxTime'));
|
||||
},
|
||||
|
||||
|
||||
// Slices up a date range into a segment for each column
|
||||
rangeToSegs: function(rangeStart, rangeEnd) {
|
||||
var view = this.view;
|
||||
var segs = [];
|
||||
var seg;
|
||||
var col;
|
||||
var cellDate;
|
||||
var colStart, colEnd;
|
||||
|
||||
// normalize
|
||||
rangeStart = rangeStart.clone().stripZone();
|
||||
rangeEnd = rangeEnd.clone().stripZone();
|
||||
|
||||
for (col = 0; col < view.colCnt; col++) {
|
||||
cellDate = view.cellToDate(0, col); // use the View's cell system for this
|
||||
colStart = cellDate.clone().time(this.minTime);
|
||||
colEnd = cellDate.clone().time(this.maxTime);
|
||||
seg = intersectionToSeg(rangeStart, rangeEnd, colStart, colEnd);
|
||||
if (seg) {
|
||||
seg.col = col;
|
||||
segs.push(seg);
|
||||
}
|
||||
}
|
||||
|
||||
return segs;
|
||||
},
|
||||
|
||||
|
||||
/* Coordinates
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Called when there is a window resize/zoom and we need to recalculate coordinates for the grid
|
||||
resize: function() {
|
||||
this.computeSlatTops();
|
||||
this.updateSegVerticals();
|
||||
},
|
||||
|
||||
|
||||
// Populates the given empty `rows` and `cols` arrays with offset positions of the "snap" cells.
|
||||
// "Snap" cells are different the slots because they might have finer granularity.
|
||||
buildCoords: function(rows, cols) {
|
||||
var colCnt = this.view.colCnt;
|
||||
var originTop = this.el.offset().top;
|
||||
var snapTime = moment.duration(+this.minTime);
|
||||
var p = null;
|
||||
var e, n;
|
||||
|
||||
this.dayEls.slice(0, colCnt).each(function(i, _e) {
|
||||
e = $(_e);
|
||||
n = e.offset().left;
|
||||
if (p) {
|
||||
p[1] = n;
|
||||
}
|
||||
p = [ n ];
|
||||
cols[i] = p;
|
||||
});
|
||||
p[1] = n + e.outerWidth();
|
||||
|
||||
p = null;
|
||||
while (snapTime < this.maxTime) {
|
||||
n = originTop + this.computeTimeTop(snapTime);
|
||||
if (p) {
|
||||
p[1] = n;
|
||||
}
|
||||
p = [ n ];
|
||||
rows.push(p);
|
||||
snapTime.add(this.snapDuration);
|
||||
}
|
||||
p[1] = originTop + this.computeTimeTop(snapTime); // the position of the exclusive end
|
||||
},
|
||||
|
||||
|
||||
// Gets the datetime for the given slot cell
|
||||
getCellDate: function(cell) {
|
||||
var view = this.view;
|
||||
var calendar = view.calendar;
|
||||
|
||||
return calendar.rezoneDate( // since we are adding a time, it needs to be in the calendar's timezone
|
||||
view.cellToDate(0, cell.col) // View's coord system only accounts for start-of-day for column
|
||||
.time(this.minTime + this.snapDuration * cell.row)
|
||||
);
|
||||
},
|
||||
|
||||
|
||||
// Gets the element that represents the whole-day the cell resides on
|
||||
getCellDayEl: function(cell) {
|
||||
return this.dayEls.eq(cell.col);
|
||||
},
|
||||
|
||||
|
||||
// Computes the top coordinate, relative to the bounds of the grid, of the given date.
|
||||
// A `startOfDayDate` must be given for avoiding ambiguity over how to treat midnight.
|
||||
computeDateTop: function(date, startOfDayDate) {
|
||||
return this.computeTimeTop(
|
||||
moment.duration(
|
||||
date.clone().stripZone() - startOfDayDate.clone().stripTime()
|
||||
)
|
||||
);
|
||||
},
|
||||
|
||||
|
||||
// Computes the top coordinate, relative to the bounds of the grid, of the given time (a Duration).
|
||||
computeTimeTop: function(time) {
|
||||
var slatCoverage = (time - this.minTime) / this.slotDuration; // floating-point value of # of slots covered
|
||||
var slatIndex;
|
||||
var slatRemainder;
|
||||
var slatTop;
|
||||
var slatBottom;
|
||||
|
||||
// constrain. because minTime/maxTime might be customized
|
||||
slatCoverage = Math.max(0, slatCoverage);
|
||||
slatCoverage = Math.min(this.slatEls.length, slatCoverage);
|
||||
|
||||
slatIndex = Math.floor(slatCoverage); // an integer index of the furthest whole slot
|
||||
slatRemainder = slatCoverage - slatIndex;
|
||||
slatTop = this.slatTops[slatIndex]; // the top position of the furthest whole slot
|
||||
|
||||
if (slatRemainder) { // time spans part-way into the slot
|
||||
slatBottom = this.slatTops[slatIndex + 1];
|
||||
return slatTop + (slatBottom - slatTop) * slatRemainder; // part-way between slots
|
||||
}
|
||||
else {
|
||||
return slatTop;
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Queries each `slatEl` for its position relative to the grid's container and stores it in `slatTops`.
|
||||
// Includes the the bottom of the last slat as the last item in the array.
|
||||
computeSlatTops: function() {
|
||||
var tops = [];
|
||||
var top;
|
||||
|
||||
this.slatEls.each(function(i, node) {
|
||||
top = $(node).position().top;
|
||||
tops.push(top);
|
||||
});
|
||||
|
||||
tops.push(top + this.slatEls.last().outerHeight()); // bottom of the last slat
|
||||
|
||||
this.slatTops = tops;
|
||||
},
|
||||
|
||||
|
||||
/* Event Drag Visualization
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Renders a visual indication of an event being dragged over the specified date(s).
|
||||
// `end` and `seg` can be null. See View's documentation on renderDrag for more info.
|
||||
renderDrag: function(start, end, seg) {
|
||||
var opacity;
|
||||
|
||||
if (seg) { // if there is event information for this drag, render a helper event
|
||||
this.renderRangeHelper(start, end, seg);
|
||||
|
||||
opacity = this.view.opt('dragOpacity');
|
||||
if (opacity !== undefined) {
|
||||
this.helperEl.css('opacity', opacity);
|
||||
}
|
||||
|
||||
return true; // signal that a helper has been rendered
|
||||
}
|
||||
else {
|
||||
// otherwise, just render a highlight
|
||||
this.renderHighlight(
|
||||
start,
|
||||
end || this.view.calendar.getDefaultEventEnd(false, start)
|
||||
);
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Unrenders any visual indication of an event being dragged
|
||||
destroyDrag: function() {
|
||||
this.destroyHelper();
|
||||
this.destroyHighlight();
|
||||
},
|
||||
|
||||
|
||||
/* Event Resize Visualization
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Renders a visual indication of an event being resized
|
||||
renderResize: function(start, end, seg) {
|
||||
this.renderRangeHelper(start, end, seg);
|
||||
},
|
||||
|
||||
|
||||
// Unrenders any visual indication of an event being resized
|
||||
destroyResize: function() {
|
||||
this.destroyHelper();
|
||||
},
|
||||
|
||||
|
||||
/* Event Helper
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Renders a mock "helper" event. `sourceSeg` is the original segment object and might be null (an external drag)
|
||||
renderHelper: function(event, sourceSeg) {
|
||||
var res = this.renderEventTable([ event ]);
|
||||
var tableEl = res.tableEl;
|
||||
var segs = res.segs;
|
||||
var i, seg;
|
||||
var sourceEl;
|
||||
|
||||
// Try to make the segment that is in the same row as sourceSeg look the same
|
||||
for (i = 0; i < segs.length; i++) {
|
||||
seg = segs[i];
|
||||
if (sourceSeg && sourceSeg.col === seg.col) {
|
||||
sourceEl = sourceSeg.el;
|
||||
seg.el.css({
|
||||
left: sourceEl.css('left'),
|
||||
right: sourceEl.css('right'),
|
||||
'margin-left': sourceEl.css('margin-left'),
|
||||
'margin-right': sourceEl.css('margin-right')
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
this.helperEl = $('<div class="fc-helper-skeleton"/>')
|
||||
.append(tableEl)
|
||||
.appendTo(this.el);
|
||||
},
|
||||
|
||||
|
||||
// Unrenders any mock helper event
|
||||
destroyHelper: function() {
|
||||
if (this.helperEl) {
|
||||
this.helperEl.remove();
|
||||
this.helperEl = null;
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
/* Selection
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Renders a visual indication of a selection. Overrides the default, which was to simply render a highlight.
|
||||
renderSelection: function(start, end) {
|
||||
if (this.view.opt('selectHelper')) { // this setting signals that a mock helper event should be rendered
|
||||
this.renderRangeHelper(start, end);
|
||||
}
|
||||
else {
|
||||
this.renderHighlight(start, end);
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Unrenders any visual indication of a selection
|
||||
destroySelection: function() {
|
||||
this.destroyHelper();
|
||||
this.destroyHighlight();
|
||||
},
|
||||
|
||||
|
||||
/* Highlight
|
||||
------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// Renders an emphasis on the given date range. `start` is inclusive. `end` is exclusive.
|
||||
renderHighlight: function(start, end) {
|
||||
this.highlightEl = $(
|
||||
this.highlightSkeletonHtml(start, end)
|
||||
).appendTo(this.el);
|
||||
},
|
||||
|
||||
|
||||
// Unrenders the emphasis on a date range
|
||||
destroyHighlight: function() {
|
||||
if (this.highlightEl) {
|
||||
this.highlightEl.remove();
|
||||
this.highlightEl = null;
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
// Generates HTML for a table element with containers in each column, responsible for absolutely positioning the
|
||||
// highlight elements to cover the highlighted slots.
|
||||
highlightSkeletonHtml: function(start, end) {
|
||||
var view = this.view;
|
||||
var segs = this.rangeToSegs(start, end);
|
||||
var cellHtml = '';
|
||||
var col = 0;
|
||||
var i, seg;
|
||||
var dayDate;
|
||||
var top, bottom;
|
||||
|
||||
for (i = 0; i < segs.length; i++) { // loop through the segments. one per column
|
||||
seg = segs[i];
|
||||
|
||||
// need empty cells beforehand?
|
||||
if (col < seg.col) {
|
||||
cellHtml += '<td colspan="' + (seg.col - col) + '"/>';
|
||||
col = seg.col;
|
||||
}
|
||||
|
||||
// compute vertical position
|
||||
dayDate = view.cellToDate(0, col);
|
||||
top = this.computeDateTop(seg.start, dayDate);
|
||||
bottom = this.computeDateTop(seg.end, dayDate); // the y position of the bottom edge
|
||||
|
||||
// generate the cell HTML. bottom becomes negative because it needs to be a CSS value relative to the
|
||||
// bottom edge of the zero-height container.
|
||||
cellHtml +=
|
||||
'<td>' +
|
||||
'<div class="fc-highlight-container">' +
|
||||
'<div class="fc-highlight" style="top:' + top + 'px;bottom:-' + bottom + 'px"/>' +
|
||||
'</div>' +
|
||||
'</td>';
|
||||
|
||||
col++;
|
||||
}
|
||||
|
||||
// need empty cells after the last segment?
|
||||
if (col < view.colCnt) {
|
||||
cellHtml += '<td colspan="' + (view.colCnt - col) + '"/>';
|
||||
}
|
||||
|
||||
cellHtml = this.bookendCells(cellHtml, 'highlight');
|
||||
|
||||
return '' +
|
||||
'<div class="fc-highlight-skeleton">' +
|
||||
'<table>' +
|
||||
'<tr>' +
|
||||
cellHtml +
|
||||
'</tr>' +
|
||||
'</table>' +
|
||||
'</div>';
|
||||
}
|
||||
|
||||
});
|
||||
Reference in New Issue
Block a user