1 | /*!
|
---|
2 | * FullCalendar v1.6.4
|
---|
3 | * Docs & License: http://arshaw.com/fullcalendar/
|
---|
4 | * (c) 2013 Adam Shaw
|
---|
5 | */
|
---|
6 |
|
---|
7 | /*
|
---|
8 | * Use fullcalendar.css for basic styling.
|
---|
9 | * For event drag & drop, requires jQuery UI draggable.
|
---|
10 | * For event resizing, requires jQuery UI resizable.
|
---|
11 | */
|
---|
12 |
|
---|
13 | (function($, undefined) {
|
---|
14 |
|
---|
15 |
|
---|
16 | ;;
|
---|
17 |
|
---|
18 | var defaults = {
|
---|
19 |
|
---|
20 | // display
|
---|
21 | defaultView: 'month',
|
---|
22 | aspectRatio: 1.35,
|
---|
23 | header: {
|
---|
24 | left: 'title',
|
---|
25 | center: '',
|
---|
26 | right: 'today prev,next'
|
---|
27 | },
|
---|
28 | weekends: true,
|
---|
29 | weekNumbers: false,
|
---|
30 | weekNumberCalculation: 'iso',
|
---|
31 | weekNumberTitle: 'W',
|
---|
32 |
|
---|
33 | // editing
|
---|
34 | //editable: false,
|
---|
35 | //disableDragging: false,
|
---|
36 | //disableResizing: false,
|
---|
37 |
|
---|
38 | allDayDefault: true,
|
---|
39 | ignoreTimezone: true,
|
---|
40 |
|
---|
41 | // event ajax
|
---|
42 | lazyFetching: true,
|
---|
43 | startParam: 'start',
|
---|
44 | endParam: 'end',
|
---|
45 |
|
---|
46 | // time formats
|
---|
47 | titleFormat: {
|
---|
48 | month: 'MMMM yyyy',
|
---|
49 | week: "MMM d[ yyyy]{ '—'[ MMM] d yyyy}",
|
---|
50 | day: 'dddd, MMM d, yyyy'
|
---|
51 | },
|
---|
52 | columnFormat: {
|
---|
53 | month: 'ddd',
|
---|
54 | week: 'ddd M/d',
|
---|
55 | day: 'dddd M/d'
|
---|
56 | },
|
---|
57 | timeFormat: { // for event elements
|
---|
58 | '': 'h(:mm)t' // default
|
---|
59 | },
|
---|
60 |
|
---|
61 | // locale
|
---|
62 | isRTL: false,
|
---|
63 | firstDay: 0,
|
---|
64 | monthNames: ['January','February','March','April','May','June','July','August','September','October','November','December'],
|
---|
65 | monthNamesShort: ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'],
|
---|
66 | dayNames: ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'],
|
---|
67 | dayNamesShort: ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'],
|
---|
68 | buttonText: {
|
---|
69 | prev: "<span class='fc-text-arrow'>‹</span>",
|
---|
70 | next: "<span class='fc-text-arrow'>›</span>",
|
---|
71 | prevYear: "<span class='fc-text-arrow'>«</span>",
|
---|
72 | nextYear: "<span class='fc-text-arrow'>»</span>",
|
---|
73 | today: 'today',
|
---|
74 | month: 'month',
|
---|
75 | week: 'week',
|
---|
76 | day: 'day'
|
---|
77 | },
|
---|
78 |
|
---|
79 | // jquery-ui theming
|
---|
80 | theme: false,
|
---|
81 | buttonIcons: {
|
---|
82 | prev: 'circle-triangle-w',
|
---|
83 | next: 'circle-triangle-e'
|
---|
84 | },
|
---|
85 |
|
---|
86 | //selectable: false,
|
---|
87 | unselectAuto: true,
|
---|
88 |
|
---|
89 | dropAccept: '*',
|
---|
90 |
|
---|
91 | handleWindowResize: true
|
---|
92 |
|
---|
93 | };
|
---|
94 |
|
---|
95 | // right-to-left defaults
|
---|
96 | var rtlDefaults = {
|
---|
97 | header: {
|
---|
98 | left: 'next,prev today',
|
---|
99 | center: '',
|
---|
100 | right: 'title'
|
---|
101 | },
|
---|
102 | buttonText: {
|
---|
103 | prev: "<span class='fc-text-arrow'>›</span>",
|
---|
104 | next: "<span class='fc-text-arrow'>‹</span>",
|
---|
105 | prevYear: "<span class='fc-text-arrow'>»</span>",
|
---|
106 | nextYear: "<span class='fc-text-arrow'>«</span>"
|
---|
107 | },
|
---|
108 | buttonIcons: {
|
---|
109 | prev: 'circle-triangle-e',
|
---|
110 | next: 'circle-triangle-w'
|
---|
111 | }
|
---|
112 | };
|
---|
113 |
|
---|
114 |
|
---|
115 |
|
---|
116 | ;;
|
---|
117 |
|
---|
118 | var fc = $.fullCalendar = { version: "1.6.4" };
|
---|
119 | var fcViews = fc.views = {};
|
---|
120 |
|
---|
121 |
|
---|
122 | $.fn.fullCalendar = function(options) {
|
---|
123 |
|
---|
124 |
|
---|
125 | // method calling
|
---|
126 | if (typeof options == 'string') {
|
---|
127 | var args = Array.prototype.slice.call(arguments, 1);
|
---|
128 | var res;
|
---|
129 | this.each(function() {
|
---|
130 | var calendar = $.data(this, 'fullCalendar');
|
---|
131 | if (calendar && $.isFunction(calendar[options])) {
|
---|
132 | var r = calendar[options].apply(calendar, args);
|
---|
133 | if (res === undefined) {
|
---|
134 | res = r;
|
---|
135 | }
|
---|
136 | if (options == 'destroy') {
|
---|
137 | $.removeData(this, 'fullCalendar');
|
---|
138 | }
|
---|
139 | }
|
---|
140 | });
|
---|
141 | if (res !== undefined) {
|
---|
142 | return res;
|
---|
143 | }
|
---|
144 | return this;
|
---|
145 | }
|
---|
146 |
|
---|
147 | options = options || {};
|
---|
148 |
|
---|
149 | // would like to have this logic in EventManager, but needs to happen before options are recursively extended
|
---|
150 | var eventSources = options.eventSources || [];
|
---|
151 | delete options.eventSources;
|
---|
152 | if (options.events) {
|
---|
153 | eventSources.push(options.events);
|
---|
154 | delete options.events;
|
---|
155 | }
|
---|
156 |
|
---|
157 |
|
---|
158 | options = $.extend(true, {},
|
---|
159 | defaults,
|
---|
160 | (options.isRTL || options.isRTL===undefined && defaults.isRTL) ? rtlDefaults : {},
|
---|
161 | options
|
---|
162 | );
|
---|
163 |
|
---|
164 |
|
---|
165 | this.each(function(i, _element) {
|
---|
166 | var element = $(_element);
|
---|
167 | var calendar = new Calendar(element, options, eventSources);
|
---|
168 | element.data('fullCalendar', calendar); // TODO: look into memory leak implications
|
---|
169 | calendar.render();
|
---|
170 | });
|
---|
171 |
|
---|
172 |
|
---|
173 | return this;
|
---|
174 |
|
---|
175 | };
|
---|
176 |
|
---|
177 |
|
---|
178 | // function for adding/overriding defaults
|
---|
179 | function setDefaults(d) {
|
---|
180 | $.extend(true, defaults, d);
|
---|
181 | }
|
---|
182 |
|
---|
183 |
|
---|
184 |
|
---|
185 | ;;
|
---|
186 |
|
---|
187 |
|
---|
188 | function Calendar(element, options, eventSources) {
|
---|
189 | var t = this;
|
---|
190 |
|
---|
191 |
|
---|
192 | // exports
|
---|
193 | t.options = options;
|
---|
194 | t.render = render;
|
---|
195 | t.destroy = destroy;
|
---|
196 | t.refetchEvents = refetchEvents;
|
---|
197 | t.reportEvents = reportEvents;
|
---|
198 | t.reportEventChange = reportEventChange;
|
---|
199 | t.rerenderEvents = rerenderEvents;
|
---|
200 | t.changeView = changeView;
|
---|
201 | t.select = select;
|
---|
202 | t.unselect = unselect;
|
---|
203 | t.prev = prev;
|
---|
204 | t.next = next;
|
---|
205 | t.prevYear = prevYear;
|
---|
206 | t.nextYear = nextYear;
|
---|
207 | t.today = today;
|
---|
208 | t.gotoDate = gotoDate;
|
---|
209 | t.incrementDate = incrementDate;
|
---|
210 | t.formatDate = function(format, date) { return formatDate(format, date, options) };
|
---|
211 | t.formatDates = function(format, date1, date2) { return formatDates(format, date1, date2, options) };
|
---|
212 | t.getDate = getDate;
|
---|
213 | t.getView = getView;
|
---|
214 | t.option = option;
|
---|
215 | t.trigger = trigger;
|
---|
216 |
|
---|
217 |
|
---|
218 | // imports
|
---|
219 | EventManager.call(t, options, eventSources);
|
---|
220 | var isFetchNeeded = t.isFetchNeeded;
|
---|
221 | var fetchEvents = t.fetchEvents;
|
---|
222 |
|
---|
223 |
|
---|
224 | // locals
|
---|
225 | var _element = element[0];
|
---|
226 | var header;
|
---|
227 | var headerElement;
|
---|
228 | var content;
|
---|
229 | var tm; // for making theme classes
|
---|
230 | var currentView;
|
---|
231 | var elementOuterWidth;
|
---|
232 | var suggestedViewHeight;
|
---|
233 | var resizeUID = 0;
|
---|
234 | var ignoreWindowResize = 0;
|
---|
235 | var date = new Date();
|
---|
236 | var events = [];
|
---|
237 | var _dragElement;
|
---|
238 |
|
---|
239 |
|
---|
240 |
|
---|
241 | /* Main Rendering
|
---|
242 | -----------------------------------------------------------------------------*/
|
---|
243 |
|
---|
244 |
|
---|
245 | setYMD(date, options.year, options.month, options.date);
|
---|
246 |
|
---|
247 |
|
---|
248 | function render(inc) {
|
---|
249 | if (!content) {
|
---|
250 | initialRender();
|
---|
251 | }
|
---|
252 | else if (elementVisible()) {
|
---|
253 | // mainly for the public API
|
---|
254 | calcSize();
|
---|
255 | _renderView(inc);
|
---|
256 | }
|
---|
257 | }
|
---|
258 |
|
---|
259 |
|
---|
260 | function initialRender() {
|
---|
261 | tm = options.theme ? 'ui' : 'fc';
|
---|
262 | element.addClass('fc');
|
---|
263 | if (options.isRTL) {
|
---|
264 | element.addClass('fc-rtl');
|
---|
265 | }
|
---|
266 | else {
|
---|
267 | element.addClass('fc-ltr');
|
---|
268 | }
|
---|
269 | if (options.theme) {
|
---|
270 | element.addClass('ui-widget');
|
---|
271 | }
|
---|
272 |
|
---|
273 | content = $("<div class='fc-content' style='position:relative'/>")
|
---|
274 | .prependTo(element);
|
---|
275 |
|
---|
276 | header = new Header(t, options);
|
---|
277 | headerElement = header.render();
|
---|
278 | if (headerElement) {
|
---|
279 | element.prepend(headerElement);
|
---|
280 | }
|
---|
281 |
|
---|
282 | changeView(options.defaultView);
|
---|
283 |
|
---|
284 | if (options.handleWindowResize) {
|
---|
285 | $(window).resize(windowResize);
|
---|
286 | }
|
---|
287 |
|
---|
288 | // needed for IE in a 0x0 iframe, b/c when it is resized, never triggers a windowResize
|
---|
289 | if (!bodyVisible()) {
|
---|
290 | lateRender();
|
---|
291 | }
|
---|
292 | }
|
---|
293 |
|
---|
294 |
|
---|
295 | // called when we know the calendar couldn't be rendered when it was initialized,
|
---|
296 | // but we think it's ready now
|
---|
297 | function lateRender() {
|
---|
298 | setTimeout(function() { // IE7 needs this so dimensions are calculated correctly
|
---|
299 | if (!currentView.start && bodyVisible()) { // !currentView.start makes sure this never happens more than once
|
---|
300 | renderView();
|
---|
301 | }
|
---|
302 | },0);
|
---|
303 | }
|
---|
304 |
|
---|
305 |
|
---|
306 | function destroy() {
|
---|
307 |
|
---|
308 | if (currentView) {
|
---|
309 | trigger('viewDestroy', currentView, currentView, currentView.element);
|
---|
310 | currentView.triggerEventDestroy();
|
---|
311 | }
|
---|
312 |
|
---|
313 | $(window).unbind('resize', windowResize);
|
---|
314 |
|
---|
315 | header.destroy();
|
---|
316 | content.remove();
|
---|
317 | element.removeClass('fc fc-rtl ui-widget');
|
---|
318 | }
|
---|
319 |
|
---|
320 |
|
---|
321 | function elementVisible() {
|
---|
322 | return element.is(':visible');
|
---|
323 | }
|
---|
324 |
|
---|
325 |
|
---|
326 | function bodyVisible() {
|
---|
327 | return $('body').is(':visible');
|
---|
328 | }
|
---|
329 |
|
---|
330 |
|
---|
331 |
|
---|
332 | /* View Rendering
|
---|
333 | -----------------------------------------------------------------------------*/
|
---|
334 |
|
---|
335 |
|
---|
336 | function changeView(newViewName) {
|
---|
337 | if (!currentView || newViewName != currentView.name) {
|
---|
338 | _changeView(newViewName);
|
---|
339 | }
|
---|
340 | }
|
---|
341 |
|
---|
342 |
|
---|
343 | function _changeView(newViewName) {
|
---|
344 | ignoreWindowResize++;
|
---|
345 |
|
---|
346 | if (currentView) {
|
---|
347 | trigger('viewDestroy', currentView, currentView, currentView.element);
|
---|
348 | unselect();
|
---|
349 | currentView.triggerEventDestroy(); // trigger 'eventDestroy' for each event
|
---|
350 | freezeContentHeight();
|
---|
351 | currentView.element.remove();
|
---|
352 | header.deactivateButton(currentView.name);
|
---|
353 | }
|
---|
354 |
|
---|
355 | header.activateButton(newViewName);
|
---|
356 |
|
---|
357 | currentView = new fcViews[newViewName](
|
---|
358 | $("<div class='fc-view fc-view-" + newViewName + "' style='position:relative'/>")
|
---|
359 | .appendTo(content),
|
---|
360 | t // the calendar object
|
---|
361 | );
|
---|
362 |
|
---|
363 | renderView();
|
---|
364 | unfreezeContentHeight();
|
---|
365 |
|
---|
366 | ignoreWindowResize--;
|
---|
367 | }
|
---|
368 |
|
---|
369 |
|
---|
370 | function renderView(inc) {
|
---|
371 | if (
|
---|
372 | !currentView.start || // never rendered before
|
---|
373 | inc || date < currentView.start || date >= currentView.end // or new date range
|
---|
374 | ) {
|
---|
375 | if (elementVisible()) {
|
---|
376 | _renderView(inc);
|
---|
377 | }
|
---|
378 | }
|
---|
379 | }
|
---|
380 |
|
---|
381 |
|
---|
382 | function _renderView(inc) { // assumes elementVisible
|
---|
383 | ignoreWindowResize++;
|
---|
384 |
|
---|
385 | if (currentView.start) { // already been rendered?
|
---|
386 | trigger('viewDestroy', currentView, currentView, currentView.element);
|
---|
387 | unselect();
|
---|
388 | clearEvents();
|
---|
389 | }
|
---|
390 |
|
---|
391 | freezeContentHeight();
|
---|
392 | currentView.render(date, inc || 0); // the view's render method ONLY renders the skeleton, nothing else
|
---|
393 | setSize();
|
---|
394 | unfreezeContentHeight();
|
---|
395 | (currentView.afterRender || noop)();
|
---|
396 |
|
---|
397 | updateTitle();
|
---|
398 | updateTodayButton();
|
---|
399 |
|
---|
400 | trigger('viewRender', currentView, currentView, currentView.element);
|
---|
401 | currentView.trigger('viewDisplay', _element); // deprecated
|
---|
402 |
|
---|
403 | ignoreWindowResize--;
|
---|
404 |
|
---|
405 | getAndRenderEvents();
|
---|
406 | }
|
---|
407 |
|
---|
408 |
|
---|
409 |
|
---|
410 | /* Resizing
|
---|
411 | -----------------------------------------------------------------------------*/
|
---|
412 |
|
---|
413 |
|
---|
414 | function updateSize() {
|
---|
415 | if (elementVisible()) {
|
---|
416 | unselect();
|
---|
417 | clearEvents();
|
---|
418 | calcSize();
|
---|
419 | setSize();
|
---|
420 | renderEvents();
|
---|
421 | }
|
---|
422 | }
|
---|
423 |
|
---|
424 |
|
---|
425 | function calcSize() { // assumes elementVisible
|
---|
426 | if (options.contentHeight) {
|
---|
427 | suggestedViewHeight = options.contentHeight;
|
---|
428 | }
|
---|
429 | else if (options.height) {
|
---|
430 | suggestedViewHeight = options.height - (headerElement ? headerElement.height() : 0) - vsides(content);
|
---|
431 | }
|
---|
432 | else {
|
---|
433 | suggestedViewHeight = Math.round(content.width() / Math.max(options.aspectRatio, .5));
|
---|
434 | }
|
---|
435 | }
|
---|
436 |
|
---|
437 |
|
---|
438 | function setSize() { // assumes elementVisible
|
---|
439 |
|
---|
440 | if (suggestedViewHeight === undefined) {
|
---|
441 | calcSize(); // for first time
|
---|
442 | // NOTE: we don't want to recalculate on every renderView because
|
---|
443 | // it could result in oscillating heights due to scrollbars.
|
---|
444 | }
|
---|
445 |
|
---|
446 | ignoreWindowResize++;
|
---|
447 | currentView.setHeight(suggestedViewHeight);
|
---|
448 | currentView.setWidth(content.width());
|
---|
449 | ignoreWindowResize--;
|
---|
450 |
|
---|
451 | elementOuterWidth = element.outerWidth();
|
---|
452 | }
|
---|
453 |
|
---|
454 |
|
---|
455 | function windowResize() {
|
---|
456 | if (!ignoreWindowResize) {
|
---|
457 | if (currentView.start) { // view has already been rendered
|
---|
458 | var uid = ++resizeUID;
|
---|
459 | setTimeout(function() { // add a delay
|
---|
460 | if (uid == resizeUID && !ignoreWindowResize && elementVisible()) {
|
---|
461 | if (elementOuterWidth != (elementOuterWidth = element.outerWidth())) {
|
---|
462 | ignoreWindowResize++; // in case the windowResize callback changes the height
|
---|
463 | updateSize();
|
---|
464 | currentView.trigger('windowResize', _element);
|
---|
465 | ignoreWindowResize--;
|
---|
466 | }
|
---|
467 | }
|
---|
468 | }, 200);
|
---|
469 | }else{
|
---|
470 | // calendar must have been initialized in a 0x0 iframe that has just been resized
|
---|
471 | lateRender();
|
---|
472 | }
|
---|
473 | }
|
---|
474 | }
|
---|
475 |
|
---|
476 |
|
---|
477 |
|
---|
478 | /* Event Fetching/Rendering
|
---|
479 | -----------------------------------------------------------------------------*/
|
---|
480 | // TODO: going forward, most of this stuff should be directly handled by the view
|
---|
481 |
|
---|
482 |
|
---|
483 | function refetchEvents() { // can be called as an API method
|
---|
484 | clearEvents();
|
---|
485 | fetchAndRenderEvents();
|
---|
486 | }
|
---|
487 |
|
---|
488 |
|
---|
489 | function rerenderEvents(modifiedEventID) { // can be called as an API method
|
---|
490 | clearEvents();
|
---|
491 | renderEvents(modifiedEventID);
|
---|
492 | }
|
---|
493 |
|
---|
494 |
|
---|
495 | function renderEvents(modifiedEventID) { // TODO: remove modifiedEventID hack
|
---|
496 | if (elementVisible()) {
|
---|
497 | currentView.setEventData(events); // for View.js, TODO: unify with renderEvents
|
---|
498 | currentView.renderEvents(events, modifiedEventID); // actually render the DOM elements
|
---|
499 | currentView.trigger('eventAfterAllRender');
|
---|
500 | }
|
---|
501 | }
|
---|
502 |
|
---|
503 |
|
---|
504 | function clearEvents() {
|
---|
505 | currentView.triggerEventDestroy(); // trigger 'eventDestroy' for each event
|
---|
506 | currentView.clearEvents(); // actually remove the DOM elements
|
---|
507 | currentView.clearEventData(); // for View.js, TODO: unify with clearEvents
|
---|
508 | }
|
---|
509 |
|
---|
510 |
|
---|
511 | function getAndRenderEvents() {
|
---|
512 | if (!options.lazyFetching || isFetchNeeded(currentView.visStart, currentView.visEnd)) {
|
---|
513 | fetchAndRenderEvents();
|
---|
514 | }
|
---|
515 | else {
|
---|
516 | renderEvents();
|
---|
517 | }
|
---|
518 | }
|
---|
519 |
|
---|
520 |
|
---|
521 | function fetchAndRenderEvents() {
|
---|
522 | fetchEvents(currentView.visStart, currentView.visEnd);
|
---|
523 | // ... will call reportEvents
|
---|
524 | // ... which will call renderEvents
|
---|
525 | }
|
---|
526 |
|
---|
527 |
|
---|
528 | // called when event data arrives
|
---|
529 | function reportEvents(_events) {
|
---|
530 | events = _events;
|
---|
531 | renderEvents();
|
---|
532 | }
|
---|
533 |
|
---|
534 |
|
---|
535 | // called when a single event's data has been changed
|
---|
536 | function reportEventChange(eventID) {
|
---|
537 | rerenderEvents(eventID);
|
---|
538 | }
|
---|
539 |
|
---|
540 |
|
---|
541 |
|
---|
542 | /* Header Updating
|
---|
543 | -----------------------------------------------------------------------------*/
|
---|
544 |
|
---|
545 |
|
---|
546 | function updateTitle() {
|
---|
547 | header.updateTitle(currentView.title);
|
---|
548 | }
|
---|
549 |
|
---|
550 |
|
---|
551 | function updateTodayButton() {
|
---|
552 | var today = new Date();
|
---|
553 | if (today >= currentView.start && today < currentView.end) {
|
---|
554 | header.disableButton('today');
|
---|
555 | }
|
---|
556 | else {
|
---|
557 | header.enableButton('today');
|
---|
558 | }
|
---|
559 | }
|
---|
560 |
|
---|
561 |
|
---|
562 |
|
---|
563 | /* Selection
|
---|
564 | -----------------------------------------------------------------------------*/
|
---|
565 |
|
---|
566 |
|
---|
567 | function select(start, end, allDay) {
|
---|
568 | currentView.select(start, end, allDay===undefined ? true : allDay);
|
---|
569 | }
|
---|
570 |
|
---|
571 |
|
---|
572 | function unselect() { // safe to be called before renderView
|
---|
573 | if (currentView) {
|
---|
574 | currentView.unselect();
|
---|
575 | }
|
---|
576 | }
|
---|
577 |
|
---|
578 |
|
---|
579 |
|
---|
580 | /* Date
|
---|
581 | -----------------------------------------------------------------------------*/
|
---|
582 |
|
---|
583 |
|
---|
584 | function prev() {
|
---|
585 | renderView(-1);
|
---|
586 | }
|
---|
587 |
|
---|
588 |
|
---|
589 | function next() {
|
---|
590 | renderView(1);
|
---|
591 | }
|
---|
592 |
|
---|
593 |
|
---|
594 | function prevYear() {
|
---|
595 | addYears(date, -1);
|
---|
596 | renderView();
|
---|
597 | }
|
---|
598 |
|
---|
599 |
|
---|
600 | function nextYear() {
|
---|
601 | addYears(date, 1);
|
---|
602 | renderView();
|
---|
603 | }
|
---|
604 |
|
---|
605 |
|
---|
606 | function today() {
|
---|
607 | date = new Date();
|
---|
608 | renderView();
|
---|
609 | }
|
---|
610 |
|
---|
611 |
|
---|
612 | function gotoDate(year, month, dateOfMonth) {
|
---|
613 | if (year instanceof Date) {
|
---|
614 | date = cloneDate(year); // provided 1 argument, a Date
|
---|
615 | }else{
|
---|
616 | setYMD(date, year, month, dateOfMonth);
|
---|
617 | }
|
---|
618 | renderView();
|
---|
619 | }
|
---|
620 |
|
---|
621 |
|
---|
622 | function incrementDate(years, months, days) {
|
---|
623 | if (years !== undefined) {
|
---|
624 | addYears(date, years);
|
---|
625 | }
|
---|
626 | if (months !== undefined) {
|
---|
627 | addMonths(date, months);
|
---|
628 | }
|
---|
629 | if (days !== undefined) {
|
---|
630 | addDays(date, days);
|
---|
631 | }
|
---|
632 | renderView();
|
---|
633 | }
|
---|
634 |
|
---|
635 |
|
---|
636 | function getDate() {
|
---|
637 | return cloneDate(date);
|
---|
638 | }
|
---|
639 |
|
---|
640 |
|
---|
641 |
|
---|
642 | /* Height "Freezing"
|
---|
643 | -----------------------------------------------------------------------------*/
|
---|
644 |
|
---|
645 |
|
---|
646 | function freezeContentHeight() {
|
---|
647 | content.css({
|
---|
648 | width: '100%',
|
---|
649 | height: content.height(),
|
---|
650 | overflow: 'hidden'
|
---|
651 | });
|
---|
652 | }
|
---|
653 |
|
---|
654 |
|
---|
655 | function unfreezeContentHeight() {
|
---|
656 | content.css({
|
---|
657 | width: '',
|
---|
658 | height: '',
|
---|
659 | overflow: ''
|
---|
660 | });
|
---|
661 | }
|
---|
662 |
|
---|
663 |
|
---|
664 |
|
---|
665 | /* Misc
|
---|
666 | -----------------------------------------------------------------------------*/
|
---|
667 |
|
---|
668 |
|
---|
669 | function getView() {
|
---|
670 | return currentView;
|
---|
671 | }
|
---|
672 |
|
---|
673 |
|
---|
674 | function option(name, value) {
|
---|
675 | if (value === undefined) {
|
---|
676 | return options[name];
|
---|
677 | }
|
---|
678 | if (name == 'height' || name == 'contentHeight' || name == 'aspectRatio') {
|
---|
679 | options[name] = value;
|
---|
680 | updateSize();
|
---|
681 | }
|
---|
682 | }
|
---|
683 |
|
---|
684 |
|
---|
685 | function trigger(name, thisObj) {
|
---|
686 | if (options[name]) {
|
---|
687 | return options[name].apply(
|
---|
688 | thisObj || _element,
|
---|
689 | Array.prototype.slice.call(arguments, 2)
|
---|
690 | );
|
---|
691 | }
|
---|
692 | }
|
---|
693 |
|
---|
694 |
|
---|
695 |
|
---|
696 | /* External Dragging
|
---|
697 | ------------------------------------------------------------------------*/
|
---|
698 |
|
---|
699 | if (options.droppable) {
|
---|
700 | $(document)
|
---|
701 | .bind('dragstart', function(ev, ui) {
|
---|
702 | var _e = ev.target;
|
---|
703 | var e = $(_e);
|
---|
704 | if (!e.parents('.fc').length) { // not already inside a calendar
|
---|
705 | var accept = options.dropAccept;
|
---|
706 | if ($.isFunction(accept) ? accept.call(_e, e) : e.is(accept)) {
|
---|
707 | _dragElement = _e;
|
---|
708 | currentView.dragStart(_dragElement, ev, ui);
|
---|
709 | }
|
---|
710 | }
|
---|
711 | })
|
---|
712 | .bind('dragstop', function(ev, ui) {
|
---|
713 | if (_dragElement) {
|
---|
714 | currentView.dragStop(_dragElement, ev, ui);
|
---|
715 | _dragElement = null;
|
---|
716 | }
|
---|
717 | });
|
---|
718 | }
|
---|
719 |
|
---|
720 |
|
---|
721 | }
|
---|
722 |
|
---|
723 | ;;
|
---|
724 |
|
---|
725 | function Header(calendar, options) {
|
---|
726 | var t = this;
|
---|
727 |
|
---|
728 |
|
---|
729 | // exports
|
---|
730 | t.render = render;
|
---|
731 | t.destroy = destroy;
|
---|
732 | t.updateTitle = updateTitle;
|
---|
733 | t.activateButton = activateButton;
|
---|
734 | t.deactivateButton = deactivateButton;
|
---|
735 | t.disableButton = disableButton;
|
---|
736 | t.enableButton = enableButton;
|
---|
737 |
|
---|
738 |
|
---|
739 | // locals
|
---|
740 | var element = $([]);
|
---|
741 | var tm;
|
---|
742 |
|
---|
743 |
|
---|
744 |
|
---|
745 | function render() {
|
---|
746 | tm = options.theme ? 'ui' : 'fc';
|
---|
747 | var sections = options.header;
|
---|
748 | if (sections) {
|
---|
749 | element = $("<table class='fc-header' style='width:100%'/>")
|
---|
750 | .append(
|
---|
751 | $("<tr/>")
|
---|
752 | .append(renderSection('left'))
|
---|
753 | .append(renderSection('center'))
|
---|
754 | .append(renderSection('right'))
|
---|
755 | );
|
---|
756 | return element;
|
---|
757 | }
|
---|
758 | }
|
---|
759 |
|
---|
760 |
|
---|
761 | function destroy() {
|
---|
762 | element.remove();
|
---|
763 | }
|
---|
764 |
|
---|
765 |
|
---|
766 | function renderSection(position) {
|
---|
767 | var e = $("<td class='fc-header-" + position + "'/>");
|
---|
768 | var buttonStr = options.header[position];
|
---|
769 | if (buttonStr) {
|
---|
770 | $.each(buttonStr.split(' '), function(i) {
|
---|
771 | if (i > 0) {
|
---|
772 | e.append("<span class='fc-header-space'/>");
|
---|
773 | }
|
---|
774 | var prevButton;
|
---|
775 | $.each(this.split(','), function(j, buttonName) {
|
---|
776 | if (buttonName == 'title') {
|
---|
777 | e.append("<span class='fc-header-title'><h2> </h2></span>");
|
---|
778 | if (prevButton) {
|
---|
779 | prevButton.addClass(tm + '-corner-right');
|
---|
780 | }
|
---|
781 | prevButton = null;
|
---|
782 | }else{
|
---|
783 | var buttonClick;
|
---|
784 | if (calendar[buttonName]) {
|
---|
785 | buttonClick = calendar[buttonName]; // calendar method
|
---|
786 | }
|
---|
787 | else if (fcViews[buttonName]) {
|
---|
788 | buttonClick = function() {
|
---|
789 | button.removeClass(tm + '-state-hover'); // forget why
|
---|
790 | calendar.changeView(buttonName);
|
---|
791 | };
|
---|
792 | }
|
---|
793 | if (buttonClick) {
|
---|
794 | var icon = options.theme ? smartProperty(options.buttonIcons, buttonName) : null; // why are we using smartProperty here?
|
---|
795 | var text = smartProperty(options.buttonText, buttonName); // why are we using smartProperty here?
|
---|
796 | var button = $(
|
---|
797 | "<span class='fc-button fc-button-" + buttonName + " " + tm + "-state-default'>" +
|
---|
798 | (icon ?
|
---|
799 | "<span class='fc-icon-wrap'>" +
|
---|
800 | "<span class='ui-icon ui-icon-" + icon + "'/>" +
|
---|
801 | "</span>" :
|
---|
802 | text
|
---|
803 | ) +
|
---|
804 | "</span>"
|
---|
805 | )
|
---|
806 | .click(function() {
|
---|
807 | if (!button.hasClass(tm + '-state-disabled')) {
|
---|
808 | buttonClick();
|
---|
809 | }
|
---|
810 | })
|
---|
811 | .mousedown(function() {
|
---|
812 | button
|
---|
813 | .not('.' + tm + '-state-active')
|
---|
814 | .not('.' + tm + '-state-disabled')
|
---|
815 | .addClass(tm + '-state-down');
|
---|
816 | })
|
---|
817 | .mouseup(function() {
|
---|
818 | button.removeClass(tm + '-state-down');
|
---|
819 | })
|
---|
820 | .hover(
|
---|
821 | function() {
|
---|
822 | button
|
---|
823 | .not('.' + tm + '-state-active')
|
---|
824 | .not('.' + tm + '-state-disabled')
|
---|
825 | .addClass(tm + '-state-hover');
|
---|
826 | },
|
---|
827 | function() {
|
---|
828 | button
|
---|
829 | .removeClass(tm + '-state-hover')
|
---|
830 | .removeClass(tm + '-state-down');
|
---|
831 | }
|
---|
832 | )
|
---|
833 | .appendTo(e);
|
---|
834 | disableTextSelection(button);
|
---|
835 | if (!prevButton) {
|
---|
836 | button.addClass(tm + '-corner-left');
|
---|
837 | }
|
---|
838 | prevButton = button;
|
---|
839 | }
|
---|
840 | }
|
---|
841 | });
|
---|
842 | if (prevButton) {
|
---|
843 | prevButton.addClass(tm + '-corner-right');
|
---|
844 | }
|
---|
845 | });
|
---|
846 | }
|
---|
847 | return e;
|
---|
848 | }
|
---|
849 |
|
---|
850 |
|
---|
851 | function updateTitle(html) {
|
---|
852 | element.find('h2')
|
---|
853 | .html(html);
|
---|
854 | }
|
---|
855 |
|
---|
856 |
|
---|
857 | function activateButton(buttonName) {
|
---|
858 | element.find('span.fc-button-' + buttonName)
|
---|
859 | .addClass(tm + '-state-active');
|
---|
860 | }
|
---|
861 |
|
---|
862 |
|
---|
863 | function deactivateButton(buttonName) {
|
---|
864 | element.find('span.fc-button-' + buttonName)
|
---|
865 | .removeClass(tm + '-state-active');
|
---|
866 | }
|
---|
867 |
|
---|
868 |
|
---|
869 | function disableButton(buttonName) {
|
---|
870 | element.find('span.fc-button-' + buttonName)
|
---|
871 | .addClass(tm + '-state-disabled');
|
---|
872 | }
|
---|
873 |
|
---|
874 |
|
---|
875 | function enableButton(buttonName) {
|
---|
876 | element.find('span.fc-button-' + buttonName)
|
---|
877 | .removeClass(tm + '-state-disabled');
|
---|
878 | }
|
---|
879 |
|
---|
880 |
|
---|
881 | }
|
---|
882 |
|
---|
883 | ;;
|
---|
884 |
|
---|
885 | fc.sourceNormalizers = [];
|
---|
886 | fc.sourceFetchers = [];
|
---|
887 |
|
---|
888 | var ajaxDefaults = {
|
---|
889 | dataType: 'json',
|
---|
890 | cache: false
|
---|
891 | };
|
---|
892 |
|
---|
893 | var eventGUID = 1;
|
---|
894 |
|
---|
895 |
|
---|
896 | function EventManager(options, _sources) {
|
---|
897 | var t = this;
|
---|
898 |
|
---|
899 |
|
---|
900 | // exports
|
---|
901 | t.isFetchNeeded = isFetchNeeded;
|
---|
902 | t.fetchEvents = fetchEvents;
|
---|
903 | t.addEventSource = addEventSource;
|
---|
904 | t.removeEventSource = removeEventSource;
|
---|
905 | t.updateEvent = updateEvent;
|
---|
906 | t.renderEvent = renderEvent;
|
---|
907 | t.removeEvents = removeEvents;
|
---|
908 | t.clientEvents = clientEvents;
|
---|
909 | t.normalizeEvent = normalizeEvent;
|
---|
910 |
|
---|
911 |
|
---|
912 | // imports
|
---|
913 | var trigger = t.trigger;
|
---|
914 | var getView = t.getView;
|
---|
915 | var reportEvents = t.reportEvents;
|
---|
916 |
|
---|
917 |
|
---|
918 | // locals
|
---|
919 | var stickySource = { events: [] };
|
---|
920 | var sources = [ stickySource ];
|
---|
921 | var rangeStart, rangeEnd;
|
---|
922 | var currentFetchID = 0;
|
---|
923 | var pendingSourceCnt = 0;
|
---|
924 | var loadingLevel = 0;
|
---|
925 | var cache = [];
|
---|
926 |
|
---|
927 |
|
---|
928 | for (var i=0; i<_sources.length; i++) {
|
---|
929 | _addEventSource(_sources[i]);
|
---|
930 | }
|
---|
931 |
|
---|
932 |
|
---|
933 |
|
---|
934 | /* Fetching
|
---|
935 | -----------------------------------------------------------------------------*/
|
---|
936 |
|
---|
937 |
|
---|
938 | function isFetchNeeded(start, end) {
|
---|
939 | return !rangeStart || start < rangeStart || end > rangeEnd;
|
---|
940 | }
|
---|
941 |
|
---|
942 |
|
---|
943 | function fetchEvents(start, end) {
|
---|
944 | rangeStart = start;
|
---|
945 | rangeEnd = end;
|
---|
946 | cache = [];
|
---|
947 | var fetchID = ++currentFetchID;
|
---|
948 | var len = sources.length;
|
---|
949 | pendingSourceCnt = len;
|
---|
950 | for (var i=0; i<len; i++) {
|
---|
951 | fetchEventSource(sources[i], fetchID);
|
---|
952 | }
|
---|
953 | }
|
---|
954 |
|
---|
955 |
|
---|
956 | function fetchEventSource(source, fetchID) {
|
---|
957 | _fetchEventSource(source, function(events) {
|
---|
958 | if (fetchID == currentFetchID) {
|
---|
959 | if (events) {
|
---|
960 |
|
---|
961 | if (options.eventDataTransform) {
|
---|
962 | events = $.map(events, options.eventDataTransform);
|
---|
963 | }
|
---|
964 | if (source.eventDataTransform) {
|
---|
965 | events = $.map(events, source.eventDataTransform);
|
---|
966 | }
|
---|
967 | // TODO: this technique is not ideal for static array event sources.
|
---|
968 | // For arrays, we'll want to process all events right in the beginning, then never again.
|
---|
969 |
|
---|
970 | for (var i=0; i<events.length; i++) {
|
---|
971 | events[i].source = source;
|
---|
972 | normalizeEvent(events[i]);
|
---|
973 | }
|
---|
974 | cache = cache.concat(events);
|
---|
975 | }
|
---|
976 | pendingSourceCnt--;
|
---|
977 | if (!pendingSourceCnt) {
|
---|
978 | reportEvents(cache);
|
---|
979 | }
|
---|
980 | }
|
---|
981 | });
|
---|
982 | }
|
---|
983 |
|
---|
984 |
|
---|
985 | function _fetchEventSource(source, callback) {
|
---|
986 | var i;
|
---|
987 | var fetchers = fc.sourceFetchers;
|
---|
988 | var res;
|
---|
989 | for (i=0; i<fetchers.length; i++) {
|
---|
990 | res = fetchers[i](source, rangeStart, rangeEnd, callback);
|
---|
991 | if (res === true) {
|
---|
992 | // the fetcher is in charge. made its own async request
|
---|
993 | return;
|
---|
994 | }
|
---|
995 | else if (typeof res == 'object') {
|
---|
996 | // the fetcher returned a new source. process it
|
---|
997 | _fetchEventSource(res, callback);
|
---|
998 | return;
|
---|
999 | }
|
---|
1000 | }
|
---|
1001 | var events = source.events;
|
---|
1002 | if (events) {
|
---|
1003 | if ($.isFunction(events)) {
|
---|
1004 | pushLoading();
|
---|
1005 | events(cloneDate(rangeStart), cloneDate(rangeEnd), function(events) {
|
---|
1006 | callback(events);
|
---|
1007 | popLoading();
|
---|
1008 | });
|
---|
1009 | }
|
---|
1010 | else if ($.isArray(events)) {
|
---|
1011 | callback(events);
|
---|
1012 | }
|
---|
1013 | else {
|
---|
1014 | callback();
|
---|
1015 | }
|
---|
1016 | }else{
|
---|
1017 | var url = source.url;
|
---|
1018 | if (url) {
|
---|
1019 | var success = source.success;
|
---|
1020 | var error = source.error;
|
---|
1021 | var complete = source.complete;
|
---|
1022 |
|
---|
1023 | // retrieve any outbound GET/POST $.ajax data from the options
|
---|
1024 | var customData;
|
---|
1025 | if ($.isFunction(source.data)) {
|
---|
1026 | // supplied as a function that returns a key/value object
|
---|
1027 | customData = source.data();
|
---|
1028 | }
|
---|
1029 | else {
|
---|
1030 | // supplied as a straight key/value object
|
---|
1031 | customData = source.data;
|
---|
1032 | }
|
---|
1033 |
|
---|
1034 | // use a copy of the custom data so we can modify the parameters
|
---|
1035 | // and not affect the passed-in object.
|
---|
1036 | var data = $.extend({}, customData || {});
|
---|
1037 |
|
---|
1038 | var startParam = firstDefined(source.startParam, options.startParam);
|
---|
1039 | var endParam = firstDefined(source.endParam, options.endParam);
|
---|
1040 | if (startParam) {
|
---|
1041 | data[startParam] = Math.round(+rangeStart / 1000);
|
---|
1042 | }
|
---|
1043 | if (endParam) {
|
---|
1044 | data[endParam] = Math.round(+rangeEnd / 1000);
|
---|
1045 | }
|
---|
1046 |
|
---|
1047 | pushLoading();
|
---|
1048 | $.ajax($.extend({}, ajaxDefaults, source, {
|
---|
1049 | data: data,
|
---|
1050 | success: function(events) {
|
---|
1051 | events = events || [];
|
---|
1052 | var res = applyAll(success, this, arguments);
|
---|
1053 | if ($.isArray(res)) {
|
---|
1054 | events = res;
|
---|
1055 | }
|
---|
1056 | callback(events);
|
---|
1057 | },
|
---|
1058 | error: function() {
|
---|
1059 | applyAll(error, this, arguments);
|
---|
1060 | callback();
|
---|
1061 | },
|
---|
1062 | complete: function() {
|
---|
1063 | applyAll(complete, this, arguments);
|
---|
1064 | popLoading();
|
---|
1065 | }
|
---|
1066 | }));
|
---|
1067 | }else{
|
---|
1068 | callback();
|
---|
1069 | }
|
---|
1070 | }
|
---|
1071 | }
|
---|
1072 |
|
---|
1073 |
|
---|
1074 |
|
---|
1075 | /* Sources
|
---|
1076 | -----------------------------------------------------------------------------*/
|
---|
1077 |
|
---|
1078 |
|
---|
1079 | function addEventSource(source) {
|
---|
1080 | source = _addEventSource(source);
|
---|
1081 | if (source) {
|
---|
1082 | pendingSourceCnt++;
|
---|
1083 | fetchEventSource(source, currentFetchID); // will eventually call reportEvents
|
---|
1084 | }
|
---|
1085 | }
|
---|
1086 |
|
---|
1087 |
|
---|
1088 | function _addEventSource(source) {
|
---|
1089 | if ($.isFunction(source) || $.isArray(source)) {
|
---|
1090 | source = { events: source };
|
---|
1091 | }
|
---|
1092 | else if (typeof source == 'string') {
|
---|
1093 | source = { url: source };
|
---|
1094 | }
|
---|
1095 | if (typeof source == 'object') {
|
---|
1096 | normalizeSource(source);
|
---|
1097 | sources.push(source);
|
---|
1098 | return source;
|
---|
1099 | }
|
---|
1100 | }
|
---|
1101 |
|
---|
1102 |
|
---|
1103 | function removeEventSource(source) {
|
---|
1104 | sources = $.grep(sources, function(src) {
|
---|
1105 | return !isSourcesEqual(src, source);
|
---|
1106 | });
|
---|
1107 | // remove all client events from that source
|
---|
1108 | cache = $.grep(cache, function(e) {
|
---|
1109 | return !isSourcesEqual(e.source, source);
|
---|
1110 | });
|
---|
1111 | reportEvents(cache);
|
---|
1112 | }
|
---|
1113 |
|
---|
1114 |
|
---|
1115 |
|
---|
1116 | /* Manipulation
|
---|
1117 | -----------------------------------------------------------------------------*/
|
---|
1118 |
|
---|
1119 |
|
---|
1120 | function updateEvent(event) { // update an existing event
|
---|
1121 | var i, len = cache.length, e,
|
---|
1122 | defaultEventEnd = getView().defaultEventEnd, // getView???
|
---|
1123 | startDelta = event.start - event._start,
|
---|
1124 | endDelta = event.end ?
|
---|
1125 | (event.end - (event._end || defaultEventEnd(event))) // event._end would be null if event.end
|
---|
1126 | : 0; // was null and event was just resized
|
---|
1127 | for (i=0; i<len; i++) {
|
---|
1128 | e = cache[i];
|
---|
1129 | if (e._id == event._id && e != event) {
|
---|
1130 | e.start = new Date(+e.start + startDelta);
|
---|
1131 | if (event.end) {
|
---|
1132 | if (e.end) {
|
---|
1133 | e.end = new Date(+e.end + endDelta);
|
---|
1134 | }else{
|
---|
1135 | e.end = new Date(+defaultEventEnd(e) + endDelta);
|
---|
1136 | }
|
---|
1137 | }else{
|
---|
1138 | e.end = null;
|
---|
1139 | }
|
---|
1140 | e.title = event.title;
|
---|
1141 | e.url = event.url;
|
---|
1142 | e.allDay = event.allDay;
|
---|
1143 | e.className = event.className;
|
---|
1144 | e.editable = event.editable;
|
---|
1145 | e.color = event.color;
|
---|
1146 | e.backgroundColor = event.backgroundColor;
|
---|
1147 | e.borderColor = event.borderColor;
|
---|
1148 | e.textColor = event.textColor;
|
---|
1149 | normalizeEvent(e);
|
---|
1150 | }
|
---|
1151 | }
|
---|
1152 | normalizeEvent(event);
|
---|
1153 | reportEvents(cache);
|
---|
1154 | }
|
---|
1155 |
|
---|
1156 |
|
---|
1157 | function renderEvent(event, stick) {
|
---|
1158 | normalizeEvent(event);
|
---|
1159 | if (!event.source) {
|
---|
1160 | if (stick) {
|
---|
1161 | stickySource.events.push(event);
|
---|
1162 | event.source = stickySource;
|
---|
1163 | }
|
---|
1164 | cache.push(event);
|
---|
1165 | }
|
---|
1166 | reportEvents(cache);
|
---|
1167 | }
|
---|
1168 |
|
---|
1169 |
|
---|
1170 | function removeEvents(filter) {
|
---|
1171 | if (!filter) { // remove all
|
---|
1172 | cache = [];
|
---|
1173 | // clear all array sources
|
---|
1174 | for (var i=0; i<sources.length; i++) {
|
---|
1175 | if ($.isArray(sources[i].events)) {
|
---|
1176 | sources[i].events = [];
|
---|
1177 | }
|
---|
1178 | }
|
---|
1179 | }else{
|
---|
1180 | if (!$.isFunction(filter)) { // an event ID
|
---|
1181 | var id = filter + '';
|
---|
1182 | filter = function(e) {
|
---|
1183 | return e._id == id;
|
---|
1184 | };
|
---|
1185 | }
|
---|
1186 | cache = $.grep(cache, filter, true);
|
---|
1187 | // remove events from array sources
|
---|
1188 | for (var i=0; i<sources.length; i++) {
|
---|
1189 | if ($.isArray(sources[i].events)) {
|
---|
1190 | sources[i].events = $.grep(sources[i].events, filter, true);
|
---|
1191 | }
|
---|
1192 | }
|
---|
1193 | }
|
---|
1194 | reportEvents(cache);
|
---|
1195 | }
|
---|
1196 |
|
---|
1197 |
|
---|
1198 | function clientEvents(filter) {
|
---|
1199 | if ($.isFunction(filter)) {
|
---|
1200 | return $.grep(cache, filter);
|
---|
1201 | }
|
---|
1202 | else if (filter) { // an event ID
|
---|
1203 | filter += '';
|
---|
1204 | return $.grep(cache, function(e) {
|
---|
1205 | return e._id == filter;
|
---|
1206 | });
|
---|
1207 | }
|
---|
1208 | return cache; // else, return all
|
---|
1209 | }
|
---|
1210 |
|
---|
1211 |
|
---|
1212 |
|
---|
1213 | /* Loading State
|
---|
1214 | -----------------------------------------------------------------------------*/
|
---|
1215 |
|
---|
1216 |
|
---|
1217 | function pushLoading() {
|
---|
1218 | if (!loadingLevel++) {
|
---|
1219 | trigger('loading', null, true, getView());
|
---|
1220 | }
|
---|
1221 | }
|
---|
1222 |
|
---|
1223 |
|
---|
1224 | function popLoading() {
|
---|
1225 | if (!--loadingLevel) {
|
---|
1226 | trigger('loading', null, false, getView());
|
---|
1227 | }
|
---|
1228 | }
|
---|
1229 |
|
---|
1230 |
|
---|
1231 |
|
---|
1232 | /* Event Normalization
|
---|
1233 | -----------------------------------------------------------------------------*/
|
---|
1234 |
|
---|
1235 |
|
---|
1236 | function normalizeEvent(event) {
|
---|
1237 | var source = event.source || {};
|
---|
1238 | var ignoreTimezone = firstDefined(source.ignoreTimezone, options.ignoreTimezone);
|
---|
1239 | event._id = event._id || (event.id === undefined ? '_fc' + eventGUID++ : event.id + '');
|
---|
1240 | if (event.date) {
|
---|
1241 | if (!event.start) {
|
---|
1242 | event.start = event.date;
|
---|
1243 | }
|
---|
1244 | delete event.date;
|
---|
1245 | }
|
---|
1246 | event._start = cloneDate(event.start = parseDate(event.start, ignoreTimezone));
|
---|
1247 | event.end = parseDate(event.end, ignoreTimezone);
|
---|
1248 | if (event.end && event.end <= event.start) {
|
---|
1249 | event.end = null;
|
---|
1250 | }
|
---|
1251 | event._end = event.end ? cloneDate(event.end) : null;
|
---|
1252 | if (event.allDay === undefined) {
|
---|
1253 | event.allDay = firstDefined(source.allDayDefault, options.allDayDefault);
|
---|
1254 | }
|
---|
1255 | if (event.className) {
|
---|
1256 | if (typeof event.className == 'string') {
|
---|
1257 | event.className = event.className.split(/\s+/);
|
---|
1258 | }
|
---|
1259 | }else{
|
---|
1260 | event.className = [];
|
---|
1261 | }
|
---|
1262 | // TODO: if there is no start date, return false to indicate an invalid event
|
---|
1263 | }
|
---|
1264 |
|
---|
1265 |
|
---|
1266 |
|
---|
1267 | /* Utils
|
---|
1268 | ------------------------------------------------------------------------------*/
|
---|
1269 |
|
---|
1270 |
|
---|
1271 | function normalizeSource(source) {
|
---|
1272 | if (source.className) {
|
---|
1273 | // TODO: repeat code, same code for event classNames
|
---|
1274 | if (typeof source.className == 'string') {
|
---|
1275 | source.className = source.className.split(/\s+/);
|
---|
1276 | }
|
---|
1277 | }else{
|
---|
1278 | source.className = [];
|
---|
1279 | }
|
---|
1280 | var normalizers = fc.sourceNormalizers;
|
---|
1281 | for (var i=0; i<normalizers.length; i++) {
|
---|
1282 | normalizers[i](source);
|
---|
1283 | }
|
---|
1284 | }
|
---|
1285 |
|
---|
1286 |
|
---|
1287 | function isSourcesEqual(source1, source2) {
|
---|
1288 | return source1 && source2 && getSourcePrimitive(source1) == getSourcePrimitive(source2);
|
---|
1289 | }
|
---|
1290 |
|
---|
1291 |
|
---|
1292 | function getSourcePrimitive(source) {
|
---|
1293 | return ((typeof source == 'object') ? (source.events || source.url) : '') || source;
|
---|
1294 | }
|
---|
1295 |
|
---|
1296 |
|
---|
1297 | }
|
---|
1298 |
|
---|
1299 | ;;
|
---|
1300 |
|
---|
1301 |
|
---|
1302 | fc.addDays = addDays;
|
---|
1303 | fc.cloneDate = cloneDate;
|
---|
1304 | fc.parseDate = parseDate;
|
---|
1305 | fc.parseISO8601 = parseISO8601;
|
---|
1306 | fc.parseTime = parseTime;
|
---|
1307 | fc.formatDate = formatDate;
|
---|
1308 | fc.formatDates = formatDates;
|
---|
1309 |
|
---|
1310 |
|
---|
1311 |
|
---|
1312 | /* Date Math
|
---|
1313 | -----------------------------------------------------------------------------*/
|
---|
1314 |
|
---|
1315 | var dayIDs = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'],
|
---|
1316 | DAY_MS = 86400000,
|
---|
1317 | HOUR_MS = 3600000,
|
---|
1318 | MINUTE_MS = 60000;
|
---|
1319 |
|
---|
1320 |
|
---|
1321 | function addYears(d, n, keepTime) {
|
---|
1322 | d.setFullYear(d.getFullYear() + n);
|
---|
1323 | if (!keepTime) {
|
---|
1324 | clearTime(d);
|
---|
1325 | }
|
---|
1326 | return d;
|
---|
1327 | }
|
---|
1328 |
|
---|
1329 |
|
---|
1330 | function addMonths(d, n, keepTime) { // prevents day overflow/underflow
|
---|
1331 | if (+d) { // prevent infinite looping on invalid dates
|
---|
1332 | var m = d.getMonth() + n,
|
---|
1333 | check = cloneDate(d);
|
---|
1334 | check.setDate(1);
|
---|
1335 | check.setMonth(m);
|
---|
1336 | d.setMonth(m);
|
---|
1337 | if (!keepTime) {
|
---|
1338 | clearTime(d);
|
---|
1339 | }
|
---|
1340 | while (d.getMonth() != check.getMonth()) {
|
---|
1341 | d.setDate(d.getDate() + (d < check ? 1 : -1));
|
---|
1342 | }
|
---|
1343 | }
|
---|
1344 | return d;
|
---|
1345 | }
|
---|
1346 |
|
---|
1347 |
|
---|
1348 | function addDays(d, n, keepTime) { // deals with daylight savings
|
---|
1349 | if (+d) {
|
---|
1350 | var dd = d.getDate() + n,
|
---|
1351 | check = cloneDate(d);
|
---|
1352 | check.setHours(9); // set to middle of day
|
---|
1353 | check.setDate(dd);
|
---|
1354 | d.setDate(dd);
|
---|
1355 | if (!keepTime) {
|
---|
1356 | clearTime(d);
|
---|
1357 | }
|
---|
1358 | fixDate(d, check);
|
---|
1359 | }
|
---|
1360 | return d;
|
---|
1361 | }
|
---|
1362 |
|
---|
1363 |
|
---|
1364 | function fixDate(d, check) { // force d to be on check's YMD, for daylight savings purposes
|
---|
1365 | if (+d) { // prevent infinite looping on invalid dates
|
---|
1366 | while (d.getDate() != check.getDate()) {
|
---|
1367 | d.setTime(+d + (d < check ? 1 : -1) * HOUR_MS);
|
---|
1368 | }
|
---|
1369 | }
|
---|
1370 | }
|
---|
1371 |
|
---|
1372 |
|
---|
1373 | function addMinutes(d, n) {
|
---|
1374 | d.setMinutes(d.getMinutes() + n);
|
---|
1375 | return d;
|
---|
1376 | }
|
---|
1377 |
|
---|
1378 |
|
---|
1379 | function clearTime(d) {
|
---|
1380 | d.setHours(0);
|
---|
1381 | d.setMinutes(0);
|
---|
1382 | d.setSeconds(0);
|
---|
1383 | d.setMilliseconds(0);
|
---|
1384 | return d;
|
---|
1385 | }
|
---|
1386 |
|
---|
1387 |
|
---|
1388 | function cloneDate(d, dontKeepTime) {
|
---|
1389 | if (dontKeepTime) {
|
---|
1390 | return clearTime(new Date(+d));
|
---|
1391 | }
|
---|
1392 | return new Date(+d);
|
---|
1393 | }
|
---|
1394 |
|
---|
1395 |
|
---|
1396 | function zeroDate() { // returns a Date with time 00:00:00 and dateOfMonth=1
|
---|
1397 | var i=0, d;
|
---|
1398 | do {
|
---|
1399 | d = new Date(1970, i++, 1);
|
---|
1400 | } while (d.getHours()); // != 0
|
---|
1401 | return d;
|
---|
1402 | }
|
---|
1403 |
|
---|
1404 |
|
---|
1405 | function dayDiff(d1, d2) { // d1 - d2
|
---|
1406 | return Math.round((cloneDate(d1, true) - cloneDate(d2, true)) / DAY_MS);
|
---|
1407 | }
|
---|
1408 |
|
---|
1409 |
|
---|
1410 | function setYMD(date, y, m, d) {
|
---|
1411 | if (y !== undefined && y != date.getFullYear()) {
|
---|
1412 | date.setDate(1);
|
---|
1413 | date.setMonth(0);
|
---|
1414 | date.setFullYear(y);
|
---|
1415 | }
|
---|
1416 | if (m !== undefined && m != date.getMonth()) {
|
---|
1417 | date.setDate(1);
|
---|
1418 | date.setMonth(m);
|
---|
1419 | }
|
---|
1420 | if (d !== undefined) {
|
---|
1421 | date.setDate(d);
|
---|
1422 | }
|
---|
1423 | }
|
---|
1424 |
|
---|
1425 |
|
---|
1426 |
|
---|
1427 | /* Date Parsing
|
---|
1428 | -----------------------------------------------------------------------------*/
|
---|
1429 |
|
---|
1430 |
|
---|
1431 | function parseDate(s, ignoreTimezone) { // ignoreTimezone defaults to true
|
---|
1432 | if (typeof s == 'object') { // already a Date object
|
---|
1433 | return s;
|
---|
1434 | }
|
---|
1435 | if (typeof s == 'number') { // a UNIX timestamp
|
---|
1436 | return new Date(s * 1000);
|
---|
1437 | }
|
---|
1438 | if (typeof s == 'string') {
|
---|
1439 | if (s.match(/^\d+(\.\d+)?$/)) { // a UNIX timestamp
|
---|
1440 | return new Date(parseFloat(s) * 1000);
|
---|
1441 | }
|
---|
1442 | if (ignoreTimezone === undefined) {
|
---|
1443 | ignoreTimezone = true;
|
---|
1444 | }
|
---|
1445 | return parseISO8601(s, ignoreTimezone) || (s ? new Date(s) : null);
|
---|
1446 | }
|
---|
1447 | // TODO: never return invalid dates (like from new Date(<string>)), return null instead
|
---|
1448 | return null;
|
---|
1449 | }
|
---|
1450 |
|
---|
1451 |
|
---|
1452 | function parseISO8601(s, ignoreTimezone) { // ignoreTimezone defaults to false
|
---|
1453 | // derived from http://delete.me.uk/2005/03/iso8601.html
|
---|
1454 | // TODO: for a know glitch/feature, read tests/issue_206_parseDate_dst.html
|
---|
1455 | var m = s.match(/^([0-9]{4})(-([0-9]{2})(-([0-9]{2})([T ]([0-9]{2}):([0-9]{2})(:([0-9]{2})(\.([0-9]+))?)?(Z|(([-+])([0-9]{2})(:?([0-9]{2}))?))?)?)?)?$/);
|
---|
1456 | if (!m) {
|
---|
1457 | return null;
|
---|
1458 | }
|
---|
1459 | var date = new Date(m[1], 0, 1);
|
---|
1460 | if (ignoreTimezone || !m[13]) {
|
---|
1461 | var check = new Date(m[1], 0, 1, 9, 0);
|
---|
1462 | if (m[3]) {
|
---|
1463 | date.setMonth(m[3] - 1);
|
---|
1464 | check.setMonth(m[3] - 1);
|
---|
1465 | }
|
---|
1466 | if (m[5]) {
|
---|
1467 | date.setDate(m[5]);
|
---|
1468 | check.setDate(m[5]);
|
---|
1469 | }
|
---|
1470 | fixDate(date, check);
|
---|
1471 | if (m[7]) {
|
---|
1472 | date.setHours(m[7]);
|
---|
1473 | }
|
---|
1474 | if (m[8]) {
|
---|
1475 | date.setMinutes(m[8]);
|
---|
1476 | }
|
---|
1477 | if (m[10]) {
|
---|
1478 | date.setSeconds(m[10]);
|
---|
1479 | }
|
---|
1480 | if (m[12]) {
|
---|
1481 | date.setMilliseconds(Number("0." + m[12]) * 1000);
|
---|
1482 | }
|
---|
1483 | fixDate(date, check);
|
---|
1484 | }else{
|
---|
1485 | date.setUTCFullYear(
|
---|
1486 | m[1],
|
---|
1487 | m[3] ? m[3] - 1 : 0,
|
---|
1488 | m[5] || 1
|
---|
1489 | );
|
---|
1490 | date.setUTCHours(
|
---|
1491 | m[7] || 0,
|
---|
1492 | m[8] || 0,
|
---|
1493 | m[10] || 0,
|
---|
1494 | m[12] ? Number("0." + m[12]) * 1000 : 0
|
---|
1495 | );
|
---|
1496 | if (m[14]) {
|
---|
1497 | var offset = Number(m[16]) * 60 + (m[18] ? Number(m[18]) : 0);
|
---|
1498 | offset *= m[15] == '-' ? 1 : -1;
|
---|
1499 | date = new Date(+date + (offset * 60 * 1000));
|
---|
1500 | }
|
---|
1501 | }
|
---|
1502 | return date;
|
---|
1503 | }
|
---|
1504 |
|
---|
1505 |
|
---|
1506 | function parseTime(s) { // returns minutes since start of day
|
---|
1507 | if (typeof s == 'number') { // an hour
|
---|
1508 | return s * 60;
|
---|
1509 | }
|
---|
1510 | if (typeof s == 'object') { // a Date object
|
---|
1511 | return s.getHours() * 60 + s.getMinutes();
|
---|
1512 | }
|
---|
1513 | var m = s.match(/(\d+)(?::(\d+))?\s*(\w+)?/);
|
---|
1514 | if (m) {
|
---|
1515 | var h = parseInt(m[1], 10);
|
---|
1516 | if (m[3]) {
|
---|
1517 | h %= 12;
|
---|
1518 | if (m[3].toLowerCase().charAt(0) == 'p') {
|
---|
1519 | h += 12;
|
---|
1520 | }
|
---|
1521 | }
|
---|
1522 | return h * 60 + (m[2] ? parseInt(m[2], 10) : 0);
|
---|
1523 | }
|
---|
1524 | }
|
---|
1525 |
|
---|
1526 |
|
---|
1527 |
|
---|
1528 | /* Date Formatting
|
---|
1529 | -----------------------------------------------------------------------------*/
|
---|
1530 | // TODO: use same function formatDate(date, [date2], format, [options])
|
---|
1531 |
|
---|
1532 |
|
---|
1533 | function formatDate(date, format, options) {
|
---|
1534 | return formatDates(date, null, format, options);
|
---|
1535 | }
|
---|
1536 |
|
---|
1537 |
|
---|
1538 | function formatDates(date1, date2, format, options) {
|
---|
1539 | options = options || defaults;
|
---|
1540 | var date = date1,
|
---|
1541 | otherDate = date2,
|
---|
1542 | i, len = format.length, c,
|
---|
1543 | i2, formatter,
|
---|
1544 | res = '';
|
---|
1545 | for (i=0; i<len; i++) {
|
---|
1546 | c = format.charAt(i);
|
---|
1547 | if (c == "'") {
|
---|
1548 | for (i2=i+1; i2<len; i2++) {
|
---|
1549 | if (format.charAt(i2) == "'") {
|
---|
1550 | if (date) {
|
---|
1551 | if (i2 == i+1) {
|
---|
1552 | res += "'";
|
---|
1553 | }else{
|
---|
1554 | res += format.substring(i+1, i2);
|
---|
1555 | }
|
---|
1556 | i = i2;
|
---|
1557 | }
|
---|
1558 | break;
|
---|
1559 | }
|
---|
1560 | }
|
---|
1561 | }
|
---|
1562 | else if (c == '(') {
|
---|
1563 | for (i2=i+1; i2<len; i2++) {
|
---|
1564 | if (format.charAt(i2) == ')') {
|
---|
1565 | var subres = formatDate(date, format.substring(i+1, i2), options);
|
---|
1566 | if (parseInt(subres.replace(/\D/, ''), 10)) {
|
---|
1567 | res += subres;
|
---|
1568 | }
|
---|
1569 | i = i2;
|
---|
1570 | break;
|
---|
1571 | }
|
---|
1572 | }
|
---|
1573 | }
|
---|
1574 | else if (c == '[') {
|
---|
1575 | for (i2=i+1; i2<len; i2++) {
|
---|
1576 | if (format.charAt(i2) == ']') {
|
---|
1577 | var subformat = format.substring(i+1, i2);
|
---|
1578 | var subres = formatDate(date, subformat, options);
|
---|
1579 | if (subres != formatDate(otherDate, subformat, options)) {
|
---|
1580 | res += subres;
|
---|
1581 | }
|
---|
1582 | i = i2;
|
---|
1583 | break;
|
---|
1584 | }
|
---|
1585 | }
|
---|
1586 | }
|
---|
1587 | else if (c == '{') {
|
---|
1588 | date = date2;
|
---|
1589 | otherDate = date1;
|
---|
1590 | }
|
---|
1591 | else if (c == '}') {
|
---|
1592 | date = date1;
|
---|
1593 | otherDate = date2;
|
---|
1594 | }
|
---|
1595 | else {
|
---|
1596 | for (i2=len; i2>i; i2--) {
|
---|
1597 | if (formatter = dateFormatters[format.substring(i, i2)]) {
|
---|
1598 | if (date) {
|
---|
1599 | res += formatter(date, options);
|
---|
1600 | }
|
---|
1601 | i = i2 - 1;
|
---|
1602 | break;
|
---|
1603 | }
|
---|
1604 | }
|
---|
1605 | if (i2 == i) {
|
---|
1606 | if (date) {
|
---|
1607 | res += c;
|
---|
1608 | }
|
---|
1609 | }
|
---|
1610 | }
|
---|
1611 | }
|
---|
1612 | return res;
|
---|
1613 | };
|
---|
1614 |
|
---|
1615 |
|
---|
1616 | var dateFormatters = {
|
---|
1617 | s : function(d) { return d.getSeconds() },
|
---|
1618 | ss : function(d) { return zeroPad(d.getSeconds()) },
|
---|
1619 | m : function(d) { return d.getMinutes() },
|
---|
1620 | mm : function(d) { return zeroPad(d.getMinutes()) },
|
---|
1621 | h : function(d) { return d.getHours() % 12 || 12 },
|
---|
1622 | hh : function(d) { return zeroPad(d.getHours() % 12 || 12) },
|
---|
1623 | H : function(d) { return d.getHours() },
|
---|
1624 | HH : function(d) { return zeroPad(d.getHours()) },
|
---|
1625 | d : function(d) { return d.getDate() },
|
---|
1626 | dd : function(d) { return zeroPad(d.getDate()) },
|
---|
1627 | ddd : function(d,o) { return o.dayNamesShort[d.getDay()] },
|
---|
1628 | dddd: function(d,o) { return o.dayNames[d.getDay()] },
|
---|
1629 | M : function(d) { return d.getMonth() + 1 },
|
---|
1630 | MM : function(d) { return zeroPad(d.getMonth() + 1) },
|
---|
1631 | MMM : function(d,o) { return o.monthNamesShort[d.getMonth()] },
|
---|
1632 | MMMM: function(d,o) { return o.monthNames[d.getMonth()] },
|
---|
1633 | yy : function(d) { return (d.getFullYear()+'').substring(2) },
|
---|
1634 | yyyy: function(d) { return d.getFullYear() },
|
---|
1635 | t : function(d) { return d.getHours() < 12 ? 'a' : 'p' },
|
---|
1636 | tt : function(d) { return d.getHours() < 12 ? 'am' : 'pm' },
|
---|
1637 | T : function(d) { return d.getHours() < 12 ? 'A' : 'P' },
|
---|
1638 | TT : function(d) { return d.getHours() < 12 ? 'AM' : 'PM' },
|
---|
1639 | u : function(d) { return formatDate(d, "yyyy-MM-dd'T'HH:mm:ss'Z'") },
|
---|
1640 | S : function(d) {
|
---|
1641 | var date = d.getDate();
|
---|
1642 | if (date > 10 && date < 20) {
|
---|
1643 | return 'th';
|
---|
1644 | }
|
---|
1645 | return ['st', 'nd', 'rd'][date%10-1] || 'th';
|
---|
1646 | },
|
---|
1647 | w : function(d, o) { // local
|
---|
1648 | return o.weekNumberCalculation(d);
|
---|
1649 | },
|
---|
1650 | W : function(d) { // ISO
|
---|
1651 | return iso8601Week(d);
|
---|
1652 | }
|
---|
1653 | };
|
---|
1654 | fc.dateFormatters = dateFormatters;
|
---|
1655 |
|
---|
1656 |
|
---|
1657 | /* thanks jQuery UI (https://github.com/jquery/jquery-ui/blob/master/ui/jquery.ui.datepicker.js)
|
---|
1658 | *
|
---|
1659 | * Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
|
---|
1660 | * `date` - the date to get the week for
|
---|
1661 | * `number` - the number of the week within the year that contains this date
|
---|
1662 | */
|
---|
1663 | function iso8601Week(date) {
|
---|
1664 | var time;
|
---|
1665 | var checkDate = new Date(date.getTime());
|
---|
1666 |
|
---|
1667 | // Find Thursday of this week starting on Monday
|
---|
1668 | checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
|
---|
1669 |
|
---|
1670 | time = checkDate.getTime();
|
---|
1671 | checkDate.setMonth(0); // Compare with Jan 1
|
---|
1672 | checkDate.setDate(1);
|
---|
1673 | return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
|
---|
1674 | }
|
---|
1675 |
|
---|
1676 |
|
---|
1677 | ;;
|
---|
1678 |
|
---|
1679 | fc.applyAll = applyAll;
|
---|
1680 |
|
---|
1681 |
|
---|
1682 | /* Event Date Math
|
---|
1683 | -----------------------------------------------------------------------------*/
|
---|
1684 |
|
---|
1685 |
|
---|
1686 | function exclEndDay(event) {
|
---|
1687 | if (event.end) {
|
---|
1688 | return _exclEndDay(event.end, event.allDay);
|
---|
1689 | }else{
|
---|
1690 | return addDays(cloneDate(event.start), 1);
|
---|
1691 | }
|
---|
1692 | }
|
---|
1693 |
|
---|
1694 |
|
---|
1695 | function _exclEndDay(end, allDay) {
|
---|
1696 | end = cloneDate(end);
|
---|
1697 | return allDay || end.getHours() || end.getMinutes() ? addDays(end, 1) : clearTime(end);
|
---|
1698 | // why don't we check for seconds/ms too?
|
---|
1699 | }
|
---|
1700 |
|
---|
1701 |
|
---|
1702 |
|
---|
1703 | /* Event Element Binding
|
---|
1704 | -----------------------------------------------------------------------------*/
|
---|
1705 |
|
---|
1706 |
|
---|
1707 | function lazySegBind(container, segs, bindHandlers) {
|
---|
1708 | container.unbind('mouseover').mouseover(function(ev) {
|
---|
1709 | var parent=ev.target, e,
|
---|
1710 | i, seg;
|
---|
1711 | while (parent != this) {
|
---|
1712 | e = parent;
|
---|
1713 | parent = parent.parentNode;
|
---|
1714 | }
|
---|
1715 | if ((i = e._fci) !== undefined) {
|
---|
1716 | e._fci = undefined;
|
---|
1717 | seg = segs[i];
|
---|
1718 | bindHandlers(seg.event, seg.element, seg);
|
---|
1719 | $(ev.target).trigger(ev);
|
---|
1720 | }
|
---|
1721 | ev.stopPropagation();
|
---|
1722 | });
|
---|
1723 | }
|
---|
1724 |
|
---|
1725 |
|
---|
1726 |
|
---|
1727 | /* Element Dimensions
|
---|
1728 | -----------------------------------------------------------------------------*/
|
---|
1729 |
|
---|
1730 |
|
---|
1731 | function setOuterWidth(element, width, includeMargins) {
|
---|
1732 | for (var i=0, e; i<element.length; i++) {
|
---|
1733 | e = $(element[i]);
|
---|
1734 | e.width(Math.max(0, width - hsides(e, includeMargins)));
|
---|
1735 | }
|
---|
1736 | }
|
---|
1737 |
|
---|
1738 |
|
---|
1739 | function setOuterHeight(element, height, includeMargins) {
|
---|
1740 | for (var i=0, e; i<element.length; i++) {
|
---|
1741 | e = $(element[i]);
|
---|
1742 | e.height(Math.max(0, height - vsides(e, includeMargins)));
|
---|
1743 | }
|
---|
1744 | }
|
---|
1745 |
|
---|
1746 |
|
---|
1747 | function hsides(element, includeMargins) {
|
---|
1748 | return hpadding(element) + hborders(element) + (includeMargins ? hmargins(element) : 0);
|
---|
1749 | }
|
---|
1750 |
|
---|
1751 |
|
---|
1752 | function hpadding(element) {
|
---|
1753 | return (parseFloat($.css(element[0], 'paddingLeft', true)) || 0) +
|
---|
1754 | (parseFloat($.css(element[0], 'paddingRight', true)) || 0);
|
---|
1755 | }
|
---|
1756 |
|
---|
1757 |
|
---|
1758 | function hmargins(element) {
|
---|
1759 | return (parseFloat($.css(element[0], 'marginLeft', true)) || 0) +
|
---|
1760 | (parseFloat($.css(element[0], 'marginRight', true)) || 0);
|
---|
1761 | }
|
---|
1762 |
|
---|
1763 |
|
---|
1764 | function hborders(element) {
|
---|
1765 | return (parseFloat($.css(element[0], 'borderLeftWidth', true)) || 0) +
|
---|
1766 | (parseFloat($.css(element[0], 'borderRightWidth', true)) || 0);
|
---|
1767 | }
|
---|
1768 |
|
---|
1769 |
|
---|
1770 | function vsides(element, includeMargins) {
|
---|
1771 | return vpadding(element) + vborders(element) + (includeMargins ? vmargins(element) : 0);
|
---|
1772 | }
|
---|
1773 |
|
---|
1774 |
|
---|
1775 | function vpadding(element) {
|
---|
1776 | return (parseFloat($.css(element[0], 'paddingTop', true)) || 0) +
|
---|
1777 | (parseFloat($.css(element[0], 'paddingBottom', true)) || 0);
|
---|
1778 | }
|
---|
1779 |
|
---|
1780 |
|
---|
1781 | function vmargins(element) {
|
---|
1782 | return (parseFloat($.css(element[0], 'marginTop', true)) || 0) +
|
---|
1783 | (parseFloat($.css(element[0], 'marginBottom', true)) || 0);
|
---|
1784 | }
|
---|
1785 |
|
---|
1786 |
|
---|
1787 | function vborders(element) {
|
---|
1788 | return (parseFloat($.css(element[0], 'borderTopWidth', true)) || 0) +
|
---|
1789 | (parseFloat($.css(element[0], 'borderBottomWidth', true)) || 0);
|
---|
1790 | }
|
---|
1791 |
|
---|
1792 |
|
---|
1793 |
|
---|
1794 | /* Misc Utils
|
---|
1795 | -----------------------------------------------------------------------------*/
|
---|
1796 |
|
---|
1797 |
|
---|
1798 | //TODO: arraySlice
|
---|
1799 | //TODO: isFunction, grep ?
|
---|
1800 |
|
---|
1801 |
|
---|
1802 | function noop() { }
|
---|
1803 |
|
---|
1804 |
|
---|
1805 | function dateCompare(a, b) {
|
---|
1806 | return a - b;
|
---|
1807 | }
|
---|
1808 |
|
---|
1809 |
|
---|
1810 | function arrayMax(a) {
|
---|
1811 | return Math.max.apply(Math, a);
|
---|
1812 | }
|
---|
1813 |
|
---|
1814 |
|
---|
1815 | function zeroPad(n) {
|
---|
1816 | return (n < 10 ? '0' : '') + n;
|
---|
1817 | }
|
---|
1818 |
|
---|
1819 |
|
---|
1820 | function smartProperty(obj, name) { // get a camel-cased/namespaced property of an object
|
---|
1821 | if (obj[name] !== undefined) {
|
---|
1822 | return obj[name];
|
---|
1823 | }
|
---|
1824 | var parts = name.split(/(?=[A-Z])/),
|
---|
1825 | i=parts.length-1, res;
|
---|
1826 | for (; i>=0; i--) {
|
---|
1827 | res = obj[parts[i].toLowerCase()];
|
---|
1828 | if (res !== undefined) {
|
---|
1829 | return res;
|
---|
1830 | }
|
---|
1831 | }
|
---|
1832 | return obj[''];
|
---|
1833 | }
|
---|
1834 |
|
---|
1835 |
|
---|
1836 | function htmlEscape(s) {
|
---|
1837 | return s.replace(/&/g, '&')
|
---|
1838 | .replace(/</g, '<')
|
---|
1839 | .replace(/>/g, '>')
|
---|
1840 | .replace(/'/g, ''')
|
---|
1841 | .replace(/"/g, '"')
|
---|
1842 | .replace(/\n/g, '<br />');
|
---|
1843 | }
|
---|
1844 |
|
---|
1845 |
|
---|
1846 | function disableTextSelection(element) {
|
---|
1847 | element
|
---|
1848 | .attr('unselectable', 'on')
|
---|
1849 | .css('MozUserSelect', 'none')
|
---|
1850 | .bind('selectstart.ui', function() { return false; });
|
---|
1851 | }
|
---|
1852 |
|
---|
1853 |
|
---|
1854 | /*
|
---|
1855 | function enableTextSelection(element) {
|
---|
1856 | element
|
---|
1857 | .attr('unselectable', 'off')
|
---|
1858 | .css('MozUserSelect', '')
|
---|
1859 | .unbind('selectstart.ui');
|
---|
1860 | }
|
---|
1861 | */
|
---|
1862 |
|
---|
1863 |
|
---|
1864 | function markFirstLast(e) {
|
---|
1865 | e.children()
|
---|
1866 | .removeClass('fc-first fc-last')
|
---|
1867 | .filter(':first-child')
|
---|
1868 | .addClass('fc-first')
|
---|
1869 | .end()
|
---|
1870 | .filter(':last-child')
|
---|
1871 | .addClass('fc-last');
|
---|
1872 | }
|
---|
1873 |
|
---|
1874 |
|
---|
1875 | function setDayID(cell, date) {
|
---|
1876 | cell.each(function(i, _cell) {
|
---|
1877 | _cell.className = _cell.className.replace(/^fc-\w*/, 'fc-' + dayIDs[date.getDay()]);
|
---|
1878 | // TODO: make a way that doesn't rely on order of classes
|
---|
1879 | });
|
---|
1880 | }
|
---|
1881 |
|
---|
1882 |
|
---|
1883 | function getSkinCss(event, opt) {
|
---|
1884 | var source = event.source || {};
|
---|
1885 | var eventColor = event.color;
|
---|
1886 | var sourceColor = source.color;
|
---|
1887 | var optionColor = opt('eventColor');
|
---|
1888 | var backgroundColor =
|
---|
1889 | event.backgroundColor ||
|
---|
1890 | eventColor ||
|
---|
1891 | source.backgroundColor ||
|
---|
1892 | sourceColor ||
|
---|
1893 | opt('eventBackgroundColor') ||
|
---|
1894 | optionColor;
|
---|
1895 | var borderColor =
|
---|
1896 | event.borderColor ||
|
---|
1897 | eventColor ||
|
---|
1898 | source.borderColor ||
|
---|
1899 | sourceColor ||
|
---|
1900 | opt('eventBorderColor') ||
|
---|
1901 | optionColor;
|
---|
1902 | var textColor =
|
---|
1903 | event.textColor ||
|
---|
1904 | source.textColor ||
|
---|
1905 | opt('eventTextColor');
|
---|
1906 | var statements = [];
|
---|
1907 | if (backgroundColor) {
|
---|
1908 | statements.push('background-color:' + backgroundColor);
|
---|
1909 | }
|
---|
1910 | if (borderColor) {
|
---|
1911 | statements.push('border-color:' + borderColor);
|
---|
1912 | }
|
---|
1913 | if (textColor) {
|
---|
1914 | statements.push('color:' + textColor);
|
---|
1915 | }
|
---|
1916 | return statements.join(';');
|
---|
1917 | }
|
---|
1918 |
|
---|
1919 |
|
---|
1920 | function applyAll(functions, thisObj, args) {
|
---|
1921 | if ($.isFunction(functions)) {
|
---|
1922 | functions = [ functions ];
|
---|
1923 | }
|
---|
1924 | if (functions) {
|
---|
1925 | var i;
|
---|
1926 | var ret;
|
---|
1927 | for (i=0; i<functions.length; i++) {
|
---|
1928 | ret = functions[i].apply(thisObj, args) || ret;
|
---|
1929 | }
|
---|
1930 | return ret;
|
---|
1931 | }
|
---|
1932 | }
|
---|
1933 |
|
---|
1934 |
|
---|
1935 | function firstDefined() {
|
---|
1936 | for (var i=0; i<arguments.length; i++) {
|
---|
1937 | if (arguments[i] !== undefined) {
|
---|
1938 | return arguments[i];
|
---|
1939 | }
|
---|
1940 | }
|
---|
1941 | }
|
---|
1942 |
|
---|
1943 |
|
---|
1944 | ;;
|
---|
1945 |
|
---|
1946 | fcViews.month = MonthView;
|
---|
1947 |
|
---|
1948 | function MonthView(element, calendar) {
|
---|
1949 | var t = this;
|
---|
1950 |
|
---|
1951 |
|
---|
1952 | // exports
|
---|
1953 | t.render = render;
|
---|
1954 |
|
---|
1955 |
|
---|
1956 | // imports
|
---|
1957 | BasicView.call(t, element, calendar, 'month');
|
---|
1958 | var opt = t.opt;
|
---|
1959 | var renderBasic = t.renderBasic;
|
---|
1960 | var skipHiddenDays = t.skipHiddenDays;
|
---|
1961 | var getCellsPerWeek = t.getCellsPerWeek;
|
---|
1962 | var formatDate = calendar.formatDate;
|
---|
1963 |
|
---|
1964 |
|
---|
1965 | function render(date, delta) {
|
---|
1966 |
|
---|
1967 | if (delta) {
|
---|
1968 | addMonths(date, delta);
|
---|
1969 | date.setDate(1);
|
---|
1970 | }
|
---|
1971 |
|
---|
1972 | var firstDay = opt('firstDay');
|
---|
1973 |
|
---|
1974 | var start = cloneDate(date, true);
|
---|
1975 | start.setDate(1);
|
---|
1976 |
|
---|
1977 | var end = addMonths(cloneDate(start), 1);
|
---|
1978 |
|
---|
1979 | var visStart = cloneDate(start);
|
---|
1980 | addDays(visStart, -((visStart.getDay() - firstDay + 7) % 7));
|
---|
1981 | skipHiddenDays(visStart);
|
---|
1982 |
|
---|
1983 | var visEnd = cloneDate(end);
|
---|
1984 | addDays(visEnd, (7 - visEnd.getDay() + firstDay) % 7);
|
---|
1985 | skipHiddenDays(visEnd, -1, true);
|
---|
1986 |
|
---|
1987 | var colCnt = getCellsPerWeek();
|
---|
1988 | var rowCnt = Math.round(dayDiff(visEnd, visStart) / 7); // should be no need for Math.round
|
---|
1989 |
|
---|
1990 | if (opt('weekMode') == 'fixed') {
|
---|
1991 | addDays(visEnd, (6 - rowCnt) * 7); // add weeks to make up for it
|
---|
1992 | rowCnt = 6;
|
---|
1993 | }
|
---|
1994 |
|
---|
1995 | t.title = formatDate(start, opt('titleFormat'));
|
---|
1996 |
|
---|
1997 | t.start = start;
|
---|
1998 | t.end = end;
|
---|
1999 | t.visStart = visStart;
|
---|
2000 | t.visEnd = visEnd;
|
---|
2001 |
|
---|
2002 | renderBasic(rowCnt, colCnt, true);
|
---|
2003 | }
|
---|
2004 |
|
---|
2005 |
|
---|
2006 | }
|
---|
2007 |
|
---|
2008 | ;;
|
---|
2009 |
|
---|
2010 | fcViews.basicWeek = BasicWeekView;
|
---|
2011 |
|
---|
2012 | function BasicWeekView(element, calendar) {
|
---|
2013 | var t = this;
|
---|
2014 |
|
---|
2015 |
|
---|
2016 | // exports
|
---|
2017 | t.render = render;
|
---|
2018 |
|
---|
2019 |
|
---|
2020 | // imports
|
---|
2021 | BasicView.call(t, element, calendar, 'basicWeek');
|
---|
2022 | var opt = t.opt;
|
---|
2023 | var renderBasic = t.renderBasic;
|
---|
2024 | var skipHiddenDays = t.skipHiddenDays;
|
---|
2025 | var getCellsPerWeek = t.getCellsPerWeek;
|
---|
2026 | var formatDates = calendar.formatDates;
|
---|
2027 |
|
---|
2028 |
|
---|
2029 | function render(date, delta) {
|
---|
2030 |
|
---|
2031 | if (delta) {
|
---|
2032 | addDays(date, delta * 7);
|
---|
2033 | }
|
---|
2034 |
|
---|
2035 | var start = addDays(cloneDate(date), -((date.getDay() - opt('firstDay') + 7) % 7));
|
---|
2036 | var end = addDays(cloneDate(start), 7);
|
---|
2037 |
|
---|
2038 | var visStart = cloneDate(start);
|
---|
2039 | skipHiddenDays(visStart);
|
---|
2040 |
|
---|
2041 | var visEnd = cloneDate(end);
|
---|
2042 | skipHiddenDays(visEnd, -1, true);
|
---|
2043 |
|
---|
2044 | var colCnt = getCellsPerWeek();
|
---|
2045 |
|
---|
2046 | t.start = start;
|
---|
2047 | t.end = end;
|
---|
2048 | t.visStart = visStart;
|
---|
2049 | t.visEnd = visEnd;
|
---|
2050 |
|
---|
2051 | t.title = formatDates(
|
---|
2052 | visStart,
|
---|
2053 | addDays(cloneDate(visEnd), -1),
|
---|
2054 | opt('titleFormat')
|
---|
2055 | );
|
---|
2056 |
|
---|
2057 | renderBasic(1, colCnt, false);
|
---|
2058 | }
|
---|
2059 |
|
---|
2060 |
|
---|
2061 | }
|
---|
2062 |
|
---|
2063 | ;;
|
---|
2064 |
|
---|
2065 | fcViews.basicDay = BasicDayView;
|
---|
2066 |
|
---|
2067 |
|
---|
2068 | function BasicDayView(element, calendar) {
|
---|
2069 | var t = this;
|
---|
2070 |
|
---|
2071 |
|
---|
2072 | // exports
|
---|
2073 | t.render = render;
|
---|
2074 |
|
---|
2075 |
|
---|
2076 | // imports
|
---|
2077 | BasicView.call(t, element, calendar, 'basicDay');
|
---|
2078 | var opt = t.opt;
|
---|
2079 | var renderBasic = t.renderBasic;
|
---|
2080 | var skipHiddenDays = t.skipHiddenDays;
|
---|
2081 | var formatDate = calendar.formatDate;
|
---|
2082 |
|
---|
2083 |
|
---|
2084 | function render(date, delta) {
|
---|
2085 |
|
---|
2086 | if (delta) {
|
---|
2087 | addDays(date, delta);
|
---|
2088 | }
|
---|
2089 | skipHiddenDays(date, delta < 0 ? -1 : 1);
|
---|
2090 |
|
---|
2091 | var start = cloneDate(date, true);
|
---|
2092 | var end = addDays(cloneDate(start), 1);
|
---|
2093 |
|
---|
2094 | t.title = formatDate(date, opt('titleFormat'));
|
---|
2095 |
|
---|
2096 | t.start = t.visStart = start;
|
---|
2097 | t.end = t.visEnd = end;
|
---|
2098 |
|
---|
2099 | renderBasic(1, 1, false);
|
---|
2100 | }
|
---|
2101 |
|
---|
2102 |
|
---|
2103 | }
|
---|
2104 |
|
---|
2105 | ;;
|
---|
2106 |
|
---|
2107 | setDefaults({
|
---|
2108 | weekMode: 'fixed'
|
---|
2109 | });
|
---|
2110 |
|
---|
2111 |
|
---|
2112 | function BasicView(element, calendar, viewName) {
|
---|
2113 | var t = this;
|
---|
2114 |
|
---|
2115 |
|
---|
2116 | // exports
|
---|
2117 | t.renderBasic = renderBasic;
|
---|
2118 | t.setHeight = setHeight;
|
---|
2119 | t.setWidth = setWidth;
|
---|
2120 | t.renderDayOverlay = renderDayOverlay;
|
---|
2121 | t.defaultSelectionEnd = defaultSelectionEnd;
|
---|
2122 | t.renderSelection = renderSelection;
|
---|
2123 | t.clearSelection = clearSelection;
|
---|
2124 | t.reportDayClick = reportDayClick; // for selection (kinda hacky)
|
---|
2125 | t.dragStart = dragStart;
|
---|
2126 | t.dragStop = dragStop;
|
---|
2127 | t.defaultEventEnd = defaultEventEnd;
|
---|
2128 | t.getHoverListener = function() { return hoverListener };
|
---|
2129 | t.colLeft = colLeft;
|
---|
2130 | t.colRight = colRight;
|
---|
2131 | t.colContentLeft = colContentLeft;
|
---|
2132 | t.colContentRight = colContentRight;
|
---|
2133 | t.getIsCellAllDay = function() { return true };
|
---|
2134 | t.allDayRow = allDayRow;
|
---|
2135 | t.getRowCnt = function() { return rowCnt };
|
---|
2136 | t.getColCnt = function() { return colCnt };
|
---|
2137 | t.getColWidth = function() { return colWidth };
|
---|
2138 | t.getDaySegmentContainer = function() { return daySegmentContainer };
|
---|
2139 |
|
---|
2140 |
|
---|
2141 | // imports
|
---|
2142 | View.call(t, element, calendar, viewName);
|
---|
2143 | OverlayManager.call(t);
|
---|
2144 | SelectionManager.call(t);
|
---|
2145 | BasicEventRenderer.call(t);
|
---|
2146 | var opt = t.opt;
|
---|
2147 | var trigger = t.trigger;
|
---|
2148 | var renderOverlay = t.renderOverlay;
|
---|
2149 | var clearOverlays = t.clearOverlays;
|
---|
2150 | var daySelectionMousedown = t.daySelectionMousedown;
|
---|
2151 | var cellToDate = t.cellToDate;
|
---|
2152 | var dateToCell = t.dateToCell;
|
---|
2153 | var rangeToSegments = t.rangeToSegments;
|
---|
2154 | var formatDate = calendar.formatDate;
|
---|
2155 |
|
---|
2156 |
|
---|
2157 | // locals
|
---|
2158 |
|
---|
2159 | var table;
|
---|
2160 | var head;
|
---|
2161 | var headCells;
|
---|
2162 | var body;
|
---|
2163 | var bodyRows;
|
---|
2164 | var bodyCells;
|
---|
2165 | var bodyFirstCells;
|
---|
2166 | var firstRowCellInners;
|
---|
2167 | var firstRowCellContentInners;
|
---|
2168 | var daySegmentContainer;
|
---|
2169 |
|
---|
2170 | var viewWidth;
|
---|
2171 | var viewHeight;
|
---|
2172 | var colWidth;
|
---|
2173 | var weekNumberWidth;
|
---|
2174 |
|
---|
2175 | var rowCnt, colCnt;
|
---|
2176 | var showNumbers;
|
---|
2177 | var coordinateGrid;
|
---|
2178 | var hoverListener;
|
---|
2179 | var colPositions;
|
---|
2180 | var colContentPositions;
|
---|
2181 |
|
---|
2182 | var tm;
|
---|
2183 | var colFormat;
|
---|
2184 | var showWeekNumbers;
|
---|
2185 | var weekNumberTitle;
|
---|
2186 | var weekNumberFormat;
|
---|
2187 |
|
---|
2188 |
|
---|
2189 |
|
---|
2190 | /* Rendering
|
---|
2191 | ------------------------------------------------------------*/
|
---|
2192 |
|
---|
2193 |
|
---|
2194 | disableTextSelection(element.addClass('fc-grid'));
|
---|
2195 |
|
---|
2196 |
|
---|
2197 | function renderBasic(_rowCnt, _colCnt, _showNumbers) {
|
---|
2198 | rowCnt = _rowCnt;
|
---|
2199 | colCnt = _colCnt;
|
---|
2200 | showNumbers = _showNumbers;
|
---|
2201 | updateOptions();
|
---|
2202 |
|
---|
2203 | if (!body) {
|
---|
2204 | buildEventContainer();
|
---|
2205 | }
|
---|
2206 |
|
---|
2207 | buildTable();
|
---|
2208 | }
|
---|
2209 |
|
---|
2210 |
|
---|
2211 | function updateOptions() {
|
---|
2212 | tm = opt('theme') ? 'ui' : 'fc';
|
---|
2213 | colFormat = opt('columnFormat');
|
---|
2214 |
|
---|
2215 | // week # options. (TODO: bad, logic also in other views)
|
---|
2216 | showWeekNumbers = opt('weekNumbers');
|
---|
2217 | weekNumberTitle = opt('weekNumberTitle');
|
---|
2218 | if (opt('weekNumberCalculation') != 'iso') {
|
---|
2219 | weekNumberFormat = "w";
|
---|
2220 | }
|
---|
2221 | else {
|
---|
2222 | weekNumberFormat = "W";
|
---|
2223 | }
|
---|
2224 | }
|
---|
2225 |
|
---|
2226 |
|
---|
2227 | function buildEventContainer() {
|
---|
2228 | daySegmentContainer =
|
---|
2229 | $("<div class='fc-event-container' style='position:absolute;z-index:8;top:0;left:0'/>")
|
---|
2230 | .appendTo(element);
|
---|
2231 | }
|
---|
2232 |
|
---|
2233 |
|
---|
2234 | function buildTable() {
|
---|
2235 | var html = buildTableHTML();
|
---|
2236 |
|
---|
2237 | if (table) {
|
---|
2238 | table.remove();
|
---|
2239 | }
|
---|
2240 | table = $(html).appendTo(element);
|
---|
2241 |
|
---|
2242 | head = table.find('thead');
|
---|
2243 | headCells = head.find('.fc-day-header');
|
---|
2244 | body = table.find('tbody');
|
---|
2245 | bodyRows = body.find('tr');
|
---|
2246 | bodyCells = body.find('.fc-day');
|
---|
2247 | bodyFirstCells = bodyRows.find('td:first-child');
|
---|
2248 |
|
---|
2249 | firstRowCellInners = bodyRows.eq(0).find('.fc-day > div');
|
---|
2250 | firstRowCellContentInners = bodyRows.eq(0).find('.fc-day-content > div');
|
---|
2251 |
|
---|
2252 | markFirstLast(head.add(head.find('tr'))); // marks first+last tr/th's
|
---|
2253 | markFirstLast(bodyRows); // marks first+last td's
|
---|
2254 | bodyRows.eq(0).addClass('fc-first');
|
---|
2255 | bodyRows.filter(':last').addClass('fc-last');
|
---|
2256 |
|
---|
2257 | bodyCells.each(function(i, _cell) {
|
---|
2258 | var date = cellToDate(
|
---|
2259 | Math.floor(i / colCnt),
|
---|
2260 | i % colCnt
|
---|
2261 | );
|
---|
2262 | trigger('dayRender', t, date, $(_cell));
|
---|
2263 | });
|
---|
2264 |
|
---|
2265 | dayBind(bodyCells);
|
---|
2266 | }
|
---|
2267 |
|
---|
2268 |
|
---|
2269 |
|
---|
2270 | /* HTML Building
|
---|
2271 | -----------------------------------------------------------*/
|
---|
2272 |
|
---|
2273 |
|
---|
2274 | function buildTableHTML() {
|
---|
2275 | var html =
|
---|
2276 | "<table class='fc-border-separate' style='width:100%' cellspacing='0'>" +
|
---|
2277 | buildHeadHTML() +
|
---|
2278 | buildBodyHTML() +
|
---|
2279 | "</table>";
|
---|
2280 |
|
---|
2281 | return html;
|
---|
2282 | }
|
---|
2283 |
|
---|
2284 |
|
---|
2285 | function buildHeadHTML() {
|
---|
2286 | var headerClass = tm + "-widget-header";
|
---|
2287 | var html = '';
|
---|
2288 | var col;
|
---|
2289 | var date;
|
---|
2290 |
|
---|
2291 | html += "<thead><tr>";
|
---|
2292 |
|
---|
2293 | if (showWeekNumbers) {
|
---|
2294 | html +=
|
---|
2295 | "<th class='fc-week-number " + headerClass + "'>" +
|
---|
2296 | htmlEscape(weekNumberTitle) +
|
---|
2297 | "</th>";
|
---|
2298 | }
|
---|
2299 |
|
---|
2300 | for (col=0; col<colCnt; col++) {
|
---|
2301 | date = cellToDate(0, col);
|
---|
2302 | html +=
|
---|
2303 | "<th class='fc-day-header fc-" + dayIDs[date.getDay()] + " " + headerClass + "'>" +
|
---|
2304 | htmlEscape(formatDate(date, colFormat)) +
|
---|
2305 | "</th>";
|
---|
2306 | }
|
---|
2307 |
|
---|
2308 | html += "</tr></thead>";
|
---|
2309 |
|
---|
2310 | return html;
|
---|
2311 | }
|
---|
2312 |
|
---|
2313 |
|
---|
2314 | function buildBodyHTML() {
|
---|
2315 | var contentClass = tm + "-widget-content";
|
---|
2316 | var html = '';
|
---|
2317 | var row;
|
---|
2318 | var col;
|
---|
2319 | var date;
|
---|
2320 |
|
---|
2321 | html += "<tbody>";
|
---|
2322 |
|
---|
2323 | for (row=0; row<rowCnt; row++) {
|
---|
2324 |
|
---|
2325 | html += "<tr class='fc-week'>";
|
---|
2326 |
|
---|
2327 | if (showWeekNumbers) {
|
---|
2328 | date = cellToDate(row, 0);
|
---|
2329 | html +=
|
---|
2330 | "<td class='fc-week-number " + contentClass + "'>" +
|
---|
2331 | "<div>" +
|
---|
2332 | htmlEscape(formatDate(date, weekNumberFormat)) +
|
---|
2333 | "</div>" +
|
---|
2334 | "</td>";
|
---|
2335 | }
|
---|
2336 |
|
---|
2337 | for (col=0; col<colCnt; col++) {
|
---|
2338 | date = cellToDate(row, col);
|
---|
2339 | html += buildCellHTML(date);
|
---|
2340 | }
|
---|
2341 |
|
---|
2342 | html += "</tr>";
|
---|
2343 | }
|
---|
2344 |
|
---|
2345 | html += "</tbody>";
|
---|
2346 |
|
---|
2347 | return html;
|
---|
2348 | }
|
---|
2349 |
|
---|
2350 |
|
---|
2351 | function buildCellHTML(date) {
|
---|
2352 | var contentClass = tm + "-widget-content";
|
---|
2353 | var month = t.start.getMonth();
|
---|
2354 | var today = clearTime(new Date());
|
---|
2355 | var html = '';
|
---|
2356 | var classNames = [
|
---|
2357 | 'fc-day',
|
---|
2358 | 'fc-' + dayIDs[date.getDay()],
|
---|
2359 | contentClass
|
---|
2360 | ];
|
---|
2361 |
|
---|
2362 | if (date.getMonth() != month) {
|
---|
2363 | classNames.push('fc-other-month');
|
---|
2364 | }
|
---|
2365 | if (+date == +today) {
|
---|
2366 | classNames.push(
|
---|
2367 | 'fc-today',
|
---|
2368 | tm + '-state-highlight'
|
---|
2369 | );
|
---|
2370 | }
|
---|
2371 | else if (date < today) {
|
---|
2372 | classNames.push('fc-past');
|
---|
2373 | }
|
---|
2374 | else {
|
---|
2375 | classNames.push('fc-future');
|
---|
2376 | }
|
---|
2377 |
|
---|
2378 | html +=
|
---|
2379 | "<td" +
|
---|
2380 | " class='" + classNames.join(' ') + "'" +
|
---|
2381 | " data-date='" + formatDate(date, 'yyyy-MM-dd') + "'" +
|
---|
2382 | ">" +
|
---|
2383 | "<div>";
|
---|
2384 |
|
---|
2385 | if (showNumbers) {
|
---|
2386 | html += "<div class='fc-day-number'>" + date.getDate() + "</div>";
|
---|
2387 | }
|
---|
2388 |
|
---|
2389 | html +=
|
---|
2390 | "<div class='fc-day-content'>" +
|
---|
2391 | "<div style='position:relative'> </div>" +
|
---|
2392 | "</div>" +
|
---|
2393 | "</div>" +
|
---|
2394 | "</td>";
|
---|
2395 |
|
---|
2396 | return html;
|
---|
2397 | }
|
---|
2398 |
|
---|
2399 |
|
---|
2400 |
|
---|
2401 | /* Dimensions
|
---|
2402 | -----------------------------------------------------------*/
|
---|
2403 |
|
---|
2404 |
|
---|
2405 | function setHeight(height) {
|
---|
2406 | viewHeight = height;
|
---|
2407 |
|
---|
2408 | var bodyHeight = viewHeight - head.height();
|
---|
2409 | var rowHeight;
|
---|
2410 | var rowHeightLast;
|
---|
2411 | var cell;
|
---|
2412 |
|
---|
2413 | if (opt('weekMode') == 'variable') {
|
---|
2414 | rowHeight = rowHeightLast = Math.floor(bodyHeight / (rowCnt==1 ? 2 : 6));
|
---|
2415 | }else{
|
---|
2416 | rowHeight = Math.floor(bodyHeight / rowCnt);
|
---|
2417 | rowHeightLast = bodyHeight - rowHeight * (rowCnt-1);
|
---|
2418 | }
|
---|
2419 |
|
---|
2420 | bodyFirstCells.each(function(i, _cell) {
|
---|
2421 | if (i < rowCnt) {
|
---|
2422 | cell = $(_cell);
|
---|
2423 | cell.find('> div').css(
|
---|
2424 | 'min-height',
|
---|
2425 | (i==rowCnt-1 ? rowHeightLast : rowHeight) - vsides(cell)
|
---|
2426 | );
|
---|
2427 | }
|
---|
2428 | });
|
---|
2429 |
|
---|
2430 | }
|
---|
2431 |
|
---|
2432 |
|
---|
2433 | function setWidth(width) {
|
---|
2434 | viewWidth = width;
|
---|
2435 | colPositions.clear();
|
---|
2436 | colContentPositions.clear();
|
---|
2437 |
|
---|
2438 | weekNumberWidth = 0;
|
---|
2439 | if (showWeekNumbers) {
|
---|
2440 | weekNumberWidth = head.find('th.fc-week-number').outerWidth();
|
---|
2441 | }
|
---|
2442 |
|
---|
2443 | colWidth = Math.floor((viewWidth - weekNumberWidth) / colCnt);
|
---|
2444 | setOuterWidth(headCells.slice(0, -1), colWidth);
|
---|
2445 | }
|
---|
2446 |
|
---|
2447 |
|
---|
2448 |
|
---|
2449 | /* Day clicking and binding
|
---|
2450 | -----------------------------------------------------------*/
|
---|
2451 |
|
---|
2452 |
|
---|
2453 | function dayBind(days) {
|
---|
2454 | days.click(dayClick)
|
---|
2455 | .mousedown(daySelectionMousedown);
|
---|
2456 | }
|
---|
2457 |
|
---|
2458 |
|
---|
2459 | function dayClick(ev) {
|
---|
2460 | if (!opt('selectable')) { // if selectable, SelectionManager will worry about dayClick
|
---|
2461 | var date = parseISO8601($(this).data('date'));
|
---|
2462 | trigger('dayClick', this, date, true, ev);
|
---|
2463 | }
|
---|
2464 | }
|
---|
2465 |
|
---|
2466 |
|
---|
2467 |
|
---|
2468 | /* Semi-transparent Overlay Helpers
|
---|
2469 | ------------------------------------------------------*/
|
---|
2470 | // TODO: should be consolidated with AgendaView's methods
|
---|
2471 |
|
---|
2472 |
|
---|
2473 | function renderDayOverlay(overlayStart, overlayEnd, refreshCoordinateGrid) { // overlayEnd is exclusive
|
---|
2474 |
|
---|
2475 | if (refreshCoordinateGrid) {
|
---|
2476 | coordinateGrid.build();
|
---|
2477 | }
|
---|
2478 |
|
---|
2479 | var segments = rangeToSegments(overlayStart, overlayEnd);
|
---|
2480 |
|
---|
2481 | for (var i=0; i<segments.length; i++) {
|
---|
2482 | var segment = segments[i];
|
---|
2483 | dayBind(
|
---|
2484 | renderCellOverlay(
|
---|
2485 | segment.row,
|
---|
2486 | segment.leftCol,
|
---|
2487 | segment.row,
|
---|
2488 | segment.rightCol
|
---|
2489 | )
|
---|
2490 | );
|
---|
2491 | }
|
---|
2492 | }
|
---|
2493 |
|
---|
2494 |
|
---|
2495 | function renderCellOverlay(row0, col0, row1, col1) { // row1,col1 is inclusive
|
---|
2496 | var rect = coordinateGrid.rect(row0, col0, row1, col1, element);
|
---|
2497 | return renderOverlay(rect, element);
|
---|
2498 | }
|
---|
2499 |
|
---|
2500 |
|
---|
2501 |
|
---|
2502 | /* Selection
|
---|
2503 | -----------------------------------------------------------------------*/
|
---|
2504 |
|
---|
2505 |
|
---|
2506 | function defaultSelectionEnd(startDate, allDay) {
|
---|
2507 | return cloneDate(startDate);
|
---|
2508 | }
|
---|
2509 |
|
---|
2510 |
|
---|
2511 | function renderSelection(startDate, endDate, allDay) {
|
---|
2512 | renderDayOverlay(startDate, addDays(cloneDate(endDate), 1), true); // rebuild every time???
|
---|
2513 | }
|
---|
2514 |
|
---|
2515 |
|
---|
2516 | function clearSelection() {
|
---|
2517 | clearOverlays();
|
---|
2518 | }
|
---|
2519 |
|
---|
2520 |
|
---|
2521 | function reportDayClick(date, allDay, ev) {
|
---|
2522 | var cell = dateToCell(date);
|
---|
2523 | var _element = bodyCells[cell.row*colCnt + cell.col];
|
---|
2524 | trigger('dayClick', _element, date, allDay, ev);
|
---|
2525 | }
|
---|
2526 |
|
---|
2527 |
|
---|
2528 |
|
---|
2529 | /* External Dragging
|
---|
2530 | -----------------------------------------------------------------------*/
|
---|
2531 |
|
---|
2532 |
|
---|
2533 | function dragStart(_dragElement, ev, ui) {
|
---|
2534 | hoverListener.start(function(cell) {
|
---|
2535 | clearOverlays();
|
---|
2536 | if (cell) {
|
---|
2537 | renderCellOverlay(cell.row, cell.col, cell.row, cell.col);
|
---|
2538 | }
|
---|
2539 | }, ev);
|
---|
2540 | }
|
---|
2541 |
|
---|
2542 |
|
---|
2543 | function dragStop(_dragElement, ev, ui) {
|
---|
2544 | var cell = hoverListener.stop();
|
---|
2545 | clearOverlays();
|
---|
2546 | if (cell) {
|
---|
2547 | var d = cellToDate(cell);
|
---|
2548 | trigger('drop', _dragElement, d, true, ev, ui);
|
---|
2549 | }
|
---|
2550 | }
|
---|
2551 |
|
---|
2552 |
|
---|
2553 |
|
---|
2554 | /* Utilities
|
---|
2555 | --------------------------------------------------------*/
|
---|
2556 |
|
---|
2557 |
|
---|
2558 | function defaultEventEnd(event) {
|
---|
2559 | return cloneDate(event.start);
|
---|
2560 | }
|
---|
2561 |
|
---|
2562 |
|
---|
2563 | coordinateGrid = new CoordinateGrid(function(rows, cols) {
|
---|
2564 | var e, n, p;
|
---|
2565 | headCells.each(function(i, _e) {
|
---|
2566 | e = $(_e);
|
---|
2567 | n = e.offset().left;
|
---|
2568 | if (i) {
|
---|
2569 | p[1] = n;
|
---|
2570 | }
|
---|
2571 | p = [n];
|
---|
2572 | cols[i] = p;
|
---|
2573 | });
|
---|
2574 | p[1] = n + e.outerWidth();
|
---|
2575 | bodyRows.each(function(i, _e) {
|
---|
2576 | if (i < rowCnt) {
|
---|
2577 | e = $(_e);
|
---|
2578 | n = e.offset().top;
|
---|
2579 | if (i) {
|
---|
2580 | p[1] = n;
|
---|
2581 | }
|
---|
2582 | p = [n];
|
---|
2583 | rows[i] = p;
|
---|
2584 | }
|
---|
2585 | });
|
---|
2586 | p[1] = n + e.outerHeight();
|
---|
2587 | });
|
---|
2588 |
|
---|
2589 |
|
---|
2590 | hoverListener = new HoverListener(coordinateGrid);
|
---|
2591 |
|
---|
2592 | colPositions = new HorizontalPositionCache(function(col) {
|
---|
2593 | return firstRowCellInners.eq(col);
|
---|
2594 | });
|
---|
2595 |
|
---|
2596 | colContentPositions = new HorizontalPositionCache(function(col) {
|
---|
2597 | return firstRowCellContentInners.eq(col);
|
---|
2598 | });
|
---|
2599 |
|
---|
2600 |
|
---|
2601 | function colLeft(col) {
|
---|
2602 | return colPositions.left(col);
|
---|
2603 | }
|
---|
2604 |
|
---|
2605 |
|
---|
2606 | function colRight(col) {
|
---|
2607 | return colPositions.right(col);
|
---|
2608 | }
|
---|
2609 |
|
---|
2610 |
|
---|
2611 | function colContentLeft(col) {
|
---|
2612 | return colContentPositions.left(col);
|
---|
2613 | }
|
---|
2614 |
|
---|
2615 |
|
---|
2616 | function colContentRight(col) {
|
---|
2617 | return colContentPositions.right(col);
|
---|
2618 | }
|
---|
2619 |
|
---|
2620 |
|
---|
2621 | function allDayRow(i) {
|
---|
2622 | return bodyRows.eq(i);
|
---|
2623 | }
|
---|
2624 |
|
---|
2625 | }
|
---|
2626 |
|
---|
2627 | ;;
|
---|
2628 |
|
---|
2629 | function BasicEventRenderer() {
|
---|
2630 | var t = this;
|
---|
2631 |
|
---|
2632 |
|
---|
2633 | // exports
|
---|
2634 | t.renderEvents = renderEvents;
|
---|
2635 | t.clearEvents = clearEvents;
|
---|
2636 |
|
---|
2637 |
|
---|
2638 | // imports
|
---|
2639 | DayEventRenderer.call(t);
|
---|
2640 |
|
---|
2641 |
|
---|
2642 | function renderEvents(events, modifiedEventId) {
|
---|
2643 | t.renderDayEvents(events, modifiedEventId);
|
---|
2644 | }
|
---|
2645 |
|
---|
2646 |
|
---|
2647 | function clearEvents() {
|
---|
2648 | t.getDaySegmentContainer().empty();
|
---|
2649 | }
|
---|
2650 |
|
---|
2651 |
|
---|
2652 | // TODO: have this class (and AgendaEventRenderer) be responsible for creating the event container div
|
---|
2653 |
|
---|
2654 | }
|
---|
2655 |
|
---|
2656 | ;;
|
---|
2657 |
|
---|
2658 | fcViews.agendaWeek = AgendaWeekView;
|
---|
2659 |
|
---|
2660 | function AgendaWeekView(element, calendar) {
|
---|
2661 | var t = this;
|
---|
2662 |
|
---|
2663 |
|
---|
2664 | // exports
|
---|
2665 | t.render = render;
|
---|
2666 |
|
---|
2667 |
|
---|
2668 | // imports
|
---|
2669 | AgendaView.call(t, element, calendar, 'agendaWeek');
|
---|
2670 | var opt = t.opt;
|
---|
2671 | var renderAgenda = t.renderAgenda;
|
---|
2672 | var skipHiddenDays = t.skipHiddenDays;
|
---|
2673 | var getCellsPerWeek = t.getCellsPerWeek;
|
---|
2674 | var formatDates = calendar.formatDates;
|
---|
2675 |
|
---|
2676 |
|
---|
2677 | function render(date, delta) {
|
---|
2678 |
|
---|
2679 | if (delta) {
|
---|
2680 | addDays(date, delta * 7);
|
---|
2681 | }
|
---|
2682 |
|
---|
2683 | var start = addDays(cloneDate(date), -((date.getDay() - opt('firstDay') + 7) % 7));
|
---|
2684 | var end = addDays(cloneDate(start), 7);
|
---|
2685 |
|
---|
2686 | var visStart = cloneDate(start);
|
---|
2687 | skipHiddenDays(visStart);
|
---|
2688 |
|
---|
2689 | var visEnd = cloneDate(end);
|
---|
2690 | skipHiddenDays(visEnd, -1, true);
|
---|
2691 |
|
---|
2692 | var colCnt = getCellsPerWeek();
|
---|
2693 |
|
---|
2694 | t.title = formatDates(
|
---|
2695 | visStart,
|
---|
2696 | addDays(cloneDate(visEnd), -1),
|
---|
2697 | opt('titleFormat')
|
---|
2698 | );
|
---|
2699 |
|
---|
2700 | t.start = start;
|
---|
2701 | t.end = end;
|
---|
2702 | t.visStart = visStart;
|
---|
2703 | t.visEnd = visEnd;
|
---|
2704 |
|
---|
2705 | renderAgenda(colCnt);
|
---|
2706 | }
|
---|
2707 |
|
---|
2708 | }
|
---|
2709 |
|
---|
2710 | ;;
|
---|
2711 |
|
---|
2712 | fcViews.agendaDay = AgendaDayView;
|
---|
2713 |
|
---|
2714 |
|
---|
2715 | function AgendaDayView(element, calendar) {
|
---|
2716 | var t = this;
|
---|
2717 |
|
---|
2718 |
|
---|
2719 | // exports
|
---|
2720 | t.render = render;
|
---|
2721 |
|
---|
2722 |
|
---|
2723 | // imports
|
---|
2724 | AgendaView.call(t, element, calendar, 'agendaDay');
|
---|
2725 | var opt = t.opt;
|
---|
2726 | var renderAgenda = t.renderAgenda;
|
---|
2727 | var skipHiddenDays = t.skipHiddenDays;
|
---|
2728 | var formatDate = calendar.formatDate;
|
---|
2729 |
|
---|
2730 |
|
---|
2731 | function render(date, delta) {
|
---|
2732 |
|
---|
2733 | if (delta) {
|
---|
2734 | addDays(date, delta);
|
---|
2735 | }
|
---|
2736 | skipHiddenDays(date, delta < 0 ? -1 : 1);
|
---|
2737 |
|
---|
2738 | var start = cloneDate(date, true);
|
---|
2739 | var end = addDays(cloneDate(start), 1);
|
---|
2740 |
|
---|
2741 | t.title = formatDate(date, opt('titleFormat'));
|
---|
2742 |
|
---|
2743 | t.start = t.visStart = start;
|
---|
2744 | t.end = t.visEnd = end;
|
---|
2745 |
|
---|
2746 | renderAgenda(1);
|
---|
2747 | }
|
---|
2748 |
|
---|
2749 |
|
---|
2750 | }
|
---|
2751 |
|
---|
2752 | ;;
|
---|
2753 |
|
---|
2754 | setDefaults({
|
---|
2755 | allDaySlot: true,
|
---|
2756 | allDayText: 'all-day',
|
---|
2757 | firstHour: 8,
|
---|
2758 | lastHour: 10,
|
---|
2759 | slotMinutes: 30,
|
---|
2760 | defaultEventMinutes: 120,
|
---|
2761 | axisFormat: 'h(:mm)tt',
|
---|
2762 | timeFormat: {
|
---|
2763 | agenda: 'h:mm{ - h:mm}'
|
---|
2764 | },
|
---|
2765 | dragOpacity: {
|
---|
2766 | agenda: .5
|
---|
2767 | },
|
---|
2768 | minTime: 0,
|
---|
2769 | maxTime: 24,
|
---|
2770 | slotEventOverlap: false
|
---|
2771 | });
|
---|
2772 |
|
---|
2773 |
|
---|
2774 | // TODO: make it work in quirks mode (event corners, all-day height)
|
---|
2775 | // TODO: test liquid width, especially in IE6
|
---|
2776 |
|
---|
2777 |
|
---|
2778 | function AgendaView(element, calendar, viewName) {
|
---|
2779 | var t = this;
|
---|
2780 |
|
---|
2781 |
|
---|
2782 | // exports
|
---|
2783 | t.renderAgenda = renderAgenda;
|
---|
2784 | t.setWidth = setWidth;
|
---|
2785 | t.setHeight = setHeight;
|
---|
2786 | t.afterRender = afterRender;
|
---|
2787 | t.defaultEventEnd = defaultEventEnd;
|
---|
2788 | t.timePosition = timePosition;
|
---|
2789 | t.getIsCellAllDay = getIsCellAllDay;
|
---|
2790 | t.allDayRow = getAllDayRow;
|
---|
2791 | t.getCoordinateGrid = function() { return coordinateGrid }; // specifically for AgendaEventRenderer
|
---|
2792 | t.getHoverListener = function() { return hoverListener };
|
---|
2793 | t.colLeft = colLeft;
|
---|
2794 | t.colRight = colRight;
|
---|
2795 | t.colContentLeft = colContentLeft;
|
---|
2796 | t.colContentRight = colContentRight;
|
---|
2797 | t.getDaySegmentContainer = function() { return daySegmentContainer };
|
---|
2798 | t.getSlotSegmentContainer = function() { return slotSegmentContainer };
|
---|
2799 | t.getMinMinute = function() { return minMinute };
|
---|
2800 | t.getMaxMinute = function() { return maxMinute };
|
---|
2801 | t.getSlotContainer = function() { return slotContainer };
|
---|
2802 | t.getRowCnt = function() { return 1 };
|
---|
2803 | t.getColCnt = function() { return colCnt };
|
---|
2804 | t.getColWidth = function() { return colWidth };
|
---|
2805 | t.getSnapHeight = function() { return snapHeight };
|
---|
2806 | t.getSnapMinutes = function() { return snapMinutes };
|
---|
2807 | t.defaultSelectionEnd = defaultSelectionEnd;
|
---|
2808 | t.renderDayOverlay = renderDayOverlay;
|
---|
2809 | t.renderSelection = renderSelection;
|
---|
2810 | t.clearSelection = clearSelection;
|
---|
2811 | t.reportDayClick = reportDayClick; // selection mousedown hack
|
---|
2812 | t.dragStart = dragStart;
|
---|
2813 | t.dragStop = dragStop;
|
---|
2814 |
|
---|
2815 |
|
---|
2816 | // imports
|
---|
2817 | View.call(t, element, calendar, viewName);
|
---|
2818 | OverlayManager.call(t);
|
---|
2819 | SelectionManager.call(t);
|
---|
2820 | AgendaEventRenderer.call(t);
|
---|
2821 | var opt = t.opt;
|
---|
2822 | var trigger = t.trigger;
|
---|
2823 | var renderOverlay = t.renderOverlay;
|
---|
2824 | var clearOverlays = t.clearOverlays;
|
---|
2825 | var reportSelection = t.reportSelection;
|
---|
2826 | var unselect = t.unselect;
|
---|
2827 | var daySelectionMousedown = t.daySelectionMousedown;
|
---|
2828 | var slotSegHtml = t.slotSegHtml;
|
---|
2829 | var cellToDate = t.cellToDate;
|
---|
2830 | var dateToCell = t.dateToCell;
|
---|
2831 | var rangeToSegments = t.rangeToSegments;
|
---|
2832 | var formatDate = calendar.formatDate;
|
---|
2833 |
|
---|
2834 |
|
---|
2835 | // locals
|
---|
2836 |
|
---|
2837 | var dayTable;
|
---|
2838 | var dayHead;
|
---|
2839 | var dayHeadCells;
|
---|
2840 | var dayBody;
|
---|
2841 | var dayBodyCells;
|
---|
2842 | var dayBodyCellInners;
|
---|
2843 | var dayBodyCellContentInners;
|
---|
2844 | var dayBodyFirstCell;
|
---|
2845 | var dayBodyFirstCellStretcher;
|
---|
2846 | var slotLayer;
|
---|
2847 | var daySegmentContainer;
|
---|
2848 | var allDayTable;
|
---|
2849 | var allDayRow;
|
---|
2850 | var slotScroller;
|
---|
2851 | var slotContainer;
|
---|
2852 | var slotSegmentContainer;
|
---|
2853 | var slotTable;
|
---|
2854 | var selectionHelper;
|
---|
2855 |
|
---|
2856 | var viewWidth;
|
---|
2857 | var viewHeight;
|
---|
2858 | var axisWidth;
|
---|
2859 | var colWidth;
|
---|
2860 | var gutterWidth;
|
---|
2861 | var slotHeight; // TODO: what if slotHeight changes? (see issue 650)
|
---|
2862 |
|
---|
2863 | var snapMinutes;
|
---|
2864 | var snapRatio; // ratio of number of "selection" slots to normal slots. (ex: 1, 2, 4)
|
---|
2865 | var snapHeight; // holds the pixel hight of a "selection" slot
|
---|
2866 |
|
---|
2867 | var colCnt;
|
---|
2868 | var slotCnt;
|
---|
2869 | var coordinateGrid;
|
---|
2870 | var hoverListener;
|
---|
2871 | var colPositions;
|
---|
2872 | var colContentPositions;
|
---|
2873 | var slotTopCache = {};
|
---|
2874 |
|
---|
2875 | var tm;
|
---|
2876 | var rtl;
|
---|
2877 | var minMinute, maxMinute;
|
---|
2878 | var colFormat;
|
---|
2879 | var showWeekNumbers;
|
---|
2880 | var weekNumberTitle;
|
---|
2881 | var weekNumberFormat;
|
---|
2882 |
|
---|
2883 |
|
---|
2884 |
|
---|
2885 | /* Rendering
|
---|
2886 | -----------------------------------------------------------------------------*/
|
---|
2887 |
|
---|
2888 |
|
---|
2889 | disableTextSelection(element.addClass('fc-agenda'));
|
---|
2890 |
|
---|
2891 |
|
---|
2892 | function renderAgenda(c) {
|
---|
2893 | colCnt = c;
|
---|
2894 | updateOptions();
|
---|
2895 |
|
---|
2896 | if (!dayTable) { // first time rendering?
|
---|
2897 | buildSkeleton(); // builds day table, slot area, events containers
|
---|
2898 | }
|
---|
2899 | else {
|
---|
2900 | buildDayTable(); // rebuilds day table
|
---|
2901 | }
|
---|
2902 | }
|
---|
2903 |
|
---|
2904 |
|
---|
2905 | function updateOptions() {
|
---|
2906 |
|
---|
2907 | tm = opt('theme') ? 'ui' : 'fc';
|
---|
2908 | rtl = opt('isRTL')
|
---|
2909 | minMinute = parseTime(opt('minTime'));
|
---|
2910 | maxMinute = parseTime(opt('maxTime'));
|
---|
2911 | colFormat = opt('columnFormat');
|
---|
2912 |
|
---|
2913 | // week # options. (TODO: bad, logic also in other views)
|
---|
2914 | showWeekNumbers = opt('weekNumbers');
|
---|
2915 | weekNumberTitle = opt('weekNumberTitle');
|
---|
2916 | if (opt('weekNumberCalculation') != 'iso') {
|
---|
2917 | weekNumberFormat = "w";
|
---|
2918 | }
|
---|
2919 | else {
|
---|
2920 | weekNumberFormat = "W";
|
---|
2921 | }
|
---|
2922 |
|
---|
2923 | snapMinutes = opt('snapMinutes') || opt('slotMinutes');
|
---|
2924 | }
|
---|
2925 |
|
---|
2926 |
|
---|
2927 |
|
---|
2928 | /* Build DOM
|
---|
2929 | -----------------------------------------------------------------------*/
|
---|
2930 |
|
---|
2931 |
|
---|
2932 | function buildSkeleton() {
|
---|
2933 | var headerClass = tm + "-widget-header";
|
---|
2934 | var contentClass = tm + "-widget-content";
|
---|
2935 | var s;
|
---|
2936 | var d;
|
---|
2937 | var i;
|
---|
2938 | var maxd;
|
---|
2939 | var minutes;
|
---|
2940 | var slotNormal = opt('slotMinutes') % 15 == 0;
|
---|
2941 |
|
---|
2942 | buildDayTable();
|
---|
2943 |
|
---|
2944 | slotLayer =
|
---|
2945 | $("<div style='position:absolute;z-index:2;left:0;width:100%'/>")
|
---|
2946 | .appendTo(element);
|
---|
2947 |
|
---|
2948 | if (opt('allDaySlot')) {
|
---|
2949 |
|
---|
2950 | daySegmentContainer =
|
---|
2951 | $("<div class='fc-event-container' style='position:absolute;z-index:8;top:0;left:0'/>")
|
---|
2952 | .appendTo(slotLayer);
|
---|
2953 |
|
---|
2954 | s =
|
---|
2955 | "<table style='width:100%' class='fc-agenda-allday' cellspacing='0'>" +
|
---|
2956 | "<tr>" +
|
---|
2957 | "<th class='" + headerClass + " fc-agenda-axis'>" + opt('allDayText') + "</th>" +
|
---|
2958 | "<td>" +
|
---|
2959 | "<div class='fc-day-content'><div style='position:relative'/></div>" +
|
---|
2960 | "</td>" +
|
---|
2961 | "<th class='" + headerClass + " fc-agenda-gutter'> </th>" +
|
---|
2962 | "</tr>" +
|
---|
2963 | "</table>";
|
---|
2964 | allDayTable = $(s).appendTo(slotLayer);
|
---|
2965 | allDayRow = allDayTable.find('tr');
|
---|
2966 |
|
---|
2967 | dayBind(allDayRow.find('td'));
|
---|
2968 |
|
---|
2969 | slotLayer.append(
|
---|
2970 | "<div class='fc-agenda-divider " + headerClass + "'>" +
|
---|
2971 | "<div class='fc-agenda-divider-inner'/>" +
|
---|
2972 | "</div>"
|
---|
2973 | );
|
---|
2974 |
|
---|
2975 | }else{
|
---|
2976 |
|
---|
2977 | daySegmentContainer = $([]); // in jQuery 1.4, we can just do $()
|
---|
2978 |
|
---|
2979 | }
|
---|
2980 |
|
---|
2981 | slotScroller =
|
---|
2982 | $("<div style='position:absolute;width:100%;overflow-x:hidden;overflow-y:auto'/>")
|
---|
2983 | .appendTo(slotLayer);
|
---|
2984 |
|
---|
2985 | slotContainer =
|
---|
2986 | $("<div style='position:relative;width:100%;overflow:hidden'/>")
|
---|
2987 | .appendTo(slotScroller);
|
---|
2988 |
|
---|
2989 | slotSegmentContainer =
|
---|
2990 | $("<div class='fc-event-container' style='position:absolute;z-index:8;top:0;left:0'/>")
|
---|
2991 | .appendTo(slotContainer);
|
---|
2992 |
|
---|
2993 | s =
|
---|
2994 | "<table class='fc-agenda-slots' style='width:100%' cellspacing='0'>" +
|
---|
2995 | "<tbody>";
|
---|
2996 | d = zeroDate();
|
---|
2997 | maxd = addMinutes(cloneDate(d), maxMinute);
|
---|
2998 | addMinutes(d, minMinute);
|
---|
2999 | slotCnt = 0;
|
---|
3000 | for (i=0; d < maxd; i++) {
|
---|
3001 | minutes = d.getMinutes();
|
---|
3002 | s +=
|
---|
3003 | "<tr class='fc-slot" + i + ' ' + (!minutes ? '' : 'fc-minor') + "'>" +
|
---|
3004 | "<th class='fc-agenda-axis " + headerClass + "'>" +
|
---|
3005 | ((!slotNormal || !minutes) ? formatDate(d, opt('axisFormat')) : ' ') +
|
---|
3006 | "</th>" +
|
---|
3007 | "<td class='" + contentClass + "'>" +
|
---|
3008 | "<div style='position:relative'> </div>" +
|
---|
3009 | "</td>" +
|
---|
3010 | "</tr>";
|
---|
3011 | addMinutes(d, opt('slotMinutes'));
|
---|
3012 | slotCnt++;
|
---|
3013 | }
|
---|
3014 | s +=
|
---|
3015 | "</tbody>" +
|
---|
3016 | "</table>";
|
---|
3017 | slotTable = $(s).appendTo(slotContainer);
|
---|
3018 |
|
---|
3019 | slotBind(slotTable.find('td'));
|
---|
3020 | }
|
---|
3021 |
|
---|
3022 |
|
---|
3023 |
|
---|
3024 | /* Build Day Table
|
---|
3025 | -----------------------------------------------------------------------*/
|
---|
3026 |
|
---|
3027 |
|
---|
3028 | function buildDayTable() {
|
---|
3029 | var html = buildDayTableHTML();
|
---|
3030 |
|
---|
3031 | if (dayTable) {
|
---|
3032 | dayTable.remove();
|
---|
3033 | }
|
---|
3034 | dayTable = $(html).appendTo(element);
|
---|
3035 |
|
---|
3036 | dayHead = dayTable.find('thead');
|
---|
3037 | dayHeadCells = dayHead.find('th').slice(1, -1); // exclude gutter
|
---|
3038 | dayBody = dayTable.find('tbody');
|
---|
3039 | dayBodyCells = dayBody.find('td').slice(0, -1); // exclude gutter
|
---|
3040 | dayBodyCellInners = dayBodyCells.find('> div');
|
---|
3041 | dayBodyCellContentInners = dayBodyCells.find('.fc-day-content > div');
|
---|
3042 |
|
---|
3043 | dayBodyFirstCell = dayBodyCells.eq(0);
|
---|
3044 | dayBodyFirstCellStretcher = dayBodyCellInners.eq(0);
|
---|
3045 |
|
---|
3046 | markFirstLast(dayHead.add(dayHead.find('tr')));
|
---|
3047 | markFirstLast(dayBody.add(dayBody.find('tr')));
|
---|
3048 |
|
---|
3049 | // TODO: now that we rebuild the cells every time, we should call dayRender
|
---|
3050 | }
|
---|
3051 |
|
---|
3052 |
|
---|
3053 | function buildDayTableHTML() {
|
---|
3054 | var html =
|
---|
3055 | "<table style='width:100%' class='fc-agenda-days fc-border-separate' cellspacing='0'>" +
|
---|
3056 | buildDayTableHeadHTML() +
|
---|
3057 | buildDayTableBodyHTML() +
|
---|
3058 | "</table>";
|
---|
3059 |
|
---|
3060 | return html;
|
---|
3061 | }
|
---|
3062 |
|
---|
3063 |
|
---|
3064 | function buildDayTableHeadHTML() {
|
---|
3065 | var headerClass = tm + "-widget-header";
|
---|
3066 | var date;
|
---|
3067 | var html = '';
|
---|
3068 | var weekText;
|
---|
3069 | var col;
|
---|
3070 |
|
---|
3071 | html +=
|
---|
3072 | "<thead>" +
|
---|
3073 | "<tr>";
|
---|
3074 |
|
---|
3075 | if (showWeekNumbers) {
|
---|
3076 | date = cellToDate(0, 0);
|
---|
3077 | weekText = formatDate(date, weekNumberFormat);
|
---|
3078 | if (rtl) {
|
---|
3079 | weekText += weekNumberTitle;
|
---|
3080 | }
|
---|
3081 | else {
|
---|
3082 | weekText = weekNumberTitle + weekText;
|
---|
3083 | }
|
---|
3084 | html +=
|
---|
3085 | "<th class='fc-agenda-axis fc-week-number " + headerClass + "'>" +
|
---|
3086 | htmlEscape(weekText) +
|
---|
3087 | "</th>";
|
---|
3088 | }
|
---|
3089 | else {
|
---|
3090 | html += "<th class='fc-agenda-axis " + headerClass + "'> </th>";
|
---|
3091 | }
|
---|
3092 |
|
---|
3093 | for (col=0; col<colCnt; col++) {
|
---|
3094 | date = cellToDate(0, col);
|
---|
3095 | html +=
|
---|
3096 | "<th class='fc-" + dayIDs[date.getDay()] + " fc-col" + col + ' ' + headerClass + "'>" +
|
---|
3097 | htmlEscape(formatDate(date, colFormat)) +
|
---|
3098 | "</th>";
|
---|
3099 | }
|
---|
3100 |
|
---|
3101 | html +=
|
---|
3102 | "<th class='fc-agenda-gutter " + headerClass + "'> </th>" +
|
---|
3103 | "</tr>" +
|
---|
3104 | "</thead>";
|
---|
3105 |
|
---|
3106 | return html;
|
---|
3107 | }
|
---|
3108 |
|
---|
3109 |
|
---|
3110 | function buildDayTableBodyHTML() {
|
---|
3111 | var headerClass = tm + "-widget-header"; // TODO: make these when updateOptions() called
|
---|
3112 | var contentClass = tm + "-widget-content";
|
---|
3113 | var date;
|
---|
3114 | var today = clearTime(new Date());
|
---|
3115 | var col;
|
---|
3116 | var cellsHTML;
|
---|
3117 | var cellHTML;
|
---|
3118 | var classNames;
|
---|
3119 | var html = '';
|
---|
3120 |
|
---|
3121 | html +=
|
---|
3122 | "<tbody>" +
|
---|
3123 | "<tr>" +
|
---|
3124 | "<th class='fc-agenda-axis " + headerClass + "'> </th>";
|
---|
3125 |
|
---|
3126 | cellsHTML = '';
|
---|
3127 |
|
---|
3128 | for (col=0; col<colCnt; col++) {
|
---|
3129 |
|
---|
3130 | date = cellToDate(0, col);
|
---|
3131 |
|
---|
3132 | classNames = [
|
---|
3133 | 'fc-col' + col,
|
---|
3134 | 'fc-' + dayIDs[date.getDay()],
|
---|
3135 | contentClass
|
---|
3136 | ];
|
---|
3137 | if (+date == +today) {
|
---|
3138 | classNames.push(
|
---|
3139 | tm + '-state-highlight',
|
---|
3140 | 'fc-today'
|
---|
3141 | );
|
---|
3142 | }
|
---|
3143 | else if (date < today) {
|
---|
3144 | classNames.push('fc-past');
|
---|
3145 | }
|
---|
3146 | else {
|
---|
3147 | classNames.push('fc-future');
|
---|
3148 | }
|
---|
3149 |
|
---|
3150 | cellHTML =
|
---|
3151 | "<td class='" + classNames.join(' ') + "'>" +
|
---|
3152 | "<div>" +
|
---|
3153 | "<div class='fc-day-content'>" +
|
---|
3154 | "<div style='position:relative'> </div>" +
|
---|
3155 | "</div>" +
|
---|
3156 | "</div>" +
|
---|
3157 | "</td>";
|
---|
3158 |
|
---|
3159 | cellsHTML += cellHTML;
|
---|
3160 | }
|
---|
3161 |
|
---|
3162 | html += cellsHTML;
|
---|
3163 | html +=
|
---|
3164 | "<td class='fc-agenda-gutter " + contentClass + "'> </td>" +
|
---|
3165 | "</tr>" +
|
---|
3166 | "</tbody>";
|
---|
3167 |
|
---|
3168 | return html;
|
---|
3169 | }
|
---|
3170 |
|
---|
3171 |
|
---|
3172 | // TODO: data-date on the cells
|
---|
3173 |
|
---|
3174 |
|
---|
3175 |
|
---|
3176 | /* Dimensions
|
---|
3177 | -----------------------------------------------------------------------*/
|
---|
3178 |
|
---|
3179 |
|
---|
3180 | function setHeight(height) {
|
---|
3181 | if (height === undefined) {
|
---|
3182 | height = viewHeight;
|
---|
3183 | }
|
---|
3184 | viewHeight = height;
|
---|
3185 | slotTopCache = {};
|
---|
3186 |
|
---|
3187 | var headHeight = dayBody.position().top;
|
---|
3188 | var allDayHeight = slotScroller.position().top; // including divider
|
---|
3189 | var bodyHeight = Math.min( // total body height, including borders
|
---|
3190 | height - headHeight, // when scrollbars
|
---|
3191 | slotTable.height() + allDayHeight + 1 // when no scrollbars. +1 for bottom border
|
---|
3192 | );
|
---|
3193 |
|
---|
3194 | dayBodyFirstCellStretcher
|
---|
3195 | .height(bodyHeight - vsides(dayBodyFirstCell));
|
---|
3196 |
|
---|
3197 | slotLayer.css('top', headHeight);
|
---|
3198 |
|
---|
3199 | slotScroller.height(bodyHeight - allDayHeight - 1);
|
---|
3200 |
|
---|
3201 | // the stylesheet guarantees that the first row has no border.
|
---|
3202 | // this allows .height() to work well cross-browser.
|
---|
3203 | slotHeight = slotTable.find('tr:first').height() + 1; // +1 for bottom border
|
---|
3204 |
|
---|
3205 | snapRatio = opt('slotMinutes') / snapMinutes;
|
---|
3206 | snapHeight = slotHeight / snapRatio;
|
---|
3207 | }
|
---|
3208 |
|
---|
3209 |
|
---|
3210 | function setWidth(width) {
|
---|
3211 | viewWidth = width;
|
---|
3212 | colPositions.clear();
|
---|
3213 | colContentPositions.clear();
|
---|
3214 |
|
---|
3215 | var axisFirstCells = dayHead.find('th:first');
|
---|
3216 | if (allDayTable) {
|
---|
3217 | axisFirstCells = axisFirstCells.add(allDayTable.find('th:first'));
|
---|
3218 | }
|
---|
3219 | axisFirstCells = axisFirstCells.add(slotTable.find('th:first'));
|
---|
3220 |
|
---|
3221 | axisWidth = 0;
|
---|
3222 | setOuterWidth(
|
---|
3223 | axisFirstCells
|
---|
3224 | .width('')
|
---|
3225 | .each(function(i, _cell) {
|
---|
3226 | axisWidth = Math.max(axisWidth, $(_cell).outerWidth());
|
---|
3227 | }),
|
---|
3228 | axisWidth
|
---|
3229 | );
|
---|
3230 |
|
---|
3231 | var gutterCells = dayTable.find('.fc-agenda-gutter');
|
---|
3232 | if (allDayTable) {
|
---|
3233 | gutterCells = gutterCells.add(allDayTable.find('th.fc-agenda-gutter'));
|
---|
3234 | }
|
---|
3235 |
|
---|
3236 | var slotTableWidth = slotScroller[0].clientWidth; // needs to be done after axisWidth (for IE7)
|
---|
3237 |
|
---|
3238 | gutterWidth = slotScroller.width() - slotTableWidth;
|
---|
3239 | if (gutterWidth) {
|
---|
3240 | setOuterWidth(gutterCells, gutterWidth);
|
---|
3241 | gutterCells
|
---|
3242 | .show()
|
---|
3243 | .prev()
|
---|
3244 | .removeClass('fc-last');
|
---|
3245 | }else{
|
---|
3246 | gutterCells
|
---|
3247 | .hide()
|
---|
3248 | .prev()
|
---|
3249 | .addClass('fc-last');
|
---|
3250 | }
|
---|
3251 |
|
---|
3252 | colWidth = Math.floor((slotTableWidth - axisWidth) / colCnt);
|
---|
3253 | setOuterWidth(dayHeadCells.slice(0, -1), colWidth);
|
---|
3254 | }
|
---|
3255 |
|
---|
3256 |
|
---|
3257 |
|
---|
3258 | /* Scrolling
|
---|
3259 | -----------------------------------------------------------------------*/
|
---|
3260 |
|
---|
3261 |
|
---|
3262 | function resetScroll() {
|
---|
3263 | var d0 = zeroDate();
|
---|
3264 | var scrollDate = cloneDate(d0);
|
---|
3265 | scrollDate.setHours(opt('firstHour'));
|
---|
3266 | var top = timePosition(d0, scrollDate) + 1; // +1 for the border
|
---|
3267 | function scroll() {
|
---|
3268 | slotScroller.scrollTop(top);
|
---|
3269 | }
|
---|
3270 | scroll();
|
---|
3271 | setTimeout(scroll, 0); // overrides any previous scroll state made by the browser
|
---|
3272 | }
|
---|
3273 |
|
---|
3274 |
|
---|
3275 | function afterRender() { // after the view has been freshly rendered and sized
|
---|
3276 | resetScroll();
|
---|
3277 | }
|
---|
3278 |
|
---|
3279 |
|
---|
3280 |
|
---|
3281 | /* Slot/Day clicking and binding
|
---|
3282 | -----------------------------------------------------------------------*/
|
---|
3283 |
|
---|
3284 |
|
---|
3285 | function dayBind(cells) {
|
---|
3286 | cells.click(slotClick)
|
---|
3287 | .mousedown(daySelectionMousedown);
|
---|
3288 | }
|
---|
3289 |
|
---|
3290 |
|
---|
3291 | function slotBind(cells) {
|
---|
3292 | cells.click(slotClick)
|
---|
3293 | .mousedown(slotSelectionMousedown);
|
---|
3294 | }
|
---|
3295 |
|
---|
3296 |
|
---|
3297 | function slotClick(ev) {
|
---|
3298 | if (!opt('selectable')) { // if selectable, SelectionManager will worry about dayClick
|
---|
3299 | var col = Math.min(colCnt-1, Math.floor((ev.pageX - dayTable.offset().left - axisWidth) / colWidth));
|
---|
3300 | var date = cellToDate(0, col);
|
---|
3301 | var rowMatch = this.parentNode.className.match(/fc-slot(\d+)/); // TODO: maybe use data
|
---|
3302 | if (rowMatch) {
|
---|
3303 | var mins = parseInt(rowMatch[1]) * opt('slotMinutes');
|
---|
3304 | var hours = Math.floor(mins/60);
|
---|
3305 | date.setHours(hours);
|
---|
3306 | date.setMinutes(mins%60 + minMinute);
|
---|
3307 | trigger('dayClick', dayBodyCells[col], date, false, ev);
|
---|
3308 | }else{
|
---|
3309 | trigger('dayClick', dayBodyCells[col], date, true, ev);
|
---|
3310 | }
|
---|
3311 | }
|
---|
3312 | }
|
---|
3313 |
|
---|
3314 |
|
---|
3315 |
|
---|
3316 | /* Semi-transparent Overlay Helpers
|
---|
3317 | -----------------------------------------------------*/
|
---|
3318 | // TODO: should be consolidated with BasicView's methods
|
---|
3319 |
|
---|
3320 |
|
---|
3321 | function renderDayOverlay(overlayStart, overlayEnd, refreshCoordinateGrid) { // overlayEnd is exclusive
|
---|
3322 |
|
---|
3323 | if (refreshCoordinateGrid) {
|
---|
3324 | coordinateGrid.build();
|
---|
3325 | }
|
---|
3326 |
|
---|
3327 | var segments = rangeToSegments(overlayStart, overlayEnd);
|
---|
3328 |
|
---|
3329 | for (var i=0; i<segments.length; i++) {
|
---|
3330 | var segment = segments[i];
|
---|
3331 | dayBind(
|
---|
3332 | renderCellOverlay(
|
---|
3333 | segment.row,
|
---|
3334 | segment.leftCol,
|
---|
3335 | segment.row,
|
---|
3336 | segment.rightCol
|
---|
3337 | )
|
---|
3338 | );
|
---|
3339 | }
|
---|
3340 | }
|
---|
3341 |
|
---|
3342 |
|
---|
3343 | function renderCellOverlay(row0, col0, row1, col1) { // only for all-day?
|
---|
3344 | var rect = coordinateGrid.rect(row0, col0, row1, col1, slotLayer);
|
---|
3345 | return renderOverlay(rect, slotLayer);
|
---|
3346 | }
|
---|
3347 |
|
---|
3348 |
|
---|
3349 | function renderSlotOverlay(overlayStart, overlayEnd) {
|
---|
3350 | for (var i=0; i<colCnt; i++) {
|
---|
3351 | var dayStart = cellToDate(0, i);
|
---|
3352 | var dayEnd = addDays(cloneDate(dayStart), 1);
|
---|
3353 | var stretchStart = new Date(Math.max(dayStart, overlayStart));
|
---|
3354 | var stretchEnd = new Date(Math.min(dayEnd, overlayEnd));
|
---|
3355 | if (stretchStart < stretchEnd) {
|
---|
3356 | var rect = coordinateGrid.rect(0, i, 0, i, slotContainer); // only use it for horizontal coords
|
---|
3357 | var top = timePosition(dayStart, stretchStart);
|
---|
3358 | var bottom = timePosition(dayStart, stretchEnd);
|
---|
3359 | rect.top = top;
|
---|
3360 | rect.height = bottom - top;
|
---|
3361 | slotBind(
|
---|
3362 | renderOverlay(rect, slotContainer)
|
---|
3363 | );
|
---|
3364 | }
|
---|
3365 | }
|
---|
3366 | }
|
---|
3367 |
|
---|
3368 |
|
---|
3369 |
|
---|
3370 | /* Coordinate Utilities
|
---|
3371 | -----------------------------------------------------------------------------*/
|
---|
3372 |
|
---|
3373 |
|
---|
3374 | coordinateGrid = new CoordinateGrid(function(rows, cols) {
|
---|
3375 | var e, n, p;
|
---|
3376 | dayHeadCells.each(function(i, _e) {
|
---|
3377 | e = $(_e);
|
---|
3378 | n = e.offset().left;
|
---|
3379 | if (i) {
|
---|
3380 | p[1] = n;
|
---|
3381 | }
|
---|
3382 | p = [n];
|
---|
3383 | cols[i] = p;
|
---|
3384 | });
|
---|
3385 | p[1] = n + e.outerWidth();
|
---|
3386 | if (opt('allDaySlot')) {
|
---|
3387 | e = allDayRow;
|
---|
3388 | n = e.offset().top;
|
---|
3389 | rows[0] = [n, n+e.outerHeight()];
|
---|
3390 | }
|
---|
3391 | var slotTableTop = slotContainer.offset().top;
|
---|
3392 | var slotScrollerTop = slotScroller.offset().top;
|
---|
3393 | var slotScrollerBottom = slotScrollerTop + slotScroller.outerHeight();
|
---|
3394 | function constrain(n) {
|
---|
3395 | return Math.max(slotScrollerTop, Math.min(slotScrollerBottom, n));
|
---|
3396 | }
|
---|
3397 | for (var i=0; i<slotCnt*snapRatio; i++) { // adapt slot count to increased/decreased selection slot count
|
---|
3398 | rows.push([
|
---|
3399 | constrain(slotTableTop + snapHeight*i),
|
---|
3400 | constrain(slotTableTop + snapHeight*(i+1))
|
---|
3401 | ]);
|
---|
3402 | }
|
---|
3403 | });
|
---|
3404 |
|
---|
3405 |
|
---|
3406 | hoverListener = new HoverListener(coordinateGrid);
|
---|
3407 |
|
---|
3408 | colPositions = new HorizontalPositionCache(function(col) {
|
---|
3409 | return dayBodyCellInners.eq(col);
|
---|
3410 | });
|
---|
3411 |
|
---|
3412 | colContentPositions = new HorizontalPositionCache(function(col) {
|
---|
3413 | return dayBodyCellContentInners.eq(col);
|
---|
3414 | });
|
---|
3415 |
|
---|
3416 |
|
---|
3417 | function colLeft(col) {
|
---|
3418 | return colPositions.left(col);
|
---|
3419 | }
|
---|
3420 |
|
---|
3421 |
|
---|
3422 | function colContentLeft(col) {
|
---|
3423 | return colContentPositions.left(col);
|
---|
3424 | }
|
---|
3425 |
|
---|
3426 |
|
---|
3427 | function colRight(col) {
|
---|
3428 | return colPositions.right(col);
|
---|
3429 | }
|
---|
3430 |
|
---|
3431 |
|
---|
3432 | function colContentRight(col) {
|
---|
3433 | return colContentPositions.right(col);
|
---|
3434 | }
|
---|
3435 |
|
---|
3436 |
|
---|
3437 | function getIsCellAllDay(cell) {
|
---|
3438 | return opt('allDaySlot') && !cell.row;
|
---|
3439 | }
|
---|
3440 |
|
---|
3441 |
|
---|
3442 | function realCellToDate(cell) { // ugh "real" ... but blame it on our abuse of the "cell" system
|
---|
3443 | var d = cellToDate(0, cell.col);
|
---|
3444 | var slotIndex = cell.row;
|
---|
3445 | if (opt('allDaySlot')) {
|
---|
3446 | slotIndex--;
|
---|
3447 | }
|
---|
3448 | if (slotIndex >= 0) {
|
---|
3449 | addMinutes(d, minMinute + slotIndex * snapMinutes);
|
---|
3450 | }
|
---|
3451 | return d;
|
---|
3452 | }
|
---|
3453 |
|
---|
3454 |
|
---|
3455 | // get the Y coordinate of the given time on the given day (both Date objects)
|
---|
3456 | function timePosition(day, time) { // both date objects. day holds 00:00 of current day
|
---|
3457 | day = cloneDate(day, true);
|
---|
3458 | if (time < addMinutes(cloneDate(day), minMinute)) {
|
---|
3459 | return 0;
|
---|
3460 | }
|
---|
3461 | if (time >= addMinutes(cloneDate(day), maxMinute)) {
|
---|
3462 | return slotTable.height();
|
---|
3463 | }
|
---|
3464 | var slotMinutes = opt('slotMinutes'),
|
---|
3465 | minutes = time.getHours()*60 + time.getMinutes() - minMinute,
|
---|
3466 | slotI = Math.floor(minutes / slotMinutes),
|
---|
3467 | slotTop = slotTopCache[slotI];
|
---|
3468 | if (slotTop === undefined) {
|
---|
3469 | slotTop = slotTopCache[slotI] =
|
---|
3470 | slotTable.find('tr').eq(slotI).find('td div')[0].offsetTop;
|
---|
3471 | // .eq() is faster than ":eq()" selector
|
---|
3472 | // [0].offsetTop is faster than .position().top (do we really need this optimization?)
|
---|
3473 | // a better optimization would be to cache all these divs
|
---|
3474 | }
|
---|
3475 | return Math.max(0, Math.round(
|
---|
3476 | slotTop - 1 + slotHeight * ((minutes % slotMinutes) / slotMinutes)
|
---|
3477 | ));
|
---|
3478 | }
|
---|
3479 |
|
---|
3480 |
|
---|
3481 | function getAllDayRow(index) {
|
---|
3482 | return allDayRow;
|
---|
3483 | }
|
---|
3484 |
|
---|
3485 |
|
---|
3486 | function defaultEventEnd(event) {
|
---|
3487 | var start = cloneDate(event.start);
|
---|
3488 | if (event.allDay) {
|
---|
3489 | return start;
|
---|
3490 | }
|
---|
3491 | return addMinutes(start, opt('defaultEventMinutes'));
|
---|
3492 | }
|
---|
3493 |
|
---|
3494 |
|
---|
3495 |
|
---|
3496 | /* Selection
|
---|
3497 | ---------------------------------------------------------------------------------*/
|
---|
3498 |
|
---|
3499 |
|
---|
3500 | function defaultSelectionEnd(startDate, allDay) {
|
---|
3501 | if (allDay) {
|
---|
3502 | return cloneDate(startDate);
|
---|
3503 | }
|
---|
3504 | return addMinutes(cloneDate(startDate), opt('slotMinutes'));
|
---|
3505 | }
|
---|
3506 |
|
---|
3507 |
|
---|
3508 | function renderSelection(startDate, endDate, allDay) { // only for all-day
|
---|
3509 | if (allDay) {
|
---|
3510 | if (opt('allDaySlot')) {
|
---|
3511 | renderDayOverlay(startDate, addDays(cloneDate(endDate), 1), true);
|
---|
3512 | }
|
---|
3513 | }else{
|
---|
3514 | renderSlotSelection(startDate, endDate);
|
---|
3515 | }
|
---|
3516 | }
|
---|
3517 |
|
---|
3518 |
|
---|
3519 | function renderSlotSelection(startDate, endDate) {
|
---|
3520 | var helperOption = opt('selectHelper');
|
---|
3521 | coordinateGrid.build();
|
---|
3522 | if (helperOption) {
|
---|
3523 | var col = dateToCell(startDate).col;
|
---|
3524 | if (col >= 0 && col < colCnt) { // only works when times are on same day
|
---|
3525 | var rect = coordinateGrid.rect(0, col, 0, col, slotContainer); // only for horizontal coords
|
---|
3526 | var top = timePosition(startDate, startDate);
|
---|
3527 | var bottom = timePosition(startDate, endDate);
|
---|
3528 | if (bottom > top) { // protect against selections that are entirely before or after visible range
|
---|
3529 | rect.top = top;
|
---|
3530 | rect.height = bottom - top;
|
---|
3531 | rect.left += 2;
|
---|
3532 | rect.width -= 5;
|
---|
3533 | if ($.isFunction(helperOption)) {
|
---|
3534 | var helperRes = helperOption(startDate, endDate);
|
---|
3535 | if (helperRes) {
|
---|
3536 | rect.position = 'absolute';
|
---|
3537 | selectionHelper = $(helperRes)
|
---|
3538 | .css(rect)
|
---|
3539 | .appendTo(slotContainer);
|
---|
3540 | }
|
---|
3541 | }else{
|
---|
3542 | rect.isStart = true; // conside rect a "seg" now
|
---|
3543 | rect.isEnd = true; //
|
---|
3544 | selectionHelper = $(slotSegHtml(
|
---|
3545 | {
|
---|
3546 | title: '',
|
---|
3547 | start: startDate,
|
---|
3548 | end: endDate,
|
---|
3549 | className: ['fc-select-helper'],
|
---|
3550 | editable: false
|
---|
3551 | },
|
---|
3552 | rect
|
---|
3553 | ));
|
---|
3554 | selectionHelper.css('opacity', opt('dragOpacity'));
|
---|
3555 | }
|
---|
3556 | if (selectionHelper) {
|
---|
3557 | slotBind(selectionHelper);
|
---|
3558 | slotContainer.append(selectionHelper);
|
---|
3559 | setOuterWidth(selectionHelper, rect.width, true); // needs to be after appended
|
---|
3560 | setOuterHeight(selectionHelper, rect.height, true);
|
---|
3561 | }
|
---|
3562 | }
|
---|
3563 | }
|
---|
3564 | }else{
|
---|
3565 | renderSlotOverlay(startDate, endDate);
|
---|
3566 | }
|
---|
3567 | }
|
---|
3568 |
|
---|
3569 |
|
---|
3570 | function clearSelection() {
|
---|
3571 | clearOverlays();
|
---|
3572 | if (selectionHelper) {
|
---|
3573 | selectionHelper.remove();
|
---|
3574 | selectionHelper = null;
|
---|
3575 | }
|
---|
3576 | }
|
---|
3577 |
|
---|
3578 |
|
---|
3579 | function slotSelectionMousedown(ev) {
|
---|
3580 | if (ev.which == 1 && opt('selectable')) { // ev.which==1 means left mouse button
|
---|
3581 | unselect(ev);
|
---|
3582 | var dates;
|
---|
3583 | hoverListener.start(function(cell, origCell) {
|
---|
3584 | clearSelection();
|
---|
3585 | if (cell && cell.col == origCell.col && !getIsCellAllDay(cell)) {
|
---|
3586 | var d1 = realCellToDate(origCell);
|
---|
3587 | var d2 = realCellToDate(cell);
|
---|
3588 | dates = [
|
---|
3589 | d1,
|
---|
3590 | addMinutes(cloneDate(d1), snapMinutes), // calculate minutes depending on selection slot minutes
|
---|
3591 | d2,
|
---|
3592 | addMinutes(cloneDate(d2), snapMinutes)
|
---|
3593 | ].sort(dateCompare);
|
---|
3594 | renderSlotSelection(dates[0], dates[3]);
|
---|
3595 | }else{
|
---|
3596 | dates = null;
|
---|
3597 | }
|
---|
3598 | }, ev);
|
---|
3599 | $(document).one('mouseup', function(ev) {
|
---|
3600 | hoverListener.stop();
|
---|
3601 | if (dates) {
|
---|
3602 | if (+dates[0] == +dates[1]) {
|
---|
3603 | reportDayClick(dates[0], false, ev);
|
---|
3604 | }
|
---|
3605 | reportSelection(dates[0], dates[3], false, ev);
|
---|
3606 | }
|
---|
3607 | });
|
---|
3608 | }
|
---|
3609 | }
|
---|
3610 |
|
---|
3611 |
|
---|
3612 | function reportDayClick(date, allDay, ev) {
|
---|
3613 | trigger('dayClick', dayBodyCells[dateToCell(date).col], date, allDay, ev);
|
---|
3614 | }
|
---|
3615 |
|
---|
3616 |
|
---|
3617 |
|
---|
3618 | /* External Dragging
|
---|
3619 | --------------------------------------------------------------------------------*/
|
---|
3620 |
|
---|
3621 |
|
---|
3622 | function dragStart(_dragElement, ev, ui) {
|
---|
3623 | hoverListener.start(function(cell) {
|
---|
3624 | clearOverlays();
|
---|
3625 | if (cell) {
|
---|
3626 | if (getIsCellAllDay(cell)) {
|
---|
3627 | renderCellOverlay(cell.row, cell.col, cell.row, cell.col);
|
---|
3628 | }else{
|
---|
3629 | var d1 = realCellToDate(cell);
|
---|
3630 | var d2 = addMinutes(cloneDate(d1), opt('defaultEventMinutes'));
|
---|
3631 | renderSlotOverlay(d1, d2);
|
---|
3632 | }
|
---|
3633 | }
|
---|
3634 | }, ev);
|
---|
3635 | }
|
---|
3636 |
|
---|
3637 |
|
---|
3638 | function dragStop(_dragElement, ev, ui) {
|
---|
3639 | var cell = hoverListener.stop();
|
---|
3640 | clearOverlays();
|
---|
3641 | if (cell) {
|
---|
3642 | trigger('drop', _dragElement, realCellToDate(cell), getIsCellAllDay(cell), ev, ui);
|
---|
3643 | }
|
---|
3644 | }
|
---|
3645 |
|
---|
3646 |
|
---|
3647 | }
|
---|
3648 |
|
---|
3649 | ;;
|
---|
3650 |
|
---|
3651 | function AgendaEventRenderer() {
|
---|
3652 | var t = this;
|
---|
3653 |
|
---|
3654 |
|
---|
3655 | // exports
|
---|
3656 | t.renderEvents = renderEvents;
|
---|
3657 | t.clearEvents = clearEvents;
|
---|
3658 | t.slotSegHtml = slotSegHtml;
|
---|
3659 |
|
---|
3660 |
|
---|
3661 | // imports
|
---|
3662 | DayEventRenderer.call(t);
|
---|
3663 | var opt = t.opt;
|
---|
3664 | var trigger = t.trigger;
|
---|
3665 | var isEventDraggable = t.isEventDraggable;
|
---|
3666 | var isEventResizable = t.isEventResizable;
|
---|
3667 | var eventEnd = t.eventEnd;
|
---|
3668 | var eventElementHandlers = t.eventElementHandlers;
|
---|
3669 | var setHeight = t.setHeight;
|
---|
3670 | var getDaySegmentContainer = t.getDaySegmentContainer;
|
---|
3671 | var getSlotSegmentContainer = t.getSlotSegmentContainer;
|
---|
3672 | var getHoverListener = t.getHoverListener;
|
---|
3673 | var getMaxMinute = t.getMaxMinute;
|
---|
3674 | var getMinMinute = t.getMinMinute;
|
---|
3675 | var timePosition = t.timePosition;
|
---|
3676 | var getIsCellAllDay = t.getIsCellAllDay;
|
---|
3677 | var colContentLeft = t.colContentLeft;
|
---|
3678 | var colContentRight = t.colContentRight;
|
---|
3679 | var cellToDate = t.cellToDate;
|
---|
3680 | var getColCnt = t.getColCnt;
|
---|
3681 | var getColWidth = t.getColWidth;
|
---|
3682 | var getSnapHeight = t.getSnapHeight;
|
---|
3683 | var getSnapMinutes = t.getSnapMinutes;
|
---|
3684 | var getSlotContainer = t.getSlotContainer;
|
---|
3685 | var reportEventElement = t.reportEventElement;
|
---|
3686 | var showEvents = t.showEvents;
|
---|
3687 | var hideEvents = t.hideEvents;
|
---|
3688 | var eventDrop = t.eventDrop;
|
---|
3689 | var eventResize = t.eventResize;
|
---|
3690 | var renderDayOverlay = t.renderDayOverlay;
|
---|
3691 | var clearOverlays = t.clearOverlays;
|
---|
3692 | var renderDayEvents = t.renderDayEvents;
|
---|
3693 | var calendar = t.calendar;
|
---|
3694 | var formatDate = calendar.formatDate;
|
---|
3695 | var formatDates = calendar.formatDates;
|
---|
3696 |
|
---|
3697 |
|
---|
3698 | // overrides
|
---|
3699 | t.draggableDayEvent = draggableDayEvent;
|
---|
3700 |
|
---|
3701 |
|
---|
3702 |
|
---|
3703 | /* Rendering
|
---|
3704 | ----------------------------------------------------------------------------*/
|
---|
3705 |
|
---|
3706 |
|
---|
3707 | function renderEvents(events, modifiedEventId) {
|
---|
3708 | var i, len=events.length,
|
---|
3709 | dayEvents=[],
|
---|
3710 | slotEvents=[];
|
---|
3711 | for (i=0; i<len; i++) {
|
---|
3712 | if (events[i].allDay) {
|
---|
3713 | dayEvents.push(events[i]);
|
---|
3714 | }else{
|
---|
3715 | slotEvents.push(events[i]);
|
---|
3716 | }
|
---|
3717 | }
|
---|
3718 |
|
---|
3719 | if (opt('allDaySlot')) {
|
---|
3720 | renderDayEvents(dayEvents, modifiedEventId);
|
---|
3721 | setHeight(); // no params means set to viewHeight
|
---|
3722 | }
|
---|
3723 |
|
---|
3724 | renderSlotSegs(compileSlotSegs(slotEvents), modifiedEventId);
|
---|
3725 | }
|
---|
3726 |
|
---|
3727 |
|
---|
3728 | function clearEvents() {
|
---|
3729 | getDaySegmentContainer().empty();
|
---|
3730 | getSlotSegmentContainer().empty();
|
---|
3731 | }
|
---|
3732 |
|
---|
3733 |
|
---|
3734 | function compileSlotSegs(events) {
|
---|
3735 | var colCnt = getColCnt(),
|
---|
3736 | minMinute = getMinMinute(),
|
---|
3737 | maxMinute = getMaxMinute(),
|
---|
3738 | d,
|
---|
3739 | visEventEnds = $.map(events, slotEventEnd),
|
---|
3740 | i,
|
---|
3741 | j, seg,
|
---|
3742 | colSegs,
|
---|
3743 | segs = [];
|
---|
3744 |
|
---|
3745 | for (i=0; i<colCnt; i++) {
|
---|
3746 |
|
---|
3747 | d = cellToDate(0, i);
|
---|
3748 | addMinutes(d, minMinute);
|
---|
3749 |
|
---|
3750 | colSegs = sliceSegs(
|
---|
3751 | events,
|
---|
3752 | visEventEnds,
|
---|
3753 | d,
|
---|
3754 | addMinutes(cloneDate(d), maxMinute-minMinute)
|
---|
3755 | );
|
---|
3756 |
|
---|
3757 | colSegs = placeSlotSegs(colSegs); // returns a new order
|
---|
3758 |
|
---|
3759 | for (j=0; j<colSegs.length; j++) {
|
---|
3760 | seg = colSegs[j];
|
---|
3761 | seg.col = i;
|
---|
3762 | segs.push(seg);
|
---|
3763 | }
|
---|
3764 | }
|
---|
3765 |
|
---|
3766 | return segs;
|
---|
3767 | }
|
---|
3768 |
|
---|
3769 |
|
---|
3770 | function sliceSegs(events, visEventEnds, start, end) {
|
---|
3771 | var segs = [],
|
---|
3772 | i, len=events.length, event,
|
---|
3773 | eventStart, eventEnd,
|
---|
3774 | segStart, segEnd,
|
---|
3775 | isStart, isEnd;
|
---|
3776 | for (i=0; i<len; i++) {
|
---|
3777 | event = events[i];
|
---|
3778 | eventStart = event.start;
|
---|
3779 | eventEnd = visEventEnds[i];
|
---|
3780 | if (eventEnd > start && eventStart < end) {
|
---|
3781 | if (eventStart < start) {
|
---|
3782 | segStart = cloneDate(start);
|
---|
3783 | isStart = false;
|
---|
3784 | }else{
|
---|
3785 | segStart = eventStart;
|
---|
3786 | isStart = true;
|
---|
3787 | }
|
---|
3788 | if (eventEnd > end) {
|
---|
3789 | segEnd = cloneDate(end);
|
---|
3790 | isEnd = false;
|
---|
3791 | }else{
|
---|
3792 | segEnd = eventEnd;
|
---|
3793 | isEnd = true;
|
---|
3794 | }
|
---|
3795 | segs.push({
|
---|
3796 | event: event,
|
---|
3797 | start: segStart,
|
---|
3798 | end: segEnd,
|
---|
3799 | isStart: isStart,
|
---|
3800 | isEnd: isEnd
|
---|
3801 | });
|
---|
3802 | }
|
---|
3803 | }
|
---|
3804 | return segs.sort(compareSlotSegs);
|
---|
3805 | }
|
---|
3806 |
|
---|
3807 |
|
---|
3808 | function slotEventEnd(event) {
|
---|
3809 | if (event.end) {
|
---|
3810 | return cloneDate(event.end);
|
---|
3811 | }else{
|
---|
3812 | return addMinutes(cloneDate(event.start), opt('defaultEventMinutes'));
|
---|
3813 | }
|
---|
3814 | }
|
---|
3815 |
|
---|
3816 |
|
---|
3817 | // renders events in the 'time slots' at the bottom
|
---|
3818 | // TODO: when we refactor this, when user returns `false` eventRender, don't have empty space
|
---|
3819 | // TODO: refactor will include using pixels to detect collisions instead of dates (handy for seg cmp)
|
---|
3820 |
|
---|
3821 | function renderSlotSegs(segs, modifiedEventId) {
|
---|
3822 |
|
---|
3823 | var i, segCnt=segs.length, seg,
|
---|
3824 | event,
|
---|
3825 | top,
|
---|
3826 | bottom,
|
---|
3827 | columnLeft,
|
---|
3828 | columnRight,
|
---|
3829 | columnWidth,
|
---|
3830 | width,
|
---|
3831 | left,
|
---|
3832 | right,
|
---|
3833 | html = '',
|
---|
3834 | eventElements,
|
---|
3835 | eventElement,
|
---|
3836 | triggerRes,
|
---|
3837 | titleElement,
|
---|
3838 | height,
|
---|
3839 | slotSegmentContainer = getSlotSegmentContainer(),
|
---|
3840 | isRTL = opt('isRTL');
|
---|
3841 |
|
---|
3842 | // calculate position/dimensions, create html
|
---|
3843 | for (i=0; i<segCnt; i++) {
|
---|
3844 | seg = segs[i];
|
---|
3845 | event = seg.event;
|
---|
3846 | top = timePosition(seg.start, seg.start);
|
---|
3847 | bottom = timePosition(seg.start, seg.end);
|
---|
3848 | columnLeft = colContentLeft(seg.col);
|
---|
3849 | columnRight = colContentRight(seg.col);
|
---|
3850 | columnWidth = columnRight - columnLeft;
|
---|
3851 |
|
---|
3852 | // shave off space on right near scrollbars (2.5%)
|
---|
3853 | // TODO: move this to CSS somehow
|
---|
3854 | columnRight -= columnWidth * .025;
|
---|
3855 | columnWidth = columnRight - columnLeft;
|
---|
3856 |
|
---|
3857 | width = columnWidth * (seg.forwardCoord - seg.backwardCoord);
|
---|
3858 |
|
---|
3859 | if (opt('slotEventOverlap')) {
|
---|
3860 | // double the width while making sure resize handle is visible
|
---|
3861 | // (assumed to be 20px wide)
|
---|
3862 | width = Math.max(
|
---|
3863 | (width - (20/2)) * 2,
|
---|
3864 | width // narrow columns will want to make the segment smaller than
|
---|
3865 | // the natural width. don't allow it
|
---|
3866 | );
|
---|
3867 | }
|
---|
3868 |
|
---|
3869 | if (isRTL) {
|
---|
3870 | right = columnRight - seg.backwardCoord * columnWidth;
|
---|
3871 | left = right - width;
|
---|
3872 | }
|
---|
3873 | else {
|
---|
3874 | left = columnLeft + seg.backwardCoord * columnWidth;
|
---|
3875 | right = left + width;
|
---|
3876 | }
|
---|
3877 |
|
---|
3878 | // make sure horizontal coordinates are in bounds
|
---|
3879 | left = Math.max(left, columnLeft);
|
---|
3880 | right = Math.min(right, columnRight);
|
---|
3881 | width = right - left;
|
---|
3882 |
|
---|
3883 | seg.top = top;
|
---|
3884 | seg.left = left;
|
---|
3885 | seg.outerWidth = width;
|
---|
3886 | seg.outerHeight = bottom - top;
|
---|
3887 | html += slotSegHtml(event, seg);
|
---|
3888 | }
|
---|
3889 |
|
---|
3890 | slotSegmentContainer[0].innerHTML = html; // faster than html()
|
---|
3891 | eventElements = slotSegmentContainer.children();
|
---|
3892 |
|
---|
3893 | // retrieve elements, run through eventRender callback, bind event handlers
|
---|
3894 | for (i=0; i<segCnt; i++) {
|
---|
3895 | seg = segs[i];
|
---|
3896 | event = seg.event;
|
---|
3897 | eventElement = $(eventElements[i]); // faster than eq()
|
---|
3898 | triggerRes = trigger('eventRender', event, event, eventElement);
|
---|
3899 | if (triggerRes === false) {
|
---|
3900 | eventElement.remove();
|
---|
3901 | }else{
|
---|
3902 | if (triggerRes && triggerRes !== true) {
|
---|
3903 | eventElement.remove();
|
---|
3904 | eventElement = $(triggerRes)
|
---|
3905 | .css({
|
---|
3906 | position: 'absolute',
|
---|
3907 | top: seg.top,
|
---|
3908 | left: seg.left
|
---|
3909 | })
|
---|
3910 | .appendTo(slotSegmentContainer);
|
---|
3911 | }
|
---|
3912 | seg.element = eventElement;
|
---|
3913 | if (event._id === modifiedEventId) {
|
---|
3914 | bindSlotSeg(event, eventElement, seg);
|
---|
3915 | }else{
|
---|
3916 | eventElement[0]._fci = i; // for lazySegBind
|
---|
3917 | }
|
---|
3918 | reportEventElement(event, eventElement);
|
---|
3919 | }
|
---|
3920 | }
|
---|
3921 |
|
---|
3922 | lazySegBind(slotSegmentContainer, segs, bindSlotSeg);
|
---|
3923 |
|
---|
3924 | // record event sides and title positions
|
---|
3925 | for (i=0; i<segCnt; i++) {
|
---|
3926 | seg = segs[i];
|
---|
3927 | if (eventElement = seg.element) {
|
---|
3928 | seg.vsides = vsides(eventElement, true);
|
---|
3929 | seg.hsides = hsides(eventElement, true);
|
---|
3930 | titleElement = eventElement.find('.fc-event-title');
|
---|
3931 | if (titleElement.length) {
|
---|
3932 | seg.contentTop = titleElement[0].offsetTop;
|
---|
3933 | }
|
---|
3934 | }
|
---|
3935 | }
|
---|
3936 |
|
---|
3937 | // set all positions/dimensions at once
|
---|
3938 | for (i=0; i<segCnt; i++) {
|
---|
3939 | seg = segs[i];
|
---|
3940 | if (eventElement = seg.element) {
|
---|
3941 | eventElement[0].style.width = Math.max(0, seg.outerWidth - seg.hsides) + 'px';
|
---|
3942 | height = Math.max(0, seg.outerHeight - seg.vsides);
|
---|
3943 | eventElement[0].style.height = height + 'px';
|
---|
3944 | event = seg.event;
|
---|
3945 | if (seg.contentTop !== undefined && height - seg.contentTop < 10) {
|
---|
3946 | // not enough room for title, put it in the time (TODO: maybe make both display:inline instead)
|
---|
3947 | eventElement.find('div.fc-event-time')
|
---|
3948 | .text(formatDate(event.start, opt('timeFormat')) + ' - ' + event.title);
|
---|
3949 | eventElement.find('div.fc-event-title')
|
---|
3950 | .remove();
|
---|
3951 | }
|
---|
3952 | trigger('eventAfterRender', event, event, eventElement);
|
---|
3953 | }
|
---|
3954 | }
|
---|
3955 |
|
---|
3956 | }
|
---|
3957 |
|
---|
3958 |
|
---|
3959 | function slotSegHtml(event, seg) {
|
---|
3960 | var html = "<";
|
---|
3961 | var url = event.url;
|
---|
3962 | var skinCss = getSkinCss(event, opt);
|
---|
3963 | var classes = ['fc-event', 'fc-event-vert'];
|
---|
3964 | if (isEventDraggable(event)) {
|
---|
3965 | classes.push('fc-event-draggable');
|
---|
3966 | }
|
---|
3967 | if (seg.isStart) {
|
---|
3968 | classes.push('fc-event-start');
|
---|
3969 | }
|
---|
3970 | if (seg.isEnd) {
|
---|
3971 | classes.push('fc-event-end');
|
---|
3972 | }
|
---|
3973 | classes = classes.concat(event.className);
|
---|
3974 | if (event.source) {
|
---|
3975 | classes = classes.concat(event.source.className || []);
|
---|
3976 | }
|
---|
3977 | if (url) {
|
---|
3978 | html += "a href='" + htmlEscape(event.url) + "'";
|
---|
3979 | }else{
|
---|
3980 | html += "div";
|
---|
3981 | }
|
---|
3982 | html +=
|
---|
3983 | " class='" + classes.join(' ') + "'" +
|
---|
3984 | " style=" +
|
---|
3985 | "'" +
|
---|
3986 | "position:absolute;" +
|
---|
3987 | "top:" + seg.top + "px;" +
|
---|
3988 | "left:" + seg.left + "px;" +
|
---|
3989 | skinCss +
|
---|
3990 | "'" +
|
---|
3991 | ">" +
|
---|
3992 | "<div class='fc-event-inner'>" +
|
---|
3993 | "<div class='fc-event-time'>" +
|
---|
3994 | htmlEscape(formatDates(event.start, event.end, opt('timeFormat'))) +
|
---|
3995 | "</div>" +
|
---|
3996 | "<div class='fc-event-title'>" +
|
---|
3997 | htmlEscape(event.title || '') +
|
---|
3998 | "</div>" +
|
---|
3999 | "</div>" +
|
---|
4000 | "<div class='fc-event-bg'></div>";
|
---|
4001 | if (seg.isEnd && isEventResizable(event)) {
|
---|
4002 | html +=
|
---|
4003 | "<div class='ui-resizable-handle ui-resizable-s'>=</div>";
|
---|
4004 | }
|
---|
4005 | html +=
|
---|
4006 | "</" + (url ? "a" : "div") + ">";
|
---|
4007 | return html;
|
---|
4008 | }
|
---|
4009 |
|
---|
4010 |
|
---|
4011 | function bindSlotSeg(event, eventElement, seg) {
|
---|
4012 | var timeElement = eventElement.find('div.fc-event-time');
|
---|
4013 | if (isEventDraggable(event)) {
|
---|
4014 | draggableSlotEvent(event, eventElement, timeElement);
|
---|
4015 | }
|
---|
4016 | if (seg.isEnd && isEventResizable(event)) {
|
---|
4017 | resizableSlotEvent(event, eventElement, timeElement);
|
---|
4018 | }
|
---|
4019 | eventElementHandlers(event, eventElement);
|
---|
4020 | }
|
---|
4021 |
|
---|
4022 |
|
---|
4023 |
|
---|
4024 | /* Dragging
|
---|
4025 | -----------------------------------------------------------------------------------*/
|
---|
4026 |
|
---|
4027 |
|
---|
4028 | // when event starts out FULL-DAY
|
---|
4029 | // overrides DayEventRenderer's version because it needs to account for dragging elements
|
---|
4030 | // to and from the slot area.
|
---|
4031 |
|
---|
4032 | function draggableDayEvent(event, eventElement, seg) {
|
---|
4033 | var isStart = seg.isStart;
|
---|
4034 | var origWidth;
|
---|
4035 | var revert;
|
---|
4036 | var allDay = true;
|
---|
4037 | var dayDelta;
|
---|
4038 | var hoverListener = getHoverListener();
|
---|
4039 | var colWidth = getColWidth();
|
---|
4040 | var snapHeight = getSnapHeight();
|
---|
4041 | var snapMinutes = getSnapMinutes();
|
---|
4042 | var minMinute = getMinMinute();
|
---|
4043 | eventElement.draggable({
|
---|
4044 | opacity: opt('dragOpacity', 'month'), // use whatever the month view was using
|
---|
4045 | revertDuration: opt('dragRevertDuration'),
|
---|
4046 | start: function(ev, ui) {
|
---|
4047 | trigger('eventDragStart', eventElement, event, ev, ui);
|
---|
4048 | hideEvents(event, eventElement);
|
---|
4049 | origWidth = eventElement.width();
|
---|
4050 | hoverListener.start(function(cell, origCell) {
|
---|
4051 | clearOverlays();
|
---|
4052 | if (cell) {
|
---|
4053 | revert = false;
|
---|
4054 | var origDate = cellToDate(0, origCell.col);
|
---|
4055 | var date = cellToDate(0, cell.col);
|
---|
4056 | dayDelta = dayDiff(date, origDate);
|
---|
4057 | if (!cell.row) {
|
---|
4058 | // on full-days
|
---|
4059 | renderDayOverlay(
|
---|
4060 | addDays(cloneDate(event.start), dayDelta),
|
---|
4061 | addDays(exclEndDay(event), dayDelta)
|
---|
4062 | );
|
---|
4063 | resetElement();
|
---|
4064 | }else{
|
---|
4065 | // mouse is over bottom slots
|
---|
4066 | if (isStart) {
|
---|
4067 | if (allDay) {
|
---|
4068 | // convert event to temporary slot-event
|
---|
4069 | eventElement.width(colWidth - 10); // don't use entire width
|
---|
4070 | setOuterHeight(
|
---|
4071 | eventElement,
|
---|
4072 | snapHeight * Math.round(
|
---|
4073 | (event.end ? ((event.end - event.start) / MINUTE_MS) : opt('defaultEventMinutes')) /
|
---|
4074 | snapMinutes
|
---|
4075 | )
|
---|
4076 | );
|
---|
4077 | eventElement.draggable('option', 'grid', [colWidth, 1]);
|
---|
4078 | allDay = false;
|
---|
4079 | }
|
---|
4080 | }else{
|
---|
4081 | revert = true;
|
---|
4082 | }
|
---|
4083 | }
|
---|
4084 | revert = revert || (allDay && !dayDelta);
|
---|
4085 | }else{
|
---|
4086 | resetElement();
|
---|
4087 | revert = true;
|
---|
4088 | }
|
---|
4089 | eventElement.draggable('option', 'revert', revert);
|
---|
4090 | }, ev, 'drag');
|
---|
4091 | },
|
---|
4092 | stop: function(ev, ui) {
|
---|
4093 | hoverListener.stop();
|
---|
4094 | clearOverlays();
|
---|
4095 | trigger('eventDragStop', eventElement, event, ev, ui);
|
---|
4096 | if (revert) {
|
---|
4097 | // hasn't moved or is out of bounds (draggable has already reverted)
|
---|
4098 | resetElement();
|
---|
4099 | eventElement.css('filter', ''); // clear IE opacity side-effects
|
---|
4100 | showEvents(event, eventElement);
|
---|
4101 | }else{
|
---|
4102 | // changed!
|
---|
4103 | var minuteDelta = 0;
|
---|
4104 | if (!allDay) {
|
---|
4105 | minuteDelta = Math.round((eventElement.offset().top - getSlotContainer().offset().top) / snapHeight)
|
---|
4106 | * snapMinutes
|
---|
4107 | + minMinute
|
---|
4108 | - (event.start.getHours() * 60 + event.start.getMinutes());
|
---|
4109 | }
|
---|
4110 | eventDrop(this, event, dayDelta, minuteDelta, allDay, ev, ui);
|
---|
4111 | }
|
---|
4112 | }
|
---|
4113 | });
|
---|
4114 | function resetElement() {
|
---|
4115 | if (!allDay) {
|
---|
4116 | eventElement
|
---|
4117 | .width(origWidth)
|
---|
4118 | .height('')
|
---|
4119 | .draggable('option', 'grid', null);
|
---|
4120 | allDay = true;
|
---|
4121 | }
|
---|
4122 | }
|
---|
4123 | }
|
---|
4124 |
|
---|
4125 |
|
---|
4126 | // when event starts out IN TIMESLOTS
|
---|
4127 |
|
---|
4128 | function draggableSlotEvent(event, eventElement, timeElement) {
|
---|
4129 | var coordinateGrid = t.getCoordinateGrid();
|
---|
4130 | var colCnt = getColCnt();
|
---|
4131 | var colWidth = getColWidth();
|
---|
4132 | var snapHeight = getSnapHeight();
|
---|
4133 | var snapMinutes = getSnapMinutes();
|
---|
4134 |
|
---|
4135 | // states
|
---|
4136 | var origPosition; // original position of the element, not the mouse
|
---|
4137 | var origCell;
|
---|
4138 | var isInBounds, prevIsInBounds;
|
---|
4139 | var isAllDay, prevIsAllDay;
|
---|
4140 | var colDelta, prevColDelta;
|
---|
4141 | var dayDelta; // derived from colDelta
|
---|
4142 | var minuteDelta, prevMinuteDelta;
|
---|
4143 |
|
---|
4144 | eventElement.draggable({
|
---|
4145 | scroll: false,
|
---|
4146 | grid: [ colWidth, snapHeight ],
|
---|
4147 | axis: colCnt==1 ? 'y' : false,
|
---|
4148 | opacity: opt('dragOpacity'),
|
---|
4149 | revertDuration: opt('dragRevertDuration'),
|
---|
4150 | start: function(ev, ui) {
|
---|
4151 |
|
---|
4152 | trigger('eventDragStart', eventElement, event, ev, ui);
|
---|
4153 | hideEvents(event, eventElement);
|
---|
4154 |
|
---|
4155 | coordinateGrid.build();
|
---|
4156 |
|
---|
4157 | // initialize states
|
---|
4158 | origPosition = eventElement.position();
|
---|
4159 | origCell = coordinateGrid.cell(ev.pageX, ev.pageY);
|
---|
4160 | isInBounds = prevIsInBounds = true;
|
---|
4161 | isAllDay = prevIsAllDay = getIsCellAllDay(origCell);
|
---|
4162 | colDelta = prevColDelta = 0;
|
---|
4163 | dayDelta = 0;
|
---|
4164 | minuteDelta = prevMinuteDelta = 0;
|
---|
4165 |
|
---|
4166 | },
|
---|
4167 | drag: function(ev, ui) {
|
---|
4168 |
|
---|
4169 | // NOTE: this `cell` value is only useful for determining in-bounds and all-day.
|
---|
4170 | // Bad for anything else due to the discrepancy between the mouse position and the
|
---|
4171 | // element position while snapping. (problem revealed in PR #55)
|
---|
4172 | //
|
---|
4173 | // PS- the problem exists for draggableDayEvent() when dragging an all-day event to a slot event.
|
---|
4174 | // We should overhaul the dragging system and stop relying on jQuery UI.
|
---|
4175 | var cell = coordinateGrid.cell(ev.pageX, ev.pageY);
|
---|
4176 |
|
---|
4177 | // update states
|
---|
4178 | isInBounds = !!cell;
|
---|
4179 | if (isInBounds) {
|
---|
4180 | isAllDay = getIsCellAllDay(cell);
|
---|
4181 |
|
---|
4182 | // calculate column delta
|
---|
4183 | colDelta = Math.round((ui.position.left - origPosition.left) / colWidth);
|
---|
4184 | if (colDelta != prevColDelta) {
|
---|
4185 | // calculate the day delta based off of the original clicked column and the column delta
|
---|
4186 | var origDate = cellToDate(0, origCell.col);
|
---|
4187 | var col = origCell.col + colDelta;
|
---|
4188 | col = Math.max(0, col);
|
---|
4189 | col = Math.min(colCnt-1, col);
|
---|
4190 | var date = cellToDate(0, col);
|
---|
4191 | dayDelta = dayDiff(date, origDate);
|
---|
4192 | }
|
---|
4193 |
|
---|
4194 | // calculate minute delta (only if over slots)
|
---|
4195 | if (!isAllDay) {
|
---|
4196 | minuteDelta = Math.round((ui.position.top - origPosition.top) / snapHeight) * snapMinutes;
|
---|
4197 | }
|
---|
4198 | }
|
---|
4199 |
|
---|
4200 | // any state changes?
|
---|
4201 | if (
|
---|
4202 | isInBounds != prevIsInBounds ||
|
---|
4203 | isAllDay != prevIsAllDay ||
|
---|
4204 | colDelta != prevColDelta ||
|
---|
4205 | minuteDelta != prevMinuteDelta
|
---|
4206 | ) {
|
---|
4207 |
|
---|
4208 | updateUI();
|
---|
4209 |
|
---|
4210 | // update previous states for next time
|
---|
4211 | prevIsInBounds = isInBounds;
|
---|
4212 | prevIsAllDay = isAllDay;
|
---|
4213 | prevColDelta = colDelta;
|
---|
4214 | prevMinuteDelta = minuteDelta;
|
---|
4215 | }
|
---|
4216 |
|
---|
4217 | // if out-of-bounds, revert when done, and vice versa.
|
---|
4218 | eventElement.draggable('option', 'revert', !isInBounds);
|
---|
4219 |
|
---|
4220 | },
|
---|
4221 | stop: function(ev, ui) {
|
---|
4222 |
|
---|
4223 | clearOverlays();
|
---|
4224 | trigger('eventDragStop', eventElement, event, ev, ui);
|
---|
4225 |
|
---|
4226 | if (isInBounds && (isAllDay || dayDelta || minuteDelta)) { // changed!
|
---|
4227 | eventDrop(this, event, dayDelta, isAllDay ? 0 : minuteDelta, isAllDay, ev, ui);
|
---|
4228 | }
|
---|
4229 | else { // either no change or out-of-bounds (draggable has already reverted)
|
---|
4230 |
|
---|
4231 | // reset states for next time, and for updateUI()
|
---|
4232 | isInBounds = true;
|
---|
4233 | isAllDay = false;
|
---|
4234 | colDelta = 0;
|
---|
4235 | dayDelta = 0;
|
---|
4236 | minuteDelta = 0;
|
---|
4237 |
|
---|
4238 | updateUI();
|
---|
4239 | eventElement.css('filter', ''); // clear IE opacity side-effects
|
---|
4240 |
|
---|
4241 | // sometimes fast drags make event revert to wrong position, so reset.
|
---|
4242 | // also, if we dragged the element out of the area because of snapping,
|
---|
4243 | // but the *mouse* is still in bounds, we need to reset the position.
|
---|
4244 | eventElement.css(origPosition);
|
---|
4245 |
|
---|
4246 | showEvents(event, eventElement);
|
---|
4247 | }
|
---|
4248 | }
|
---|
4249 | });
|
---|
4250 |
|
---|
4251 | function updateUI() {
|
---|
4252 | clearOverlays();
|
---|
4253 | if (isInBounds) {
|
---|
4254 | if (isAllDay) {
|
---|
4255 | timeElement.hide();
|
---|
4256 | eventElement.draggable('option', 'grid', null); // disable grid snapping
|
---|
4257 | renderDayOverlay(
|
---|
4258 | addDays(cloneDate(event.start), dayDelta),
|
---|
4259 | addDays(exclEndDay(event), dayDelta)
|
---|
4260 | );
|
---|
4261 | }
|
---|
4262 | else {
|
---|
4263 | updateTimeText(minuteDelta);
|
---|
4264 | timeElement.css('display', ''); // show() was causing display=inline
|
---|
4265 | eventElement.draggable('option', 'grid', [colWidth, snapHeight]); // re-enable grid snapping
|
---|
4266 | }
|
---|
4267 | }
|
---|
4268 | }
|
---|
4269 |
|
---|
4270 | function updateTimeText(minuteDelta) {
|
---|
4271 | var newStart = addMinutes(cloneDate(event.start), minuteDelta);
|
---|
4272 | var newEnd;
|
---|
4273 | if (event.end) {
|
---|
4274 | newEnd = addMinutes(cloneDate(event.end), minuteDelta);
|
---|
4275 | }
|
---|
4276 | timeElement.text(formatDates(newStart, newEnd, opt('timeFormat')));
|
---|
4277 | }
|
---|
4278 |
|
---|
4279 | }
|
---|
4280 |
|
---|
4281 |
|
---|
4282 |
|
---|
4283 | /* Resizing
|
---|
4284 | --------------------------------------------------------------------------------------*/
|
---|
4285 |
|
---|
4286 |
|
---|
4287 | function resizableSlotEvent(event, eventElement, timeElement) {
|
---|
4288 | var snapDelta, prevSnapDelta;
|
---|
4289 | var snapHeight = getSnapHeight();
|
---|
4290 | var snapMinutes = getSnapMinutes();
|
---|
4291 | eventElement.resizable({
|
---|
4292 | handles: {
|
---|
4293 | s: '.ui-resizable-handle'
|
---|
4294 | },
|
---|
4295 | grid: snapHeight,
|
---|
4296 | start: function(ev, ui) {
|
---|
4297 | snapDelta = prevSnapDelta = 0;
|
---|
4298 | hideEvents(event, eventElement);
|
---|
4299 | trigger('eventResizeStart', this, event, ev, ui);
|
---|
4300 | },
|
---|
4301 | resize: function(ev, ui) {
|
---|
4302 | // don't rely on ui.size.height, doesn't take grid into account
|
---|
4303 | snapDelta = Math.round((Math.max(snapHeight, eventElement.height()) - ui.originalSize.height) / snapHeight);
|
---|
4304 | if (snapDelta != prevSnapDelta) {
|
---|
4305 | timeElement.text(
|
---|
4306 | formatDates(
|
---|
4307 | event.start,
|
---|
4308 | (!snapDelta && !event.end) ? null : // no change, so don't display time range
|
---|
4309 | addMinutes(eventEnd(event), snapMinutes*snapDelta),
|
---|
4310 | opt('timeFormat')
|
---|
4311 | )
|
---|
4312 | );
|
---|
4313 | prevSnapDelta = snapDelta;
|
---|
4314 | }
|
---|
4315 | },
|
---|
4316 | stop: function(ev, ui) {
|
---|
4317 | trigger('eventResizeStop', this, event, ev, ui);
|
---|
4318 | if (snapDelta) {
|
---|
4319 | eventResize(this, event, 0, snapMinutes*snapDelta, ev, ui);
|
---|
4320 | }else{
|
---|
4321 | showEvents(event, eventElement);
|
---|
4322 | // BUG: if event was really short, need to put title back in span
|
---|
4323 | }
|
---|
4324 | }
|
---|
4325 | });
|
---|
4326 | }
|
---|
4327 |
|
---|
4328 |
|
---|
4329 | }
|
---|
4330 |
|
---|
4331 |
|
---|
4332 |
|
---|
4333 | /* Agenda Event Segment Utilities
|
---|
4334 | -----------------------------------------------------------------------------*/
|
---|
4335 |
|
---|
4336 |
|
---|
4337 | // Sets the seg.backwardCoord and seg.forwardCoord on each segment and returns a new
|
---|
4338 | // list in the order they should be placed into the DOM (an implicit z-index).
|
---|
4339 | function placeSlotSegs(segs) {
|
---|
4340 | var levels = buildSlotSegLevels(segs);
|
---|
4341 | var level0 = levels[0];
|
---|
4342 | var i;
|
---|
4343 |
|
---|
4344 | computeForwardSlotSegs(levels);
|
---|
4345 |
|
---|
4346 | if (level0) {
|
---|
4347 |
|
---|
4348 | for (i=0; i<level0.length; i++) {
|
---|
4349 | computeSlotSegPressures(level0[i]);
|
---|
4350 | }
|
---|
4351 |
|
---|
4352 | for (i=0; i<level0.length; i++) {
|
---|
4353 | computeSlotSegCoords(level0[i], 0, 0);
|
---|
4354 | }
|
---|
4355 | }
|
---|
4356 |
|
---|
4357 | return flattenSlotSegLevels(levels);
|
---|
4358 | }
|
---|
4359 |
|
---|
4360 |
|
---|
4361 | // Builds an array of segments "levels". The first level will be the leftmost tier of segments
|
---|
4362 | // if the calendar is left-to-right, or the rightmost if the calendar is right-to-left.
|
---|
4363 | function buildSlotSegLevels(segs) {
|
---|
4364 | var levels = [];
|
---|
4365 | var i, seg;
|
---|
4366 | var j;
|
---|
4367 |
|
---|
4368 | for (i=0; i<segs.length; i++) {
|
---|
4369 | seg = segs[i];
|
---|
4370 |
|
---|
4371 | // go through all the levels and stop on the first level where there are no collisions
|
---|
4372 | for (j=0; j<levels.length; j++) {
|
---|
4373 | if (!computeSlotSegCollisions(seg, levels[j]).length) {
|
---|
4374 | break;
|
---|
4375 | }
|
---|
4376 | }
|
---|
4377 |
|
---|
4378 | (levels[j] || (levels[j] = [])).push(seg);
|
---|
4379 | }
|
---|
4380 |
|
---|
4381 | return levels;
|
---|
4382 | }
|
---|
4383 |
|
---|
4384 |
|
---|
4385 | // For every segment, figure out the other segments that are in subsequent
|
---|
4386 | // levels that also occupy the same vertical space. Accumulate in seg.forwardSegs
|
---|
4387 | function computeForwardSlotSegs(levels) {
|
---|
4388 | var i, level;
|
---|
4389 | var j, seg;
|
---|
4390 | var k;
|
---|
4391 |
|
---|
4392 | for (i=0; i<levels.length; i++) {
|
---|
4393 | level = levels[i];
|
---|
4394 |
|
---|
4395 | for (j=0; j<level.length; j++) {
|
---|
4396 | seg = level[j];
|
---|
4397 |
|
---|
4398 | seg.forwardSegs = [];
|
---|
4399 | for (k=i+1; k<levels.length; k++) {
|
---|
4400 | computeSlotSegCollisions(seg, levels[k], seg.forwardSegs);
|
---|
4401 | }
|
---|
4402 | }
|
---|
4403 | }
|
---|
4404 | }
|
---|
4405 |
|
---|
4406 |
|
---|
4407 | // Figure out which path forward (via seg.forwardSegs) results in the longest path until
|
---|
4408 | // the furthest edge is reached. The number of segments in this path will be seg.forwardPressure
|
---|
4409 | function computeSlotSegPressures(seg) {
|
---|
4410 | var forwardSegs = seg.forwardSegs;
|
---|
4411 | var forwardPressure = 0;
|
---|
4412 | var i, forwardSeg;
|
---|
4413 |
|
---|
4414 | if (seg.forwardPressure === undefined) { // not already computed
|
---|
4415 |
|
---|
4416 | for (i=0; i<forwardSegs.length; i++) {
|
---|
4417 | forwardSeg = forwardSegs[i];
|
---|
4418 |
|
---|
4419 | // figure out the child's maximum forward path
|
---|
4420 | computeSlotSegPressures(forwardSeg);
|
---|
4421 |
|
---|
4422 | // either use the existing maximum, or use the child's forward pressure
|
---|
4423 | // plus one (for the forwardSeg itself)
|
---|
4424 | forwardPressure = Math.max(
|
---|
4425 | forwardPressure,
|
---|
4426 | 1 + forwardSeg.forwardPressure
|
---|
4427 | );
|
---|
4428 | }
|
---|
4429 |
|
---|
4430 | seg.forwardPressure = forwardPressure;
|
---|
4431 | }
|
---|
4432 | }
|
---|
4433 |
|
---|
4434 |
|
---|
4435 | // Calculate seg.forwardCoord and seg.backwardCoord for the segment, where both values range
|
---|
4436 | // from 0 to 1. If the calendar is left-to-right, the seg.backwardCoord maps to "left" and
|
---|
4437 | // seg.forwardCoord maps to "right" (via percentage). Vice-versa if the calendar is right-to-left.
|
---|
4438 | //
|
---|
4439 | // The segment might be part of a "series", which means consecutive segments with the same pressure
|
---|
4440 | // who's width is unknown until an edge has been hit. `seriesBackwardPressure` is the number of
|
---|
4441 | // segments behind this one in the current series, and `seriesBackwardCoord` is the starting
|
---|
4442 | // coordinate of the first segment in the series.
|
---|
4443 | function computeSlotSegCoords(seg, seriesBackwardPressure, seriesBackwardCoord) {
|
---|
4444 | var forwardSegs = seg.forwardSegs;
|
---|
4445 | var i;
|
---|
4446 |
|
---|
4447 | if (seg.forwardCoord === undefined) { // not already computed
|
---|
4448 |
|
---|
4449 | if (!forwardSegs.length) {
|
---|
4450 |
|
---|
4451 | // if there are no forward segments, this segment should butt up against the edge
|
---|
4452 | seg.forwardCoord = 1;
|
---|
4453 | }
|
---|
4454 | else {
|
---|
4455 |
|
---|
4456 | // sort highest pressure first
|
---|
4457 | forwardSegs.sort(compareForwardSlotSegs);
|
---|
4458 |
|
---|
4459 | // this segment's forwardCoord will be calculated from the backwardCoord of the
|
---|
4460 | // highest-pressure forward segment.
|
---|
4461 | computeSlotSegCoords(forwardSegs[0], seriesBackwardPressure + 1, seriesBackwardCoord);
|
---|
4462 | seg.forwardCoord = forwardSegs[0].backwardCoord;
|
---|
4463 | }
|
---|
4464 |
|
---|
4465 | // calculate the backwardCoord from the forwardCoord. consider the series
|
---|
4466 | seg.backwardCoord = seg.forwardCoord -
|
---|
4467 | (seg.forwardCoord - seriesBackwardCoord) / // available width for series
|
---|
4468 | (seriesBackwardPressure + 1); // # of segments in the series
|
---|
4469 |
|
---|
4470 | // use this segment's coordinates to computed the coordinates of the less-pressurized
|
---|
4471 | // forward segments
|
---|
4472 | for (i=0; i<forwardSegs.length; i++) {
|
---|
4473 | computeSlotSegCoords(forwardSegs[i], 0, seg.forwardCoord);
|
---|
4474 | }
|
---|
4475 | }
|
---|
4476 | }
|
---|
4477 |
|
---|
4478 |
|
---|
4479 | // Outputs a flat array of segments, from lowest to highest level
|
---|
4480 | function flattenSlotSegLevels(levels) {
|
---|
4481 | var segs = [];
|
---|
4482 | var i, level;
|
---|
4483 | var j;
|
---|
4484 |
|
---|
4485 | for (i=0; i<levels.length; i++) {
|
---|
4486 | level = levels[i];
|
---|
4487 |
|
---|
4488 | for (j=0; j<level.length; j++) {
|
---|
4489 | segs.push(level[j]);
|
---|
4490 | }
|
---|
4491 | }
|
---|
4492 |
|
---|
4493 | return segs;
|
---|
4494 | }
|
---|
4495 |
|
---|
4496 |
|
---|
4497 | // Find all the segments in `otherSegs` that vertically collide with `seg`.
|
---|
4498 | // Append into an optionally-supplied `results` array and return.
|
---|
4499 | function computeSlotSegCollisions(seg, otherSegs, results) {
|
---|
4500 | results = results || [];
|
---|
4501 |
|
---|
4502 | for (var i=0; i<otherSegs.length; i++) {
|
---|
4503 | if (isSlotSegCollision(seg, otherSegs[i])) {
|
---|
4504 | results.push(otherSegs[i]);
|
---|
4505 | }
|
---|
4506 | }
|
---|
4507 |
|
---|
4508 | return results;
|
---|
4509 | }
|
---|
4510 |
|
---|
4511 |
|
---|
4512 | // Do these segments occupy the same vertical space?
|
---|
4513 | function isSlotSegCollision(seg1, seg2) {
|
---|
4514 | return seg1.end > seg2.start && seg1.start < seg2.end;
|
---|
4515 | }
|
---|
4516 |
|
---|
4517 |
|
---|
4518 | // A cmp function for determining which forward segment to rely on more when computing coordinates.
|
---|
4519 | function compareForwardSlotSegs(seg1, seg2) {
|
---|
4520 | // put higher-pressure first
|
---|
4521 | return seg2.forwardPressure - seg1.forwardPressure ||
|
---|
4522 | // put segments that are closer to initial edge first (and favor ones with no coords yet)
|
---|
4523 | (seg1.backwardCoord || 0) - (seg2.backwardCoord || 0) ||
|
---|
4524 | // do normal sorting...
|
---|
4525 | compareSlotSegs(seg1, seg2);
|
---|
4526 | }
|
---|
4527 |
|
---|
4528 |
|
---|
4529 | // A cmp function for determining which segment should be closer to the initial edge
|
---|
4530 | // (the left edge on a left-to-right calendar).
|
---|
4531 | function compareSlotSegs(seg1, seg2) {
|
---|
4532 | return seg1.start - seg2.start || // earlier start time goes first
|
---|
4533 | (seg2.end - seg2.start) - (seg1.end - seg1.start) || // tie? longer-duration goes first
|
---|
4534 | (seg1.event.title || '').localeCompare(seg2.event.title); // tie? alphabetically by title
|
---|
4535 | }
|
---|
4536 |
|
---|
4537 |
|
---|
4538 | ;;
|
---|
4539 |
|
---|
4540 |
|
---|
4541 | function View(element, calendar, viewName) {
|
---|
4542 | var t = this;
|
---|
4543 |
|
---|
4544 |
|
---|
4545 | // exports
|
---|
4546 | t.element = element;
|
---|
4547 | t.calendar = calendar;
|
---|
4548 | t.name = viewName;
|
---|
4549 | t.opt = opt;
|
---|
4550 | t.trigger = trigger;
|
---|
4551 | t.isEventDraggable = isEventDraggable;
|
---|
4552 | t.isEventResizable = isEventResizable;
|
---|
4553 | t.setEventData = setEventData;
|
---|
4554 | t.clearEventData = clearEventData;
|
---|
4555 | t.eventEnd = eventEnd;
|
---|
4556 | t.reportEventElement = reportEventElement;
|
---|
4557 | t.triggerEventDestroy = triggerEventDestroy;
|
---|
4558 | t.eventElementHandlers = eventElementHandlers;
|
---|
4559 | t.showEvents = showEvents;
|
---|
4560 | t.hideEvents = hideEvents;
|
---|
4561 | t.eventDrop = eventDrop;
|
---|
4562 | t.eventResize = eventResize;
|
---|
4563 | // t.title
|
---|
4564 | // t.start, t.end
|
---|
4565 | // t.visStart, t.visEnd
|
---|
4566 |
|
---|
4567 |
|
---|
4568 | // imports
|
---|
4569 | var defaultEventEnd = t.defaultEventEnd;
|
---|
4570 | var normalizeEvent = calendar.normalizeEvent; // in EventManager
|
---|
4571 | var reportEventChange = calendar.reportEventChange;
|
---|
4572 |
|
---|
4573 |
|
---|
4574 | // locals
|
---|
4575 | var eventsByID = {}; // eventID mapped to array of events (there can be multiple b/c of repeating events)
|
---|
4576 | var eventElementsByID = {}; // eventID mapped to array of jQuery elements
|
---|
4577 | var eventElementCouples = []; // array of objects, { event, element } // TODO: unify with segment system
|
---|
4578 | var options = calendar.options;
|
---|
4579 |
|
---|
4580 |
|
---|
4581 |
|
---|
4582 | function opt(name, viewNameOverride) {
|
---|
4583 | var v = options[name];
|
---|
4584 | if ($.isPlainObject(v)) {
|
---|
4585 | return smartProperty(v, viewNameOverride || viewName);
|
---|
4586 | }
|
---|
4587 | return v;
|
---|
4588 | }
|
---|
4589 |
|
---|
4590 |
|
---|
4591 | function trigger(name, thisObj) {
|
---|
4592 | return calendar.trigger.apply(
|
---|
4593 | calendar,
|
---|
4594 | [name, thisObj || t].concat(Array.prototype.slice.call(arguments, 2), [t])
|
---|
4595 | );
|
---|
4596 | }
|
---|
4597 |
|
---|
4598 |
|
---|
4599 |
|
---|
4600 | /* Event Editable Boolean Calculations
|
---|
4601 | ------------------------------------------------------------------------------*/
|
---|
4602 |
|
---|
4603 |
|
---|
4604 | function isEventDraggable(event) {
|
---|
4605 | var source = event.source || {};
|
---|
4606 | return firstDefined(
|
---|
4607 | event.startEditable,
|
---|
4608 | source.startEditable,
|
---|
4609 | opt('eventStartEditable'),
|
---|
4610 | event.editable,
|
---|
4611 | source.editable,
|
---|
4612 | opt('editable')
|
---|
4613 | )
|
---|
4614 | && !opt('disableDragging'); // deprecated
|
---|
4615 | }
|
---|
4616 |
|
---|
4617 |
|
---|
4618 | function isEventResizable(event) { // but also need to make sure the seg.isEnd == true
|
---|
4619 | var source = event.source || {};
|
---|
4620 | return firstDefined(
|
---|
4621 | event.durationEditable,
|
---|
4622 | source.durationEditable,
|
---|
4623 | opt('eventDurationEditable'),
|
---|
4624 | event.editable,
|
---|
4625 | source.editable,
|
---|
4626 | opt('editable')
|
---|
4627 | )
|
---|
4628 | && !opt('disableResizing'); // deprecated
|
---|
4629 | }
|
---|
4630 |
|
---|
4631 |
|
---|
4632 |
|
---|
4633 | /* Event Data
|
---|
4634 | ------------------------------------------------------------------------------*/
|
---|
4635 |
|
---|
4636 |
|
---|
4637 | function setEventData(events) { // events are already normalized at this point
|
---|
4638 | eventsByID = {};
|
---|
4639 | var i, len=events.length, event;
|
---|
4640 | for (i=0; i<len; i++) {
|
---|
4641 | event = events[i];
|
---|
4642 | if (eventsByID[event._id]) {
|
---|
4643 | eventsByID[event._id].push(event);
|
---|
4644 | }else{
|
---|
4645 | eventsByID[event._id] = [event];
|
---|
4646 | }
|
---|
4647 | }
|
---|
4648 | }
|
---|
4649 |
|
---|
4650 |
|
---|
4651 | function clearEventData() {
|
---|
4652 | eventsByID = {};
|
---|
4653 | eventElementsByID = {};
|
---|
4654 | eventElementCouples = [];
|
---|
4655 | }
|
---|
4656 |
|
---|
4657 |
|
---|
4658 | // returns a Date object for an event's end
|
---|
4659 | function eventEnd(event) {
|
---|
4660 | return event.end ? cloneDate(event.end) : defaultEventEnd(event);
|
---|
4661 | }
|
---|
4662 |
|
---|
4663 |
|
---|
4664 |
|
---|
4665 | /* Event Elements
|
---|
4666 | ------------------------------------------------------------------------------*/
|
---|
4667 |
|
---|
4668 |
|
---|
4669 | // report when view creates an element for an event
|
---|
4670 | function reportEventElement(event, element) {
|
---|
4671 | eventElementCouples.push({ event: event, element: element });
|
---|
4672 | if (eventElementsByID[event._id]) {
|
---|
4673 | eventElementsByID[event._id].push(element);
|
---|
4674 | }else{
|
---|
4675 | eventElementsByID[event._id] = [element];
|
---|
4676 | }
|
---|
4677 | }
|
---|
4678 |
|
---|
4679 |
|
---|
4680 | function triggerEventDestroy() {
|
---|
4681 | $.each(eventElementCouples, function(i, couple) {
|
---|
4682 | t.trigger('eventDestroy', couple.event, couple.event, couple.element);
|
---|
4683 | });
|
---|
4684 | }
|
---|
4685 |
|
---|
4686 |
|
---|
4687 | // attaches eventClick, eventMouseover, eventMouseout
|
---|
4688 | function eventElementHandlers(event, eventElement) {
|
---|
4689 | eventElement
|
---|
4690 | .click(function(ev) {
|
---|
4691 | if (!eventElement.hasClass('ui-draggable-dragging') &&
|
---|
4692 | !eventElement.hasClass('ui-resizable-resizing')) {
|
---|
4693 | return trigger('eventClick', this, event, ev);
|
---|
4694 | }
|
---|
4695 | })
|
---|
4696 | .hover(
|
---|
4697 | function(ev) {
|
---|
4698 | trigger('eventMouseover', this, event, ev);
|
---|
4699 | },
|
---|
4700 | function(ev) {
|
---|
4701 | trigger('eventMouseout', this, event, ev);
|
---|
4702 | }
|
---|
4703 | );
|
---|
4704 | // TODO: don't fire eventMouseover/eventMouseout *while* dragging is occuring (on subject element)
|
---|
4705 | // TODO: same for resizing
|
---|
4706 | }
|
---|
4707 |
|
---|
4708 |
|
---|
4709 | function showEvents(event, exceptElement) {
|
---|
4710 | eachEventElement(event, exceptElement, 'show');
|
---|
4711 | }
|
---|
4712 |
|
---|
4713 |
|
---|
4714 | function hideEvents(event, exceptElement) {
|
---|
4715 | eachEventElement(event, exceptElement, 'hide');
|
---|
4716 | }
|
---|
4717 |
|
---|
4718 |
|
---|
4719 | function eachEventElement(event, exceptElement, funcName) {
|
---|
4720 | // NOTE: there may be multiple events per ID (repeating events)
|
---|
4721 | // and multiple segments per event
|
---|
4722 | var elements = eventElementsByID[event._id],
|
---|
4723 | i, len = elements.length;
|
---|
4724 | for (i=0; i<len; i++) {
|
---|
4725 | if (!exceptElement || elements[i][0] != exceptElement[0]) {
|
---|
4726 | elements[i][funcName]();
|
---|
4727 | }
|
---|
4728 | }
|
---|
4729 | }
|
---|
4730 |
|
---|
4731 |
|
---|
4732 |
|
---|
4733 | /* Event Modification Reporting
|
---|
4734 | ---------------------------------------------------------------------------------*/
|
---|
4735 |
|
---|
4736 |
|
---|
4737 | function eventDrop(e, event, dayDelta, minuteDelta, allDay, ev, ui) {
|
---|
4738 | var oldAllDay = event.allDay;
|
---|
4739 | var eventId = event._id;
|
---|
4740 | moveEvents(eventsByID[eventId], dayDelta, minuteDelta, allDay);
|
---|
4741 | trigger(
|
---|
4742 | 'eventDrop',
|
---|
4743 | e,
|
---|
4744 | event,
|
---|
4745 | dayDelta,
|
---|
4746 | minuteDelta,
|
---|
4747 | allDay,
|
---|
4748 | function() {
|
---|
4749 | // TODO: investigate cases where this inverse technique might not work
|
---|
4750 | moveEvents(eventsByID[eventId], -dayDelta, -minuteDelta, oldAllDay);
|
---|
4751 | reportEventChange(eventId);
|
---|
4752 | },
|
---|
4753 | ev,
|
---|
4754 | ui
|
---|
4755 | );
|
---|
4756 | reportEventChange(eventId);
|
---|
4757 | }
|
---|
4758 |
|
---|
4759 |
|
---|
4760 | function eventResize(e, event, dayDelta, minuteDelta, ev, ui) {
|
---|
4761 | var eventId = event._id;
|
---|
4762 | elongateEvents(eventsByID[eventId], dayDelta, minuteDelta);
|
---|
4763 | trigger(
|
---|
4764 | 'eventResize',
|
---|
4765 | e,
|
---|
4766 | event,
|
---|
4767 | dayDelta,
|
---|
4768 | minuteDelta,
|
---|
4769 | function() {
|
---|
4770 | // TODO: investigate cases where this inverse technique might not work
|
---|
4771 | elongateEvents(eventsByID[eventId], -dayDelta, -minuteDelta);
|
---|
4772 | reportEventChange(eventId);
|
---|
4773 | },
|
---|
4774 | ev,
|
---|
4775 | ui
|
---|
4776 | );
|
---|
4777 | reportEventChange(eventId);
|
---|
4778 | }
|
---|
4779 |
|
---|
4780 |
|
---|
4781 |
|
---|
4782 | /* Event Modification Math
|
---|
4783 | ---------------------------------------------------------------------------------*/
|
---|
4784 |
|
---|
4785 |
|
---|
4786 | function moveEvents(events, dayDelta, minuteDelta, allDay) {
|
---|
4787 | minuteDelta = minuteDelta || 0;
|
---|
4788 | for (var e, len=events.length, i=0; i<len; i++) {
|
---|
4789 | e = events[i];
|
---|
4790 | if (allDay !== undefined) {
|
---|
4791 | e.allDay = allDay;
|
---|
4792 | }
|
---|
4793 | addMinutes(addDays(e.start, dayDelta, true), minuteDelta);
|
---|
4794 | if (e.end) {
|
---|
4795 | e.end = addMinutes(addDays(e.end, dayDelta, true), minuteDelta);
|
---|
4796 | }
|
---|
4797 | normalizeEvent(e, options);
|
---|
4798 | }
|
---|
4799 | }
|
---|
4800 |
|
---|
4801 |
|
---|
4802 | function elongateEvents(events, dayDelta, minuteDelta) {
|
---|
4803 | minuteDelta = minuteDelta || 0;
|
---|
4804 | for (var e, len=events.length, i=0; i<len; i++) {
|
---|
4805 | e = events[i];
|
---|
4806 | e.end = addMinutes(addDays(eventEnd(e), dayDelta, true), minuteDelta);
|
---|
4807 | normalizeEvent(e, options);
|
---|
4808 | }
|
---|
4809 | }
|
---|
4810 |
|
---|
4811 |
|
---|
4812 |
|
---|
4813 | // ====================================================================================================
|
---|
4814 | // Utilities for day "cells"
|
---|
4815 | // ====================================================================================================
|
---|
4816 | // The "basic" views are completely made up of day cells.
|
---|
4817 | // The "agenda" views have day cells at the top "all day" slot.
|
---|
4818 | // This was the obvious common place to put these utilities, but they should be abstracted out into
|
---|
4819 | // a more meaningful class (like DayEventRenderer).
|
---|
4820 | // ====================================================================================================
|
---|
4821 |
|
---|
4822 |
|
---|
4823 | // For determining how a given "cell" translates into a "date":
|
---|
4824 | //
|
---|
4825 | // 1. Convert the "cell" (row and column) into a "cell offset" (the # of the cell, cronologically from the first).
|
---|
4826 | // Keep in mind that column indices are inverted with isRTL. This is taken into account.
|
---|
4827 | //
|
---|
4828 | // 2. Convert the "cell offset" to a "day offset" (the # of days since the first visible day in the view).
|
---|
4829 | //
|
---|
4830 | // 3. Convert the "day offset" into a "date" (a JavaScript Date object).
|
---|
4831 | //
|
---|
4832 | // The reverse transformation happens when transforming a date into a cell.
|
---|
4833 |
|
---|
4834 |
|
---|
4835 | // exports
|
---|
4836 | t.isHiddenDay = isHiddenDay;
|
---|
4837 | t.skipHiddenDays = skipHiddenDays;
|
---|
4838 | t.getCellsPerWeek = getCellsPerWeek;
|
---|
4839 | t.dateToCell = dateToCell;
|
---|
4840 | t.dateToDayOffset = dateToDayOffset;
|
---|
4841 | t.dayOffsetToCellOffset = dayOffsetToCellOffset;
|
---|
4842 | t.cellOffsetToCell = cellOffsetToCell;
|
---|
4843 | t.cellToDate = cellToDate;
|
---|
4844 | t.cellToCellOffset = cellToCellOffset;
|
---|
4845 | t.cellOffsetToDayOffset = cellOffsetToDayOffset;
|
---|
4846 | t.dayOffsetToDate = dayOffsetToDate;
|
---|
4847 | t.rangeToSegments = rangeToSegments;
|
---|
4848 |
|
---|
4849 |
|
---|
4850 | // internals
|
---|
4851 | var hiddenDays = opt('hiddenDays') || []; // array of day-of-week indices that are hidden
|
---|
4852 | var isHiddenDayHash = []; // is the day-of-week hidden? (hash with day-of-week-index -> bool)
|
---|
4853 | var cellsPerWeek;
|
---|
4854 | var dayToCellMap = []; // hash from dayIndex -> cellIndex, for one week
|
---|
4855 | var cellToDayMap = []; // hash from cellIndex -> dayIndex, for one week
|
---|
4856 | var isRTL = opt('isRTL');
|
---|
4857 |
|
---|
4858 |
|
---|
4859 | // initialize important internal variables
|
---|
4860 | (function() {
|
---|
4861 |
|
---|
4862 | if (opt('weekends') === false) {
|
---|
4863 | hiddenDays.push(0, 6); // 0=sunday, 6=saturday
|
---|
4864 | }
|
---|
4865 |
|
---|
4866 | // Loop through a hypothetical week and determine which
|
---|
4867 | // days-of-week are hidden. Record in both hashes (one is the reverse of the other).
|
---|
4868 | for (var dayIndex=0, cellIndex=0; dayIndex<7; dayIndex++) {
|
---|
4869 | dayToCellMap[dayIndex] = cellIndex;
|
---|
4870 | isHiddenDayHash[dayIndex] = $.inArray(dayIndex, hiddenDays) != -1;
|
---|
4871 | if (!isHiddenDayHash[dayIndex]) {
|
---|
4872 | cellToDayMap[cellIndex] = dayIndex;
|
---|
4873 | cellIndex++;
|
---|
4874 | }
|
---|
4875 | }
|
---|
4876 |
|
---|
4877 | cellsPerWeek = cellIndex;
|
---|
4878 | if (!cellsPerWeek) {
|
---|
4879 | throw 'invalid hiddenDays'; // all days were hidden? bad.
|
---|
4880 | }
|
---|
4881 |
|
---|
4882 | })();
|
---|
4883 |
|
---|
4884 |
|
---|
4885 | // Is the current day hidden?
|
---|
4886 | // `day` is a day-of-week index (0-6), or a Date object
|
---|
4887 | function isHiddenDay(day) {
|
---|
4888 | if (typeof day == 'object') {
|
---|
4889 | day = day.getDay();
|
---|
4890 | }
|
---|
4891 | return isHiddenDayHash[day];
|
---|
4892 | }
|
---|
4893 |
|
---|
4894 |
|
---|
4895 | function getCellsPerWeek() {
|
---|
4896 | return cellsPerWeek;
|
---|
4897 | }
|
---|
4898 |
|
---|
4899 |
|
---|
4900 | // Keep incrementing the current day until it is no longer a hidden day.
|
---|
4901 | // If the initial value of `date` is not a hidden day, don't do anything.
|
---|
4902 | // Pass `isExclusive` as `true` if you are dealing with an end date.
|
---|
4903 | // `inc` defaults to `1` (increment one day forward each time)
|
---|
4904 | function skipHiddenDays(date, inc, isExclusive) {
|
---|
4905 | inc = inc || 1;
|
---|
4906 | while (
|
---|
4907 | isHiddenDayHash[ ( date.getDay() + (isExclusive ? inc : 0) + 7 ) % 7 ]
|
---|
4908 | ) {
|
---|
4909 | addDays(date, inc);
|
---|
4910 | }
|
---|
4911 | }
|
---|
4912 |
|
---|
4913 |
|
---|
4914 | //
|
---|
4915 | // TRANSFORMATIONS: cell -> cell offset -> day offset -> date
|
---|
4916 | //
|
---|
4917 |
|
---|
4918 | // cell -> date (combines all transformations)
|
---|
4919 | // Possible arguments:
|
---|
4920 | // - row, col
|
---|
4921 | // - { row:#, col: # }
|
---|
4922 | function cellToDate() {
|
---|
4923 | var cellOffset = cellToCellOffset.apply(null, arguments);
|
---|
4924 | var dayOffset = cellOffsetToDayOffset(cellOffset);
|
---|
4925 | var date = dayOffsetToDate(dayOffset);
|
---|
4926 | return date;
|
---|
4927 | }
|
---|
4928 |
|
---|
4929 | // cell -> cell offset
|
---|
4930 | // Possible arguments:
|
---|
4931 | // - row, col
|
---|
4932 | // - { row:#, col:# }
|
---|
4933 | function cellToCellOffset(row, col) {
|
---|
4934 | var colCnt = t.getColCnt();
|
---|
4935 |
|
---|
4936 | // rtl variables. wish we could pre-populate these. but where?
|
---|
4937 | var dis = isRTL ? -1 : 1;
|
---|
4938 | var dit = isRTL ? colCnt - 1 : 0;
|
---|
4939 |
|
---|
4940 | if (typeof row == 'object') {
|
---|
4941 | col = row.col;
|
---|
4942 | row = row.row;
|
---|
4943 | }
|
---|
4944 | var cellOffset = row * colCnt + (col * dis + dit); // column, adjusted for RTL (dis & dit)
|
---|
4945 |
|
---|
4946 | return cellOffset;
|
---|
4947 | }
|
---|
4948 |
|
---|
4949 | // cell offset -> day offset
|
---|
4950 | function cellOffsetToDayOffset(cellOffset) {
|
---|
4951 | var day0 = t.visStart.getDay(); // first date's day of week
|
---|
4952 | cellOffset += dayToCellMap[day0]; // normlize cellOffset to beginning-of-week
|
---|
4953 | return Math.floor(cellOffset / cellsPerWeek) * 7 // # of days from full weeks
|
---|
4954 | + cellToDayMap[ // # of days from partial last week
|
---|
4955 | (cellOffset % cellsPerWeek + cellsPerWeek) % cellsPerWeek // crazy math to handle negative cellOffsets
|
---|
4956 | ]
|
---|
4957 | - day0; // adjustment for beginning-of-week normalization
|
---|
4958 | }
|
---|
4959 |
|
---|
4960 | // day offset -> date (JavaScript Date object)
|
---|
4961 | function dayOffsetToDate(dayOffset) {
|
---|
4962 | var date = cloneDate(t.visStart);
|
---|
4963 | addDays(date, dayOffset);
|
---|
4964 | return date;
|
---|
4965 | }
|
---|
4966 |
|
---|
4967 |
|
---|
4968 | //
|
---|
4969 | // TRANSFORMATIONS: date -> day offset -> cell offset -> cell
|
---|
4970 | //
|
---|
4971 |
|
---|
4972 | // date -> cell (combines all transformations)
|
---|
4973 | function dateToCell(date) {
|
---|
4974 | var dayOffset = dateToDayOffset(date);
|
---|
4975 | var cellOffset = dayOffsetToCellOffset(dayOffset);
|
---|
4976 | var cell = cellOffsetToCell(cellOffset);
|
---|
4977 | return cell;
|
---|
4978 | }
|
---|
4979 |
|
---|
4980 | // date -> day offset
|
---|
4981 | function dateToDayOffset(date) {
|
---|
4982 | return dayDiff(date, t.visStart);
|
---|
4983 | }
|
---|
4984 |
|
---|
4985 | // day offset -> cell offset
|
---|
4986 | function dayOffsetToCellOffset(dayOffset) {
|
---|
4987 | var day0 = t.visStart.getDay(); // first date's day of week
|
---|
4988 | dayOffset += day0; // normalize dayOffset to beginning-of-week
|
---|
4989 | return Math.floor(dayOffset / 7) * cellsPerWeek // # of cells from full weeks
|
---|
4990 | + dayToCellMap[ // # of cells from partial last week
|
---|
4991 | (dayOffset % 7 + 7) % 7 // crazy math to handle negative dayOffsets
|
---|
4992 | ]
|
---|
4993 | - dayToCellMap[day0]; // adjustment for beginning-of-week normalization
|
---|
4994 | }
|
---|
4995 |
|
---|
4996 | // cell offset -> cell (object with row & col keys)
|
---|
4997 | function cellOffsetToCell(cellOffset) {
|
---|
4998 | var colCnt = t.getColCnt();
|
---|
4999 |
|
---|
5000 | // rtl variables. wish we could pre-populate these. but where?
|
---|
5001 | var dis = isRTL ? -1 : 1;
|
---|
5002 | var dit = isRTL ? colCnt - 1 : 0;
|
---|
5003 |
|
---|
5004 | var row = Math.floor(cellOffset / colCnt);
|
---|
5005 | var col = ((cellOffset % colCnt + colCnt) % colCnt) * dis + dit; // column, adjusted for RTL (dis & dit)
|
---|
5006 | return {
|
---|
5007 | row: row,
|
---|
5008 | col: col
|
---|
5009 | };
|
---|
5010 | }
|
---|
5011 |
|
---|
5012 |
|
---|
5013 | //
|
---|
5014 | // Converts a date range into an array of segment objects.
|
---|
5015 | // "Segments" are horizontal stretches of time, sliced up by row.
|
---|
5016 | // A segment object has the following properties:
|
---|
5017 | // - row
|
---|
5018 | // - cols
|
---|
5019 | // - isStart
|
---|
5020 | // - isEnd
|
---|
5021 | //
|
---|
5022 | function rangeToSegments(startDate, endDate) {
|
---|
5023 | var rowCnt = t.getRowCnt();
|
---|
5024 | var colCnt = t.getColCnt();
|
---|
5025 | var segments = []; // array of segments to return
|
---|
5026 |
|
---|
5027 | // day offset for given date range
|
---|
5028 | var rangeDayOffsetStart = dateToDayOffset(startDate);
|
---|
5029 | var rangeDayOffsetEnd = dateToDayOffset(endDate); // exclusive
|
---|
5030 |
|
---|
5031 | // first and last cell offset for the given date range
|
---|
5032 | // "last" implies inclusivity
|
---|
5033 | var rangeCellOffsetFirst = dayOffsetToCellOffset(rangeDayOffsetStart);
|
---|
5034 | var rangeCellOffsetLast = dayOffsetToCellOffset(rangeDayOffsetEnd) - 1;
|
---|
5035 |
|
---|
5036 | // loop through all the rows in the view
|
---|
5037 | for (var row=0; row<rowCnt; row++) {
|
---|
5038 |
|
---|
5039 | // first and last cell offset for the row
|
---|
5040 | var rowCellOffsetFirst = row * colCnt;
|
---|
5041 | var rowCellOffsetLast = rowCellOffsetFirst + colCnt - 1;
|
---|
5042 |
|
---|
5043 | // get the segment's cell offsets by constraining the range's cell offsets to the bounds of the row
|
---|
5044 | var segmentCellOffsetFirst = Math.max(rangeCellOffsetFirst, rowCellOffsetFirst);
|
---|
5045 | var segmentCellOffsetLast = Math.min(rangeCellOffsetLast, rowCellOffsetLast);
|
---|
5046 |
|
---|
5047 | // make sure segment's offsets are valid and in view
|
---|
5048 | if (segmentCellOffsetFirst <= segmentCellOffsetLast) {
|
---|
5049 |
|
---|
5050 | // translate to cells
|
---|
5051 | var segmentCellFirst = cellOffsetToCell(segmentCellOffsetFirst);
|
---|
5052 | var segmentCellLast = cellOffsetToCell(segmentCellOffsetLast);
|
---|
5053 |
|
---|
5054 | // view might be RTL, so order by leftmost column
|
---|
5055 | var cols = [ segmentCellFirst.col, segmentCellLast.col ].sort();
|
---|
5056 |
|
---|
5057 | // Determine if segment's first/last cell is the beginning/end of the date range.
|
---|
5058 | // We need to compare "day offset" because "cell offsets" are often ambiguous and
|
---|
5059 | // can translate to multiple days, and an edge case reveals itself when we the
|
---|
5060 | // range's first cell is hidden (we don't want isStart to be true).
|
---|
5061 | var isStart = cellOffsetToDayOffset(segmentCellOffsetFirst) == rangeDayOffsetStart;
|
---|
5062 | var isEnd = cellOffsetToDayOffset(segmentCellOffsetLast) + 1 == rangeDayOffsetEnd; // +1 for comparing exclusively
|
---|
5063 |
|
---|
5064 | segments.push({
|
---|
5065 | row: row,
|
---|
5066 | leftCol: cols[0],
|
---|
5067 | rightCol: cols[1],
|
---|
5068 | isStart: isStart,
|
---|
5069 | isEnd: isEnd
|
---|
5070 | });
|
---|
5071 | }
|
---|
5072 | }
|
---|
5073 |
|
---|
5074 | return segments;
|
---|
5075 | }
|
---|
5076 |
|
---|
5077 |
|
---|
5078 | }
|
---|
5079 |
|
---|
5080 | ;;
|
---|
5081 |
|
---|
5082 | function DayEventRenderer() {
|
---|
5083 | var t = this;
|
---|
5084 |
|
---|
5085 |
|
---|
5086 | // exports
|
---|
5087 | t.renderDayEvents = renderDayEvents;
|
---|
5088 | t.draggableDayEvent = draggableDayEvent; // made public so that subclasses can override
|
---|
5089 | t.resizableDayEvent = resizableDayEvent; // "
|
---|
5090 |
|
---|
5091 |
|
---|
5092 | // imports
|
---|
5093 | var opt = t.opt;
|
---|
5094 | var trigger = t.trigger;
|
---|
5095 | var isEventDraggable = t.isEventDraggable;
|
---|
5096 | var isEventResizable = t.isEventResizable;
|
---|
5097 | var eventEnd = t.eventEnd;
|
---|
5098 | var reportEventElement = t.reportEventElement;
|
---|
5099 | var eventElementHandlers = t.eventElementHandlers;
|
---|
5100 | var showEvents = t.showEvents;
|
---|
5101 | var hideEvents = t.hideEvents;
|
---|
5102 | var eventDrop = t.eventDrop;
|
---|
5103 | var eventResize = t.eventResize;
|
---|
5104 | var getRowCnt = t.getRowCnt;
|
---|
5105 | var getColCnt = t.getColCnt;
|
---|
5106 | var getColWidth = t.getColWidth;
|
---|
5107 | var allDayRow = t.allDayRow; // TODO: rename
|
---|
5108 | var colLeft = t.colLeft;
|
---|
5109 | var colRight = t.colRight;
|
---|
5110 | var colContentLeft = t.colContentLeft;
|
---|
5111 | var colContentRight = t.colContentRight;
|
---|
5112 | var dateToCell = t.dateToCell;
|
---|
5113 | var getDaySegmentContainer = t.getDaySegmentContainer;
|
---|
5114 | var formatDates = t.calendar.formatDates;
|
---|
5115 | var renderDayOverlay = t.renderDayOverlay;
|
---|
5116 | var clearOverlays = t.clearOverlays;
|
---|
5117 | var clearSelection = t.clearSelection;
|
---|
5118 | var getHoverListener = t.getHoverListener;
|
---|
5119 | var rangeToSegments = t.rangeToSegments;
|
---|
5120 | var cellToDate = t.cellToDate;
|
---|
5121 | var cellToCellOffset = t.cellToCellOffset;
|
---|
5122 | var cellOffsetToDayOffset = t.cellOffsetToDayOffset;
|
---|
5123 | var dateToDayOffset = t.dateToDayOffset;
|
---|
5124 | var dayOffsetToCellOffset = t.dayOffsetToCellOffset;
|
---|
5125 |
|
---|
5126 |
|
---|
5127 | // Render `events` onto the calendar, attach mouse event handlers, and call the `eventAfterRender` callback for each.
|
---|
5128 | // Mouse event will be lazily applied, except if the event has an ID of `modifiedEventId`.
|
---|
5129 | // Can only be called when the event container is empty (because it wipes out all innerHTML).
|
---|
5130 | function renderDayEvents(events, modifiedEventId) {
|
---|
5131 |
|
---|
5132 | // do the actual rendering. Receive the intermediate "segment" data structures.
|
---|
5133 | var segments = _renderDayEvents(
|
---|
5134 | events,
|
---|
5135 | false, // don't append event elements
|
---|
5136 | true // set the heights of the rows
|
---|
5137 | );
|
---|
5138 |
|
---|
5139 | // report the elements to the View, for general drag/resize utilities
|
---|
5140 | segmentElementEach(segments, function(segment, element) {
|
---|
5141 | reportEventElement(segment.event, element);
|
---|
5142 | });
|
---|
5143 |
|
---|
5144 | // attach mouse handlers
|
---|
5145 | attachHandlers(segments, modifiedEventId);
|
---|
5146 |
|
---|
5147 | // call `eventAfterRender` callback for each event
|
---|
5148 | segmentElementEach(segments, function(segment, element) {
|
---|
5149 | trigger('eventAfterRender', segment.event, segment.event, element);
|
---|
5150 | });
|
---|
5151 | }
|
---|
5152 |
|
---|
5153 |
|
---|
5154 | // Render an event on the calendar, but don't report them anywhere, and don't attach mouse handlers.
|
---|
5155 | // Append this event element to the event container, which might already be populated with events.
|
---|
5156 | // If an event's segment will have row equal to `adjustRow`, then explicitly set its top coordinate to `adjustTop`.
|
---|
5157 | // This hack is used to maintain continuity when user is manually resizing an event.
|
---|
5158 | // Returns an array of DOM elements for the event.
|
---|
5159 | function renderTempDayEvent(event, adjustRow, adjustTop) {
|
---|
5160 |
|
---|
5161 | // actually render the event. `true` for appending element to container.
|
---|
5162 | // Recieve the intermediate "segment" data structures.
|
---|
5163 | var segments = _renderDayEvents(
|
---|
5164 | [ event ],
|
---|
5165 | true, // append event elements
|
---|
5166 | false // don't set the heights of the rows
|
---|
5167 | );
|
---|
5168 |
|
---|
5169 | var elements = [];
|
---|
5170 |
|
---|
5171 | // Adjust certain elements' top coordinates
|
---|
5172 | segmentElementEach(segments, function(segment, element) {
|
---|
5173 | if (segment.row === adjustRow) {
|
---|
5174 | element.css('top', adjustTop);
|
---|
5175 | }
|
---|
5176 | elements.push(element[0]); // accumulate DOM nodes
|
---|
5177 | });
|
---|
5178 |
|
---|
5179 | return elements;
|
---|
5180 | }
|
---|
5181 |
|
---|
5182 |
|
---|
5183 | // Render events onto the calendar. Only responsible for the VISUAL aspect.
|
---|
5184 | // Not responsible for attaching handlers or calling callbacks.
|
---|
5185 | // Set `doAppend` to `true` for rendering elements without clearing the existing container.
|
---|
5186 | // Set `doRowHeights` to allow setting the height of each row, to compensate for vertical event overflow.
|
---|
5187 | function _renderDayEvents(events, doAppend, doRowHeights) {
|
---|
5188 |
|
---|
5189 | // where the DOM nodes will eventually end up
|
---|
5190 | var finalContainer = getDaySegmentContainer();
|
---|
5191 |
|
---|
5192 | // the container where the initial HTML will be rendered.
|
---|
5193 | // If `doAppend`==true, uses a temporary container.
|
---|
5194 | var renderContainer = doAppend ? $("<div/>") : finalContainer;
|
---|
5195 |
|
---|
5196 | var segments = buildSegments(events);
|
---|
5197 | var html;
|
---|
5198 | var elements;
|
---|
5199 |
|
---|
5200 | // calculate the desired `left` and `width` properties on each segment object
|
---|
5201 | calculateHorizontals(segments);
|
---|
5202 |
|
---|
5203 | // build the HTML string. relies on `left` property
|
---|
5204 | html = buildHTML(segments);
|
---|
5205 |
|
---|
5206 | // render the HTML. innerHTML is considerably faster than jQuery's .html()
|
---|
5207 | renderContainer[0].innerHTML = html;
|
---|
5208 |
|
---|
5209 | // retrieve the individual elements
|
---|
5210 | elements = renderContainer.children();
|
---|
5211 |
|
---|
5212 | // if we were appending, and thus using a temporary container,
|
---|
5213 | // re-attach elements to the real container.
|
---|
5214 | if (doAppend) {
|
---|
5215 | finalContainer.append(elements);
|
---|
5216 | }
|
---|
5217 |
|
---|
5218 | // assigns each element to `segment.event`, after filtering them through user callbacks
|
---|
5219 | resolveElements(segments, elements);
|
---|
5220 |
|
---|
5221 | // Calculate the left and right padding+margin for each element.
|
---|
5222 | // We need this for setting each element's desired outer width, because of the W3C box model.
|
---|
5223 | // It's important we do this in a separate pass from acually setting the width on the DOM elements
|
---|
5224 | // because alternating reading/writing dimensions causes reflow for every iteration.
|
---|
5225 | segmentElementEach(segments, function(segment, element) {
|
---|
5226 | segment.hsides = hsides(element, true); // include margins = `true`
|
---|
5227 | });
|
---|
5228 |
|
---|
5229 | // Set the width of each element
|
---|
5230 | segmentElementEach(segments, function(segment, element) {
|
---|
5231 | element.width(
|
---|
5232 | Math.max(0, segment.outerWidth - segment.hsides)
|
---|
5233 | );
|
---|
5234 | });
|
---|
5235 |
|
---|
5236 | // Grab each element's outerHeight (setVerticals uses this).
|
---|
5237 | // To get an accurate reading, it's important to have each element's width explicitly set already.
|
---|
5238 | segmentElementEach(segments, function(segment, element) {
|
---|
5239 | segment.outerHeight = element.outerHeight(true); // include margins = `true`
|
---|
5240 | });
|
---|
5241 |
|
---|
5242 | // Set the top coordinate on each element (requires segment.outerHeight)
|
---|
5243 | setVerticals(segments, doRowHeights);
|
---|
5244 |
|
---|
5245 | return segments;
|
---|
5246 | }
|
---|
5247 |
|
---|
5248 |
|
---|
5249 | // Generate an array of "segments" for all events.
|
---|
5250 | function buildSegments(events) {
|
---|
5251 | var segments = [];
|
---|
5252 | for (var i=0; i<events.length; i++) {
|
---|
5253 | var eventSegments = buildSegmentsForEvent(events[i]);
|
---|
5254 | segments.push.apply(segments, eventSegments); // append an array to an array
|
---|
5255 | }
|
---|
5256 | return segments;
|
---|
5257 | }
|
---|
5258 |
|
---|
5259 |
|
---|
5260 | // Generate an array of segments for a single event.
|
---|
5261 | // A "segment" is the same data structure that View.rangeToSegments produces,
|
---|
5262 | // with the addition of the `event` property being set to reference the original event.
|
---|
5263 | function buildSegmentsForEvent(event) {
|
---|
5264 | var startDate = event.start;
|
---|
5265 | var endDate = exclEndDay(event);
|
---|
5266 | var segments = rangeToSegments(startDate, endDate);
|
---|
5267 | for (var i=0; i<segments.length; i++) {
|
---|
5268 | segments[i].event = event;
|
---|
5269 | }
|
---|
5270 | return segments;
|
---|
5271 | }
|
---|
5272 |
|
---|
5273 |
|
---|
5274 | // Sets the `left` and `outerWidth` property of each segment.
|
---|
5275 | // These values are the desired dimensions for the eventual DOM elements.
|
---|
5276 | function calculateHorizontals(segments) {
|
---|
5277 | var isRTL = opt('isRTL');
|
---|
5278 | for (var i=0; i<segments.length; i++) {
|
---|
5279 | var segment = segments[i];
|
---|
5280 |
|
---|
5281 | // Determine functions used for calulating the elements left/right coordinates,
|
---|
5282 | // depending on whether the view is RTL or not.
|
---|
5283 | // NOTE:
|
---|
5284 | // colLeft/colRight returns the coordinate butting up the edge of the cell.
|
---|
5285 | // colContentLeft/colContentRight is indented a little bit from the edge.
|
---|
5286 | var leftFunc = (isRTL ? segment.isEnd : segment.isStart) ? colContentLeft : colLeft;
|
---|
5287 | var rightFunc = (isRTL ? segment.isStart : segment.isEnd) ? colContentRight : colRight;
|
---|
5288 |
|
---|
5289 | var left = leftFunc(segment.leftCol);
|
---|
5290 | var right = rightFunc(segment.rightCol);
|
---|
5291 | segment.left = left;
|
---|
5292 | segment.outerWidth = right - left;
|
---|
5293 | }
|
---|
5294 | }
|
---|
5295 |
|
---|
5296 |
|
---|
5297 | // Build a concatenated HTML string for an array of segments
|
---|
5298 | function buildHTML(segments) {
|
---|
5299 | var html = '';
|
---|
5300 | for (var i=0; i<segments.length; i++) {
|
---|
5301 | html += buildHTMLForSegment(segments[i]);
|
---|
5302 | }
|
---|
5303 | return html;
|
---|
5304 | }
|
---|
5305 |
|
---|
5306 |
|
---|
5307 | // Build an HTML string for a single segment.
|
---|
5308 | // Relies on the following properties:
|
---|
5309 | // - `segment.event` (from `buildSegmentsForEvent`)
|
---|
5310 | // - `segment.left` (from `calculateHorizontals`)
|
---|
5311 | function buildHTMLForSegment(segment) {
|
---|
5312 | var html = '';
|
---|
5313 | var isRTL = opt('isRTL');
|
---|
5314 | var event = segment.event;
|
---|
5315 | var url = event.url;
|
---|
5316 |
|
---|
5317 | // generate the list of CSS classNames
|
---|
5318 | var classNames = [ 'fc-event', 'fc-event-hori' ];
|
---|
5319 | if (isEventDraggable(event)) {
|
---|
5320 | classNames.push('fc-event-draggable');
|
---|
5321 | }
|
---|
5322 | if (segment.isStart) {
|
---|
5323 | classNames.push('fc-event-start');
|
---|
5324 | }
|
---|
5325 | if (segment.isEnd) {
|
---|
5326 | classNames.push('fc-event-end');
|
---|
5327 | }
|
---|
5328 | // use the event's configured classNames
|
---|
5329 | // guaranteed to be an array via `normalizeEvent`
|
---|
5330 | classNames = classNames.concat(event.className);
|
---|
5331 | if (event.source) {
|
---|
5332 | // use the event's source's classNames, if specified
|
---|
5333 | classNames = classNames.concat(event.source.className || []);
|
---|
5334 | }
|
---|
5335 |
|
---|
5336 | // generate a semicolon delimited CSS string for any of the "skin" properties
|
---|
5337 | // of the event object (`backgroundColor`, `borderColor` and such)
|
---|
5338 | var skinCss = getSkinCss(event, opt);
|
---|
5339 |
|
---|
5340 | if (url) {
|
---|
5341 | html += "<a href='" + htmlEscape(url) + "'";
|
---|
5342 | }else{
|
---|
5343 | html += "<div";
|
---|
5344 | }
|
---|
5345 | html +=
|
---|
5346 | " class='" + classNames.join(' ') + "'" +
|
---|
5347 | " style=" +
|
---|
5348 | "'" +
|
---|
5349 | "position:absolute;" +
|
---|
5350 | "left:" + segment.left + "px;" +
|
---|
5351 | skinCss +
|
---|
5352 | "'" +
|
---|
5353 | ">" +
|
---|
5354 | "<div class='fc-event-inner'>";
|
---|
5355 | if (!event.allDay && segment.isStart) {
|
---|
5356 | html +=
|
---|
5357 | "<span class='fc-event-time'>" +
|
---|
5358 | htmlEscape(
|
---|
5359 | formatDates(event.start, event.end, opt('timeFormat'))
|
---|
5360 | ) +
|
---|
5361 | "</span>";
|
---|
5362 | }
|
---|
5363 | html +=
|
---|
5364 | "<span class='fc-event-title'>" +
|
---|
5365 | htmlEscape(event.title || '') +
|
---|
5366 | "</span>" +
|
---|
5367 | "</div>";
|
---|
5368 | if (segment.isEnd && isEventResizable(event)) {
|
---|
5369 | html +=
|
---|
5370 | "<div class='ui-resizable-handle ui-resizable-" + (isRTL ? 'w' : 'e') + "'>" +
|
---|
5371 | " " + // makes hit area a lot better for IE6/7
|
---|
5372 | "</div>";
|
---|
5373 | }
|
---|
5374 | html += "</" + (url ? "a" : "div") + ">";
|
---|
5375 |
|
---|
5376 | // TODO:
|
---|
5377 | // When these elements are initially rendered, they will be briefly visibile on the screen,
|
---|
5378 | // even though their widths/heights are not set.
|
---|
5379 | // SOLUTION: initially set them as visibility:hidden ?
|
---|
5380 |
|
---|
5381 | return html;
|
---|
5382 | }
|
---|
5383 |
|
---|
5384 |
|
---|
5385 | // Associate each segment (an object) with an element (a jQuery object),
|
---|
5386 | // by setting each `segment.element`.
|
---|
5387 | // Run each element through the `eventRender` filter, which allows developers to
|
---|
5388 | // modify an existing element, supply a new one, or cancel rendering.
|
---|
5389 | function resolveElements(segments, elements) {
|
---|
5390 | for (var i=0; i<segments.length; i++) {
|
---|
5391 | var segment = segments[i];
|
---|
5392 | var event = segment.event;
|
---|
5393 | var element = elements.eq(i);
|
---|
5394 |
|
---|
5395 | // call the trigger with the original element
|
---|
5396 | var triggerRes = trigger('eventRender', event, event, element);
|
---|
5397 |
|
---|
5398 | if (triggerRes === false) {
|
---|
5399 | // if `false`, remove the event from the DOM and don't assign it to `segment.event`
|
---|
5400 | element.remove();
|
---|
5401 | }
|
---|
5402 | else {
|
---|
5403 | if (triggerRes && triggerRes !== true) {
|
---|
5404 | // the trigger returned a new element, but not `true` (which means keep the existing element)
|
---|
5405 |
|
---|
5406 | // re-assign the important CSS dimension properties that were already assigned in `buildHTMLForSegment`
|
---|
5407 | triggerRes = $(triggerRes)
|
---|
5408 | .css({
|
---|
5409 | position: 'absolute',
|
---|
5410 | left: segment.left
|
---|
5411 | });
|
---|
5412 |
|
---|
5413 | element.replaceWith(triggerRes);
|
---|
5414 | element = triggerRes;
|
---|
5415 | }
|
---|
5416 |
|
---|
5417 | segment.element = element;
|
---|
5418 | }
|
---|
5419 | }
|
---|
5420 | }
|
---|
5421 |
|
---|
5422 |
|
---|
5423 |
|
---|
5424 | /* Top-coordinate Methods
|
---|
5425 | -------------------------------------------------------------------------------------------------*/
|
---|
5426 |
|
---|
5427 |
|
---|
5428 | // Sets the "top" CSS property for each element.
|
---|
5429 | // If `doRowHeights` is `true`, also sets each row's first cell to an explicit height,
|
---|
5430 | // so that if elements vertically overflow, the cell expands vertically to compensate.
|
---|
5431 | function setVerticals(segments, doRowHeights) {
|
---|
5432 | var rowContentHeights = calculateVerticals(segments); // also sets segment.top
|
---|
5433 | var rowContentElements = getRowContentElements(); // returns 1 inner div per row
|
---|
5434 | var rowContentTops = [];
|
---|
5435 |
|
---|
5436 | // Set each row's height by setting height of first inner div
|
---|
5437 | if (doRowHeights) {
|
---|
5438 | for (var i=0; i<rowContentElements.length; i++) {
|
---|
5439 | rowContentElements[i].height(rowContentHeights[i]);
|
---|
5440 | }
|
---|
5441 | }
|
---|
5442 |
|
---|
5443 | // Get each row's top, relative to the views's origin.
|
---|
5444 | // Important to do this after setting each row's height.
|
---|
5445 | for (var i=0; i<rowContentElements.length; i++) {
|
---|
5446 | rowContentTops.push(
|
---|
5447 | rowContentElements[i].position().top
|
---|
5448 | );
|
---|
5449 | }
|
---|
5450 |
|
---|
5451 | // Set each segment element's CSS "top" property.
|
---|
5452 | // Each segment object has a "top" property, which is relative to the row's top, but...
|
---|
5453 | segmentElementEach(segments, function(segment, element) {
|
---|
5454 | element.css(
|
---|
5455 | 'top',
|
---|
5456 | rowContentTops[segment.row] + segment.top // ...now, relative to views's origin
|
---|
5457 | );
|
---|
5458 | });
|
---|
5459 | }
|
---|
5460 |
|
---|
5461 |
|
---|
5462 | // Calculate the "top" coordinate for each segment, relative to the "top" of the row.
|
---|
5463 | // Also, return an array that contains the "content" height for each row
|
---|
5464 | // (the height displaced by the vertically stacked events in the row).
|
---|
5465 | // Requires segments to have their `outerHeight` property already set.
|
---|
5466 | function calculateVerticals(segments) {
|
---|
5467 | var rowCnt = getRowCnt();
|
---|
5468 | var colCnt = getColCnt();
|
---|
5469 | var rowContentHeights = []; // content height for each row
|
---|
5470 | var segmentRows = buildSegmentRows(segments); // an array of segment arrays, one for each row
|
---|
5471 |
|
---|
5472 | for (var rowI=0; rowI<rowCnt; rowI++) {
|
---|
5473 | var segmentRow = segmentRows[rowI];
|
---|
5474 |
|
---|
5475 | // an array of running total heights for each column.
|
---|
5476 | // initialize with all zeros.
|
---|
5477 | var colHeights = [];
|
---|
5478 | for (var colI=0; colI<colCnt; colI++) {
|
---|
5479 | colHeights.push(0);
|
---|
5480 | }
|
---|
5481 |
|
---|
5482 | // loop through every segment
|
---|
5483 | for (var segmentI=0; segmentI<segmentRow.length; segmentI++) {
|
---|
5484 | var segment = segmentRow[segmentI];
|
---|
5485 |
|
---|
5486 | // find the segment's top coordinate by looking at the max height
|
---|
5487 | // of all the columns the segment will be in.
|
---|
5488 | segment.top = arrayMax(
|
---|
5489 | colHeights.slice(
|
---|
5490 | segment.leftCol,
|
---|
5491 | segment.rightCol + 1 // make exclusive for slice
|
---|
5492 | )
|
---|
5493 | );
|
---|
5494 |
|
---|
5495 | // adjust the columns to account for the segment's height
|
---|
5496 | for (var colI=segment.leftCol; colI<=segment.rightCol; colI++) {
|
---|
5497 | colHeights[colI] = segment.top + segment.outerHeight;
|
---|
5498 | }
|
---|
5499 | }
|
---|
5500 |
|
---|
5501 | // the tallest column in the row should be the "content height"
|
---|
5502 | rowContentHeights.push(arrayMax(colHeights));
|
---|
5503 | }
|
---|
5504 |
|
---|
5505 | return rowContentHeights;
|
---|
5506 | }
|
---|
5507 |
|
---|
5508 |
|
---|
5509 | // Build an array of segment arrays, each representing the segments that will
|
---|
5510 | // be in a row of the grid, sorted by which event should be closest to the top.
|
---|
5511 | function buildSegmentRows(segments) {
|
---|
5512 | var rowCnt = getRowCnt();
|
---|
5513 | var segmentRows = [];
|
---|
5514 | var segmentI;
|
---|
5515 | var segment;
|
---|
5516 | var rowI;
|
---|
5517 |
|
---|
5518 | // group segments by row
|
---|
5519 | for (segmentI=0; segmentI<segments.length; segmentI++) {
|
---|
5520 | segment = segments[segmentI];
|
---|
5521 | rowI = segment.row;
|
---|
5522 | if (segment.element) { // was rendered?
|
---|
5523 | if (segmentRows[rowI]) {
|
---|
5524 | // already other segments. append to array
|
---|
5525 | segmentRows[rowI].push(segment);
|
---|
5526 | }
|
---|
5527 | else {
|
---|
5528 | // first segment in row. create new array
|
---|
5529 | segmentRows[rowI] = [ segment ];
|
---|
5530 | }
|
---|
5531 | }
|
---|
5532 | }
|
---|
5533 |
|
---|
5534 | // sort each row
|
---|
5535 | for (rowI=0; rowI<rowCnt; rowI++) {
|
---|
5536 | segmentRows[rowI] = sortSegmentRow(
|
---|
5537 | segmentRows[rowI] || [] // guarantee an array, even if no segments
|
---|
5538 | );
|
---|
5539 | }
|
---|
5540 |
|
---|
5541 | return segmentRows;
|
---|
5542 | }
|
---|
5543 |
|
---|
5544 |
|
---|
5545 | // Sort an array of segments according to which segment should appear closest to the top
|
---|
5546 | function sortSegmentRow(segments) {
|
---|
5547 | var sortedSegments = [];
|
---|
5548 |
|
---|
5549 | // build the subrow array
|
---|
5550 | var subrows = buildSegmentSubrows(segments);
|
---|
5551 |
|
---|
5552 | // flatten it
|
---|
5553 | for (var i=0; i<subrows.length; i++) {
|
---|
5554 | sortedSegments.push.apply(sortedSegments, subrows[i]); // append an array to an array
|
---|
5555 | }
|
---|
5556 |
|
---|
5557 | return sortedSegments;
|
---|
5558 | }
|
---|
5559 |
|
---|
5560 |
|
---|
5561 | // Take an array of segments, which are all assumed to be in the same row,
|
---|
5562 | // and sort into subrows.
|
---|
5563 | function buildSegmentSubrows(segments) {
|
---|
5564 |
|
---|
5565 | // Give preference to elements with certain criteria, so they have
|
---|
5566 | // a chance to be closer to the top.
|
---|
5567 | segments.sort(compareDaySegments);
|
---|
5568 |
|
---|
5569 | var subrows = [];
|
---|
5570 | for (var i=0; i<segments.length; i++) {
|
---|
5571 | var segment = segments[i];
|
---|
5572 |
|
---|
5573 | // loop through subrows, starting with the topmost, until the segment
|
---|
5574 | // doesn't collide with other segments.
|
---|
5575 | for (var j=0; j<subrows.length; j++) {
|
---|
5576 | if (!isDaySegmentCollision(segment, subrows[j])) {
|
---|
5577 | break;
|
---|
5578 | }
|
---|
5579 | }
|
---|
5580 | // `j` now holds the desired subrow index
|
---|
5581 | if (subrows[j]) {
|
---|
5582 | subrows[j].push(segment);
|
---|
5583 | }
|
---|
5584 | else {
|
---|
5585 | subrows[j] = [ segment ];
|
---|
5586 | }
|
---|
5587 | }
|
---|
5588 |
|
---|
5589 | return subrows;
|
---|
5590 | }
|
---|
5591 |
|
---|
5592 |
|
---|
5593 | // Return an array of jQuery objects for the placeholder content containers of each row.
|
---|
5594 | // The content containers don't actually contain anything, but their dimensions should match
|
---|
5595 | // the events that are overlaid on top.
|
---|
5596 | function getRowContentElements() {
|
---|
5597 | var i;
|
---|
5598 | var rowCnt = getRowCnt();
|
---|
5599 | var rowDivs = [];
|
---|
5600 | for (i=0; i<rowCnt; i++) {
|
---|
5601 | rowDivs[i] = allDayRow(i)
|
---|
5602 | .find('div.fc-day-content > div');
|
---|
5603 | }
|
---|
5604 | return rowDivs;
|
---|
5605 | }
|
---|
5606 |
|
---|
5607 |
|
---|
5608 |
|
---|
5609 | /* Mouse Handlers
|
---|
5610 | ---------------------------------------------------------------------------------------------------*/
|
---|
5611 | // TODO: better documentation!
|
---|
5612 |
|
---|
5613 |
|
---|
5614 | function attachHandlers(segments, modifiedEventId) {
|
---|
5615 | var segmentContainer = getDaySegmentContainer();
|
---|
5616 |
|
---|
5617 | segmentElementEach(segments, function(segment, element, i) {
|
---|
5618 | var event = segment.event;
|
---|
5619 | if (event._id === modifiedEventId) {
|
---|
5620 | bindDaySeg(event, element, segment);
|
---|
5621 | }else{
|
---|
5622 | element[0]._fci = i; // for lazySegBind
|
---|
5623 | }
|
---|
5624 | });
|
---|
5625 |
|
---|
5626 | lazySegBind(segmentContainer, segments, bindDaySeg);
|
---|
5627 | }
|
---|
5628 |
|
---|
5629 |
|
---|
5630 | function bindDaySeg(event, eventElement, segment) {
|
---|
5631 |
|
---|
5632 | if (isEventDraggable(event)) {
|
---|
5633 | t.draggableDayEvent(event, eventElement, segment); // use `t` so subclasses can override
|
---|
5634 | }
|
---|
5635 |
|
---|
5636 | if (
|
---|
5637 | segment.isEnd && // only allow resizing on the final segment for an event
|
---|
5638 | isEventResizable(event)
|
---|
5639 | ) {
|
---|
5640 | t.resizableDayEvent(event, eventElement, segment); // use `t` so subclasses can override
|
---|
5641 | }
|
---|
5642 |
|
---|
5643 | // attach all other handlers.
|
---|
5644 | // needs to be after, because resizableDayEvent might stopImmediatePropagation on click
|
---|
5645 | eventElementHandlers(event, eventElement);
|
---|
5646 | }
|
---|
5647 |
|
---|
5648 |
|
---|
5649 | function draggableDayEvent(event, eventElement) {
|
---|
5650 | var hoverListener = getHoverListener();
|
---|
5651 | var dayDelta;
|
---|
5652 | eventElement.draggable({
|
---|
5653 | delay: 50,
|
---|
5654 | opacity: opt('dragOpacity'),
|
---|
5655 | revertDuration: opt('dragRevertDuration'),
|
---|
5656 | start: function(ev, ui) {
|
---|
5657 | trigger('eventDragStart', eventElement, event, ev, ui);
|
---|
5658 | hideEvents(event, eventElement);
|
---|
5659 | hoverListener.start(function(cell, origCell, rowDelta, colDelta) {
|
---|
5660 | eventElement.draggable('option', 'revert', !cell || !rowDelta && !colDelta);
|
---|
5661 | clearOverlays();
|
---|
5662 | if (cell) {
|
---|
5663 | var origDate = cellToDate(origCell);
|
---|
5664 | var date = cellToDate(cell);
|
---|
5665 | dayDelta = dayDiff(date, origDate);
|
---|
5666 | renderDayOverlay(
|
---|
5667 | addDays(cloneDate(event.start), dayDelta),
|
---|
5668 | addDays(exclEndDay(event), dayDelta)
|
---|
5669 | );
|
---|
5670 | }else{
|
---|
5671 | dayDelta = 0;
|
---|
5672 | }
|
---|
5673 | }, ev, 'drag');
|
---|
5674 | },
|
---|
5675 | stop: function(ev, ui) {
|
---|
5676 | hoverListener.stop();
|
---|
5677 | clearOverlays();
|
---|
5678 | trigger('eventDragStop', eventElement, event, ev, ui);
|
---|
5679 | if (dayDelta) {
|
---|
5680 | eventDrop(this, event, dayDelta, 0, event.allDay, ev, ui);
|
---|
5681 | }else{
|
---|
5682 | eventElement.css('filter', ''); // clear IE opacity side-effects
|
---|
5683 | showEvents(event, eventElement);
|
---|
5684 | }
|
---|
5685 | }
|
---|
5686 | });
|
---|
5687 | }
|
---|
5688 |
|
---|
5689 |
|
---|
5690 | function resizableDayEvent(event, element, segment) {
|
---|
5691 | var isRTL = opt('isRTL');
|
---|
5692 | var direction = isRTL ? 'w' : 'e';
|
---|
5693 | var handle = element.find('.ui-resizable-' + direction); // TODO: stop using this class because we aren't using jqui for this
|
---|
5694 | var isResizing = false;
|
---|
5695 |
|
---|
5696 | // TODO: look into using jquery-ui mouse widget for this stuff
|
---|
5697 | disableTextSelection(element); // prevent native <a> selection for IE
|
---|
5698 | element
|
---|
5699 | .mousedown(function(ev) { // prevent native <a> selection for others
|
---|
5700 | ev.preventDefault();
|
---|
5701 | })
|
---|
5702 | .click(function(ev) {
|
---|
5703 | if (isResizing) {
|
---|
5704 | ev.preventDefault(); // prevent link from being visited (only method that worked in IE6)
|
---|
5705 | ev.stopImmediatePropagation(); // prevent fullcalendar eventClick handler from being called
|
---|
5706 | // (eventElementHandlers needs to be bound after resizableDayEvent)
|
---|
5707 | }
|
---|
5708 | });
|
---|
5709 |
|
---|
5710 | handle.mousedown(function(ev) {
|
---|
5711 | if (ev.which != 1) {
|
---|
5712 | return; // needs to be left mouse button
|
---|
5713 | }
|
---|
5714 | isResizing = true;
|
---|
5715 | var hoverListener = getHoverListener();
|
---|
5716 | var rowCnt = getRowCnt();
|
---|
5717 | var colCnt = getColCnt();
|
---|
5718 | var elementTop = element.css('top');
|
---|
5719 | var dayDelta;
|
---|
5720 | var helpers;
|
---|
5721 | var eventCopy = $.extend({}, event);
|
---|
5722 | var minCellOffset = dayOffsetToCellOffset( dateToDayOffset(event.start) );
|
---|
5723 | clearSelection();
|
---|
5724 | $('body')
|
---|
5725 | .css('cursor', direction + '-resize')
|
---|
5726 | .one('mouseup', mouseup);
|
---|
5727 | trigger('eventResizeStart', this, event, ev);
|
---|
5728 | hoverListener.start(function(cell, origCell) {
|
---|
5729 | if (cell) {
|
---|
5730 |
|
---|
5731 | var origCellOffset = cellToCellOffset(origCell);
|
---|
5732 | var cellOffset = cellToCellOffset(cell);
|
---|
5733 |
|
---|
5734 | // don't let resizing move earlier than start date cell
|
---|
5735 | cellOffset = Math.max(cellOffset, minCellOffset);
|
---|
5736 |
|
---|
5737 | dayDelta =
|
---|
5738 | cellOffsetToDayOffset(cellOffset) -
|
---|
5739 | cellOffsetToDayOffset(origCellOffset);
|
---|
5740 |
|
---|
5741 | if (dayDelta) {
|
---|
5742 | eventCopy.end = addDays(eventEnd(event), dayDelta, true);
|
---|
5743 | var oldHelpers = helpers;
|
---|
5744 |
|
---|
5745 | helpers = renderTempDayEvent(eventCopy, segment.row, elementTop);
|
---|
5746 | helpers = $(helpers); // turn array into a jQuery object
|
---|
5747 |
|
---|
5748 | helpers.find('*').css('cursor', direction + '-resize');
|
---|
5749 | if (oldHelpers) {
|
---|
5750 | oldHelpers.remove();
|
---|
5751 | }
|
---|
5752 |
|
---|
5753 | hideEvents(event);
|
---|
5754 | }
|
---|
5755 | else {
|
---|
5756 | if (helpers) {
|
---|
5757 | showEvents(event);
|
---|
5758 | helpers.remove();
|
---|
5759 | helpers = null;
|
---|
5760 | }
|
---|
5761 | }
|
---|
5762 | clearOverlays();
|
---|
5763 | renderDayOverlay( // coordinate grid already rebuilt with hoverListener.start()
|
---|
5764 | event.start,
|
---|
5765 | addDays( exclEndDay(event), dayDelta )
|
---|
5766 | // TODO: instead of calling renderDayOverlay() with dates,
|
---|
5767 | // call _renderDayOverlay (or whatever) with cell offsets.
|
---|
5768 | );
|
---|
5769 | }
|
---|
5770 | }, ev);
|
---|
5771 |
|
---|
5772 | function mouseup(ev) {
|
---|
5773 | trigger('eventResizeStop', this, event, ev);
|
---|
5774 | $('body').css('cursor', '');
|
---|
5775 | hoverListener.stop();
|
---|
5776 | clearOverlays();
|
---|
5777 | if (dayDelta) {
|
---|
5778 | eventResize(this, event, dayDelta, 0, ev);
|
---|
5779 | // event redraw will clear helpers
|
---|
5780 | }
|
---|
5781 | // otherwise, the drag handler already restored the old events
|
---|
5782 |
|
---|
5783 | setTimeout(function() { // make this happen after the element's click event
|
---|
5784 | isResizing = false;
|
---|
5785 | },0);
|
---|
5786 | }
|
---|
5787 | });
|
---|
5788 | }
|
---|
5789 |
|
---|
5790 |
|
---|
5791 | }
|
---|
5792 |
|
---|
5793 |
|
---|
5794 |
|
---|
5795 | /* Generalized Segment Utilities
|
---|
5796 | -------------------------------------------------------------------------------------------------*/
|
---|
5797 |
|
---|
5798 |
|
---|
5799 | function isDaySegmentCollision(segment, otherSegments) {
|
---|
5800 | for (var i=0; i<otherSegments.length; i++) {
|
---|
5801 | var otherSegment = otherSegments[i];
|
---|
5802 | if (
|
---|
5803 | otherSegment.leftCol <= segment.rightCol &&
|
---|
5804 | otherSegment.rightCol >= segment.leftCol
|
---|
5805 | ) {
|
---|
5806 | return true;
|
---|
5807 | }
|
---|
5808 | }
|
---|
5809 | return false;
|
---|
5810 | }
|
---|
5811 |
|
---|
5812 |
|
---|
5813 | function segmentElementEach(segments, callback) { // TODO: use in AgendaView?
|
---|
5814 | for (var i=0; i<segments.length; i++) {
|
---|
5815 | var segment = segments[i];
|
---|
5816 | var element = segment.element;
|
---|
5817 | if (element) {
|
---|
5818 | callback(segment, element, i);
|
---|
5819 | }
|
---|
5820 | }
|
---|
5821 | }
|
---|
5822 |
|
---|
5823 |
|
---|
5824 | // A cmp function for determining which segments should appear higher up
|
---|
5825 | function compareDaySegments(a, b) {
|
---|
5826 | return (b.rightCol - b.leftCol) - (a.rightCol - a.leftCol) || // put wider events first
|
---|
5827 | b.event.allDay - a.event.allDay || // if tie, put all-day events first (booleans cast to 0/1)
|
---|
5828 | a.event.start - b.event.start || // if a tie, sort by event start date
|
---|
5829 | (a.event.title || '').localeCompare(b.event.title) // if a tie, sort by event title
|
---|
5830 | }
|
---|
5831 |
|
---|
5832 |
|
---|
5833 | ;;
|
---|
5834 |
|
---|
5835 | //BUG: unselect needs to be triggered when events are dragged+dropped
|
---|
5836 |
|
---|
5837 | function SelectionManager() {
|
---|
5838 | var t = this;
|
---|
5839 |
|
---|
5840 |
|
---|
5841 | // exports
|
---|
5842 | t.select = select;
|
---|
5843 | t.unselect = unselect;
|
---|
5844 | t.reportSelection = reportSelection;
|
---|
5845 | t.daySelectionMousedown = daySelectionMousedown;
|
---|
5846 |
|
---|
5847 |
|
---|
5848 | // imports
|
---|
5849 | var opt = t.opt;
|
---|
5850 | var trigger = t.trigger;
|
---|
5851 | var defaultSelectionEnd = t.defaultSelectionEnd;
|
---|
5852 | var renderSelection = t.renderSelection;
|
---|
5853 | var clearSelection = t.clearSelection;
|
---|
5854 |
|
---|
5855 |
|
---|
5856 | // locals
|
---|
5857 | var selected = false;
|
---|
5858 |
|
---|
5859 |
|
---|
5860 |
|
---|
5861 | // unselectAuto
|
---|
5862 | if (opt('selectable') && opt('unselectAuto')) {
|
---|
5863 | $(document).mousedown(function(ev) {
|
---|
5864 | var ignore = opt('unselectCancel');
|
---|
5865 | if (ignore) {
|
---|
5866 | if ($(ev.target).parents(ignore).length) { // could be optimized to stop after first match
|
---|
5867 | return;
|
---|
5868 | }
|
---|
5869 | }
|
---|
5870 | unselect(ev);
|
---|
5871 | });
|
---|
5872 | }
|
---|
5873 |
|
---|
5874 |
|
---|
5875 | function select(startDate, endDate, allDay) {
|
---|
5876 | unselect();
|
---|
5877 | if (!endDate) {
|
---|
5878 | endDate = defaultSelectionEnd(startDate, allDay);
|
---|
5879 | }
|
---|
5880 | renderSelection(startDate, endDate, allDay);
|
---|
5881 | reportSelection(startDate, endDate, allDay);
|
---|
5882 | }
|
---|
5883 |
|
---|
5884 |
|
---|
5885 | function unselect(ev) {
|
---|
5886 | if (selected) {
|
---|
5887 | selected = false;
|
---|
5888 | clearSelection();
|
---|
5889 | trigger('unselect', null, ev);
|
---|
5890 | }
|
---|
5891 | }
|
---|
5892 |
|
---|
5893 |
|
---|
5894 | function reportSelection(startDate, endDate, allDay, ev) {
|
---|
5895 | selected = true;
|
---|
5896 | trigger('select', null, startDate, endDate, allDay, ev);
|
---|
5897 | }
|
---|
5898 |
|
---|
5899 |
|
---|
5900 | function daySelectionMousedown(ev) { // not really a generic manager method, oh well
|
---|
5901 | var cellToDate = t.cellToDate;
|
---|
5902 | var getIsCellAllDay = t.getIsCellAllDay;
|
---|
5903 | var hoverListener = t.getHoverListener();
|
---|
5904 | var reportDayClick = t.reportDayClick; // this is hacky and sort of weird
|
---|
5905 | if (ev.which == 1 && opt('selectable')) { // which==1 means left mouse button
|
---|
5906 | unselect(ev);
|
---|
5907 | var _mousedownElement = this;
|
---|
5908 | var dates;
|
---|
5909 | hoverListener.start(function(cell, origCell) { // TODO: maybe put cellToDate/getIsCellAllDay info in cell
|
---|
5910 | clearSelection();
|
---|
5911 | if (cell && getIsCellAllDay(cell)) {
|
---|
5912 | dates = [ cellToDate(origCell), cellToDate(cell) ].sort(dateCompare);
|
---|
5913 | renderSelection(dates[0], dates[1], true);
|
---|
5914 | }else{
|
---|
5915 | dates = null;
|
---|
5916 | }
|
---|
5917 | }, ev);
|
---|
5918 | $(document).one('mouseup', function(ev) {
|
---|
5919 | hoverListener.stop();
|
---|
5920 | if (dates) {
|
---|
5921 | if (+dates[0] == +dates[1]) {
|
---|
5922 | reportDayClick(dates[0], true, ev);
|
---|
5923 | }
|
---|
5924 | reportSelection(dates[0], dates[1], true, ev);
|
---|
5925 | }
|
---|
5926 | });
|
---|
5927 | }
|
---|
5928 | }
|
---|
5929 |
|
---|
5930 |
|
---|
5931 | }
|
---|
5932 |
|
---|
5933 | ;;
|
---|
5934 |
|
---|
5935 | function OverlayManager() {
|
---|
5936 | var t = this;
|
---|
5937 |
|
---|
5938 |
|
---|
5939 | // exports
|
---|
5940 | t.renderOverlay = renderOverlay;
|
---|
5941 | t.clearOverlays = clearOverlays;
|
---|
5942 |
|
---|
5943 |
|
---|
5944 | // locals
|
---|
5945 | var usedOverlays = [];
|
---|
5946 | var unusedOverlays = [];
|
---|
5947 |
|
---|
5948 |
|
---|
5949 | function renderOverlay(rect, parent) {
|
---|
5950 | var e = unusedOverlays.shift();
|
---|
5951 | if (!e) {
|
---|
5952 | e = $("<div class='fc-cell-overlay' style='position:absolute;z-index:3'/>");
|
---|
5953 | }
|
---|
5954 | if (e[0].parentNode != parent[0]) {
|
---|
5955 | e.appendTo(parent);
|
---|
5956 | }
|
---|
5957 | usedOverlays.push(e.css(rect).show());
|
---|
5958 | return e;
|
---|
5959 | }
|
---|
5960 |
|
---|
5961 |
|
---|
5962 | function clearOverlays() {
|
---|
5963 | var e;
|
---|
5964 | while (e = usedOverlays.shift()) {
|
---|
5965 | unusedOverlays.push(e.hide().unbind());
|
---|
5966 | }
|
---|
5967 | }
|
---|
5968 |
|
---|
5969 |
|
---|
5970 | }
|
---|
5971 |
|
---|
5972 | ;;
|
---|
5973 |
|
---|
5974 | function CoordinateGrid(buildFunc) {
|
---|
5975 |
|
---|
5976 | var t = this;
|
---|
5977 | var rows;
|
---|
5978 | var cols;
|
---|
5979 |
|
---|
5980 |
|
---|
5981 | t.build = function() {
|
---|
5982 | rows = [];
|
---|
5983 | cols = [];
|
---|
5984 | buildFunc(rows, cols);
|
---|
5985 | };
|
---|
5986 |
|
---|
5987 |
|
---|
5988 | t.cell = function(x, y) {
|
---|
5989 | var rowCnt = rows.length;
|
---|
5990 | var colCnt = cols.length;
|
---|
5991 | var i, r=-1, c=-1;
|
---|
5992 | for (i=0; i<rowCnt; i++) {
|
---|
5993 | if (y >= rows[i][0] && y < rows[i][1]) {
|
---|
5994 | r = i;
|
---|
5995 | break;
|
---|
5996 | }
|
---|
5997 | }
|
---|
5998 | for (i=0; i<colCnt; i++) {
|
---|
5999 | if (x >= cols[i][0] && x < cols[i][1]) {
|
---|
6000 | c = i;
|
---|
6001 | break;
|
---|
6002 | }
|
---|
6003 | }
|
---|
6004 | return (r>=0 && c>=0) ? { row:r, col:c } : null;
|
---|
6005 | };
|
---|
6006 |
|
---|
6007 |
|
---|
6008 | t.rect = function(row0, col0, row1, col1, originElement) { // row1,col1 is inclusive
|
---|
6009 | var origin = originElement.offset();
|
---|
6010 | return {
|
---|
6011 | top: rows[row0][0] - origin.top,
|
---|
6012 | left: cols[col0][0] - origin.left,
|
---|
6013 | width: cols[col1][1] - cols[col0][0],
|
---|
6014 | height: rows[row1][1] - rows[row0][0]
|
---|
6015 | };
|
---|
6016 | };
|
---|
6017 |
|
---|
6018 | }
|
---|
6019 |
|
---|
6020 | ;;
|
---|
6021 |
|
---|
6022 | function HoverListener(coordinateGrid) {
|
---|
6023 |
|
---|
6024 |
|
---|
6025 | var t = this;
|
---|
6026 | var bindType;
|
---|
6027 | var change;
|
---|
6028 | var firstCell;
|
---|
6029 | var cell;
|
---|
6030 |
|
---|
6031 |
|
---|
6032 | t.start = function(_change, ev, _bindType) {
|
---|
6033 | change = _change;
|
---|
6034 | firstCell = cell = null;
|
---|
6035 | coordinateGrid.build();
|
---|
6036 | mouse(ev);
|
---|
6037 | bindType = _bindType || 'mousemove';
|
---|
6038 | $(document).bind(bindType, mouse);
|
---|
6039 | };
|
---|
6040 |
|
---|
6041 |
|
---|
6042 | function mouse(ev) {
|
---|
6043 | _fixUIEvent(ev); // see below
|
---|
6044 | var newCell = coordinateGrid.cell(ev.pageX, ev.pageY);
|
---|
6045 | if (!newCell != !cell || newCell && (newCell.row != cell.row || newCell.col != cell.col)) {
|
---|
6046 | if (newCell) {
|
---|
6047 | if (!firstCell) {
|
---|
6048 | firstCell = newCell;
|
---|
6049 | }
|
---|
6050 | change(newCell, firstCell, newCell.row-firstCell.row, newCell.col-firstCell.col);
|
---|
6051 | }else{
|
---|
6052 | change(newCell, firstCell);
|
---|
6053 | }
|
---|
6054 | cell = newCell;
|
---|
6055 | }
|
---|
6056 | }
|
---|
6057 |
|
---|
6058 |
|
---|
6059 | t.stop = function() {
|
---|
6060 | $(document).unbind(bindType, mouse);
|
---|
6061 | return cell;
|
---|
6062 | };
|
---|
6063 |
|
---|
6064 |
|
---|
6065 | }
|
---|
6066 |
|
---|
6067 |
|
---|
6068 |
|
---|
6069 | // this fix was only necessary for jQuery UI 1.8.16 (and jQuery 1.7 or 1.7.1)
|
---|
6070 | // upgrading to jQuery UI 1.8.17 (and using either jQuery 1.7 or 1.7.1) fixed the problem
|
---|
6071 | // but keep this in here for 1.8.16 users
|
---|
6072 | // and maybe remove it down the line
|
---|
6073 |
|
---|
6074 | function _fixUIEvent(event) { // for issue 1168
|
---|
6075 | if (event.pageX === undefined) {
|
---|
6076 | event.pageX = event.originalEvent.pageX;
|
---|
6077 | event.pageY = event.originalEvent.pageY;
|
---|
6078 | }
|
---|
6079 | }
|
---|
6080 | ;;
|
---|
6081 |
|
---|
6082 | function HorizontalPositionCache(getElement) {
|
---|
6083 |
|
---|
6084 | var t = this,
|
---|
6085 | elements = {},
|
---|
6086 | lefts = {},
|
---|
6087 | rights = {};
|
---|
6088 |
|
---|
6089 | function e(i) {
|
---|
6090 | return elements[i] = elements[i] || getElement(i);
|
---|
6091 | }
|
---|
6092 |
|
---|
6093 | t.left = function(i) {
|
---|
6094 | return lefts[i] = lefts[i] === undefined ? e(i).position().left : lefts[i];
|
---|
6095 | };
|
---|
6096 |
|
---|
6097 | t.right = function(i) {
|
---|
6098 | return rights[i] = rights[i] === undefined ? t.left(i) + e(i).width() : rights[i];
|
---|
6099 | };
|
---|
6100 |
|
---|
6101 | t.clear = function() {
|
---|
6102 | elements = {};
|
---|
6103 | lefts = {};
|
---|
6104 | rights = {};
|
---|
6105 | };
|
---|
6106 |
|
---|
6107 | }
|
---|
6108 |
|
---|
6109 | ;;
|
---|
6110 |
|
---|
6111 | })(jQuery); |
---|