From 459fa9f4f9dfa00da336e57ebc0f49cc09290347 Mon Sep 17 00:00:00 2001 From: Kim Pellikaan Date: Fri, 24 Jun 2016 17:13:34 +0200 Subject: [PATCH 1/2] Added the scheduler to the calendar. No conditional loading is implemented though. --- src/calendar/calendar.xml | 30 + src/calendar/lib/scheduler.js | 5884 +++++++++++++++++++++++++++ src/calendar/widget/calendar.js | 151 +- src/calendar/widget/ui/calendar.css | 8 +- test/Widgets/Calendar.mpk | Bin 317048 -> 364340 bytes test/[Test] Calendar Widget.mpr | Bin 1556480 -> 1653760 bytes 6 files changed, 6031 insertions(+), 42 deletions(-) create mode 100644 src/calendar/lib/scheduler.js diff --git a/src/calendar/calendar.xml b/src/calendar/calendar.xml index 04d7508..eabae1b 100644 --- a/src/calendar/calendar.xml +++ b/src/calendar/calendar.xml @@ -19,6 +19,11 @@ Microflow with context object (Retrieve events for each view) + + Scheduler License Key + License Key + Read the following licence agreement http://fullcalendar.io/scheduler/license/ and get a license. + Event Entity Data source @@ -35,6 +40,16 @@ Setting this microflow will override the XPath retrieve option, and solely use this microflow to fill the calendar. + + Resource Entity + Data source + The resource entity. + + + Resource reference + Data source + The association from the resource to the event + Dataview Entity Dataview context (Optional) @@ -112,6 +127,19 @@ + + Resource Label Title + Event data + Title of the resources column + + + Resource Title + Event data + Title of the resource + + + + Limit events Event data @@ -309,6 +337,8 @@ Basic day Agenda week Agenda day + Day timeline + 3 day timeline diff --git a/src/calendar/lib/scheduler.js b/src/calendar/lib/scheduler.js new file mode 100644 index 0000000..ccce76d --- /dev/null +++ b/src/calendar/lib/scheduler.js @@ -0,0 +1,5884 @@ + +/*! +FullCalendar Scheduler v1.3.2 +Docs & License: http://fullcalendar.io/scheduler/ +(c) 2016 Adam Shaw + */ +(function(factory) { + if (typeof define === 'function' && define.amd) { + define([ 'calendar/lib/jquery', 'calendar/lib/moment', 'calendar/lib/fullcalendar' ], factory); + } + else if (typeof exports === 'object') { // Node/CommonJS + module.exports = factory( + require('jquery'), + require('moment'), + require('fullcalendar') + ); + } + else { + factory(jQuery, moment); + } +})(function($, moment) {; +var COL_MIN_WIDTH, Calendar, CalendarExtension, Class, ClippedScroller, CoordCache, DEFAULT_GRID_DURATION, DragListener, EmitterMixin, EnhancedScroller, EventRow, FC, Grid, HRowGroup, LICENSE_INFO_URL, ListenerMixin, MAX_AUTO_CELLS, MAX_AUTO_SLOTS_PER_LABEL, MAX_CELLS, MIN_AUTO_LABELS, PRESET_LICENSE_KEYS, RELEASE_DATE, ResourceAgendaView, ResourceBasicView, ResourceDayGrid, ResourceDayTableMixin, ResourceGridMixin, ResourceManager, ResourceMonthView, ResourceRow, ResourceTimeGrid, ResourceTimelineGrid, ResourceTimelineView, ResourceViewMixin, RowGroup, RowParent, STOCK_SUB_DURATIONS, ScrollFollower, ScrollFollowerSprite, ScrollJoiner, ScrollerCanvas, Spreadsheet, TimelineGrid, TimelineView, UPGRADE_WINDOW, VRowGroup, View, applyAll, capitaliseFirstLetter, compareByFieldSpecs, computeIntervalUnit, computeOffsetForSeg, computeOffsetForSegs, copyRect, cssToStr, debounce, detectWarningInContainer, divideDurationByDuration, divideRangeByDuration, durationHasTime, flexibleCompare, getContentRect, getOuterRect, getOwnCells, getRectHeight, getRectWidth, getScrollbarWidths, hContainRect, htmlEscape, intersectRanges, intersectRects, isImmuneUrl, isInt, isValidKey, joinRects, multiplyDuration, origDisplayEvents, origDisplayView, origGetSegClasses, origRenderSkeleton, origUnrenderSkeleton, parseFieldSpecs, processLicenseKey, proxy, renderingWarningInContainer, testRectContains, testRectHContains, testRectVContains, timeRowSegsCollide, vContainRect, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty, + slice = [].slice; + +FC = $.fullCalendar; + +FC.schedulerVersion = "1.3.2"; + +if (FC.internalApiVersion !== 4) { + FC.warn('v' + FC.schedulerVersion + ' of FullCalendar Scheduler ' + 'is incompatible with v' + FC.version + ' of the core.\n' + 'Please see http://fullcalendar.io/support/ for more information.'); + return; +} + +Calendar = FC.Calendar; + +Class = FC.Class; + +View = FC.View; + +Grid = FC.Grid; + +intersectRanges = FC.intersectRanges; + +debounce = FC.debounce; + +isInt = FC.isInt; + +getScrollbarWidths = FC.getScrollbarWidths; + +DragListener = FC.DragListener; + +htmlEscape = FC.htmlEscape; + +computeIntervalUnit = FC.computeIntervalUnit; + +proxy = FC.proxy; + +capitaliseFirstLetter = FC.capitaliseFirstLetter; + +applyAll = FC.applyAll; + +EmitterMixin = FC.EmitterMixin; + +ListenerMixin = FC.ListenerMixin; + +durationHasTime = FC.durationHasTime; + +divideRangeByDuration = FC.divideRangeByDuration; + +divideDurationByDuration = FC.divideDurationByDuration; + +multiplyDuration = FC.multiplyDuration; + +parseFieldSpecs = FC.parseFieldSpecs; + +compareByFieldSpecs = FC.compareByFieldSpecs; + +flexibleCompare = FC.flexibleCompare; + +intersectRects = FC.intersectRects; + +CoordCache = FC.CoordCache; + +getContentRect = FC.getContentRect; + +getOuterRect = FC.getOuterRect; + + +/* +Given a jQuery set, returns the 's that do not have multi-line rowspans. +Would use the [rowspan] selector, but never not defined in IE8. + */ + +getOwnCells = function(trs) { + return trs.find('> td').filter(function(i, tdNode) { + return tdNode.rowSpan <= 1; + }); +}; + + +/* +A Scroller with additional functionality: +- optional ScrollerCanvas for content +- fired events for scroll start/end +- cross-browser normalization of horizontal scroll for RTL + */ + +EnhancedScroller = (function(superClass) { + var detectRtlScrollSystem, rtlScrollSystem; + + extend(EnhancedScroller, superClass); + + EnhancedScroller.mixin(EmitterMixin); + + EnhancedScroller.mixin(ListenerMixin); + + EnhancedScroller.prototype.canvas = null; + + EnhancedScroller.prototype.isScrolling = false; + + EnhancedScroller.prototype.isTouching = false; + + EnhancedScroller.prototype.isMoving = false; + + EnhancedScroller.prototype.isTouchScrollEnabled = true; + + EnhancedScroller.prototype.preventTouchScrollHandler = null; + + function EnhancedScroller() { + EnhancedScroller.__super__.constructor.apply(this, arguments); + this.requestMovingEnd = debounce(this.reportMovingEnd, 500); + } + + EnhancedScroller.prototype.render = function() { + EnhancedScroller.__super__.render.apply(this, arguments); + if (this.canvas) { + this.canvas.render(); + this.canvas.el.appendTo(this.scrollEl); + } + return this.bindHandlers(); + }; + + EnhancedScroller.prototype.destroy = function() { + EnhancedScroller.__super__.destroy.apply(this, arguments); + return this.unbindHandlers(); + }; + + EnhancedScroller.prototype.disableTouchScroll = function() { + this.isTouchScrollEnabled = false; + return this.bindPreventTouchScroll(); + }; + + EnhancedScroller.prototype.enableTouchScroll = function() { + this.isTouchScrollEnabled = true; + if (!this.isTouching) { + return this.unbindPreventTouchScroll(); + } + }; + + EnhancedScroller.prototype.bindPreventTouchScroll = function() { + if (!this.preventTouchScrollHandler) { + return this.scrollEl.on('touchmove', this.preventTouchScrollHandler = FC.preventDefault); + } + }; + + EnhancedScroller.prototype.unbindPreventTouchScroll = function() { + if (this.preventTouchScrollHandler) { + this.scrollEl.off('touchmove', this.preventTouchScrollHandler); + return this.preventTouchScrollHandler = null; + } + }; + + EnhancedScroller.prototype.bindHandlers = function() { + return this.listenTo(this.scrollEl, { + scroll: this.reportScroll, + touchstart: this.reportTouchStart, + touchend: this.reportTouchEnd + }); + }; + + EnhancedScroller.prototype.unbindHandlers = function() { + return this.stopListeningTo(this.scrollEl); + }; + + EnhancedScroller.prototype.reportScroll = function() { + if (!this.isScrolling) { + this.reportScrollStart(); + } + this.trigger('scroll'); + this.isMoving = true; + return this.requestMovingEnd(); + }; + + EnhancedScroller.prototype.reportScrollStart = function() { + if (!this.isScrolling) { + this.isScrolling = true; + return this.trigger('scrollStart', this.isTouching); + } + }; + + EnhancedScroller.prototype.requestMovingEnd = null; + + EnhancedScroller.prototype.reportMovingEnd = function() { + this.isMoving = false; + if (!this.isTouching) { + return this.reportScrollEnd(); + } + }; + + EnhancedScroller.prototype.reportScrollEnd = function() { + if (this.isScrolling) { + this.trigger('scrollEnd'); + return this.isScrolling = false; + } + }; + + EnhancedScroller.prototype.reportTouchStart = function() { + return this.isTouching = true; + }; + + EnhancedScroller.prototype.reportTouchEnd = function() { + if (this.isTouching) { + this.isTouching = false; + if (this.isTouchScrollEnabled) { + this.unbindPreventTouchScroll(); + } + if (!this.isMoving) { + return this.reportScrollEnd(); + } + } + }; + + + /* + If RTL, and scrolled to the left, returns NEGATIVE value (like Firefox) + */ + + EnhancedScroller.prototype.getScrollLeft = function() { + var direction, node, val; + direction = this.scrollEl.css('direction'); + node = this.scrollEl[0]; + val = node.scrollLeft; + if (direction === 'rtl') { + switch (rtlScrollSystem) { + case 'positive': + val = val + node.clientWidth - node.scrollWidth; + break; + case 'reverse': + val = -val; + } + } + return val; + }; + + + /* + Accepts a NEGATIVE value for when scrolled in RTL + */ + + EnhancedScroller.prototype.setScrollLeft = function(val) { + var direction, node; + direction = this.scrollEl.css('direction'); + node = this.scrollEl[0]; + if (direction === 'rtl') { + switch (rtlScrollSystem) { + case 'positive': + val = val - node.clientWidth + node.scrollWidth; + break; + case 'reverse': + val = -val; + } + } + return node.scrollLeft = val; + }; + + + /* + Always returns the number of pixels scrolled from the leftmost position (even if RTL). + Always positive. + */ + + EnhancedScroller.prototype.getScrollFromLeft = function() { + var direction, node, val; + direction = this.scrollEl.css('direction'); + node = this.scrollEl[0]; + val = node.scrollLeft; + if (direction === 'rtl') { + switch (rtlScrollSystem) { + case 'negative': + val = val - node.clientWidth + node.scrollWidth; + break; + case 'reverse': + val = -val - node.clientWidth + node.scrollWidth; + } + } + return val; + }; + + EnhancedScroller.prototype.getNativeScrollLeft = function() { + return this.scrollEl[0].scrollLeft; + }; + + EnhancedScroller.prototype.setNativeScrollLeft = function(val) { + return this.scrollEl[0].scrollLeft = val; + }; + + rtlScrollSystem = null; + + detectRtlScrollSystem = function() { + var el, node, system; + el = $('
A
').appendTo('body'); + node = el[0]; + system = node.scrollLeft > 0 ? 'positive' : (node.scrollLeft = 1, el.scrollLeft > 0 ? 'reverse' : 'negative'); + el.remove(); + return system; + }; + + $(function() { + return rtlScrollSystem = detectRtlScrollSystem(); + }); + + return EnhancedScroller; + +})(FC.Scroller); + + +/* +A Scroller, but with a wrapping div that allows "clipping" away of native scrollbars, +giving the appearance that there are no scrollbars. + */ + +ClippedScroller = (function(superClass) { + extend(ClippedScroller, superClass); + + ClippedScroller.prototype.isHScrollbarsClipped = false; + + ClippedScroller.prototype.isVScrollbarsClipped = false; + + + /* + Received overflows can be set to 'clipped', meaning scrollbars shouldn't be visible + to the user, but the area should still scroll. + */ + + function ClippedScroller() { + ClippedScroller.__super__.constructor.apply(this, arguments); + if (this.overflowX === 'clipped-scroll') { + this.overflowX = 'scroll'; + this.isHScrollbarsClipped = true; + } + if (this.overflowY === 'clipped-scroll') { + this.overflowY = 'scroll'; + this.isVScrollbarsClipped = true; + } + } + + ClippedScroller.prototype.renderEl = function() { + var scrollEl; + scrollEl = ClippedScroller.__super__.renderEl.apply(this, arguments); + return $('
').append(scrollEl); + }; + + ClippedScroller.prototype.updateSize = function() { + var cssProps, scrollEl, scrollbarWidths; + scrollEl = this.scrollEl; + scrollbarWidths = getScrollbarWidths(scrollEl); + cssProps = { + marginLeft: 0, + marginRight: 0, + marginTop: 0, + marginBottom: 0 + }; + if (this.isHScrollbarsClipped) { + cssProps.marginTop = -scrollbarWidths.top; + cssProps.marginBottom = -scrollbarWidths.bottom; + } + if (this.isVScrollbarsClipped) { + cssProps.marginLeft = -scrollbarWidths.left; + cssProps.marginRight = -scrollbarWidths.right; + } + scrollEl.css(cssProps); + return scrollEl.toggleClass('fc-no-scrollbars', (this.isHScrollbarsClipped || this.overflowX === 'hidden') && (this.isVScrollbarsClipped || this.overflowY === 'hidden') && !(scrollbarWidths.top || scrollbarWidths.bottom || scrollbarWidths.left || scrollbarWidths.right)); + }; + + + /* + Accounts for 'clipped' scrollbars + */ + + ClippedScroller.prototype.getScrollbarWidths = function() { + var widths; + widths = getScrollbarWidths(this.scrollEl); + if (this.isHScrollbarsClipped) { + widths.top = 0; + widths.bottom = 0; + } + if (this.isVScrollbarsClipped) { + widths.left = 0; + widths.right = 0; + } + return widths; + }; + + return ClippedScroller; + +})(EnhancedScroller); + + +/* +A rectangular area of content that lives within a Scroller. +Can have "gutters", areas of dead spacing around the perimeter. +Also very useful for forcing a width, which a Scroller cannot do alone. +Has a content area that lives above a background area. + */ + +ScrollerCanvas = (function() { + ScrollerCanvas.prototype.el = null; + + ScrollerCanvas.prototype.contentEl = null; + + ScrollerCanvas.prototype.bgEl = null; + + ScrollerCanvas.prototype.gutters = null; + + ScrollerCanvas.prototype.width = null; + + ScrollerCanvas.prototype.minWidth = null; + + function ScrollerCanvas() { + this.gutters = {}; + } + + ScrollerCanvas.prototype.render = function() { + this.el = $('
'); + this.contentEl = this.el.find('.fc-content'); + return this.bgEl = this.el.find('.fc-bg'); + }; + + + /* + If falsy, resets all the gutters to 0 + */ + + ScrollerCanvas.prototype.setGutters = function(gutters) { + if (!gutters) { + this.gutters = {}; + } else { + $.extend(this.gutters, gutters); + } + return this.updateSize(); + }; + + ScrollerCanvas.prototype.setWidth = function(width1) { + this.width = width1; + return this.updateSize(); + }; + + ScrollerCanvas.prototype.setMinWidth = function(minWidth1) { + this.minWidth = minWidth1; + return this.updateSize(); + }; + + ScrollerCanvas.prototype.clearWidth = function() { + this.width = null; + this.minWidth = null; + return this.updateSize(); + }; + + ScrollerCanvas.prototype.updateSize = function() { + var gutters; + gutters = this.gutters; + this.el.toggleClass('fc-gutter-left', Boolean(gutters.left)).toggleClass('fc-gutter-right', Boolean(gutters.right)).toggleClass('fc-gutter-top', Boolean(gutters.top)).toggleClass('fc-gutter-bottom', Boolean(gutters.bottom)).css({ + paddingLeft: gutters.left || '', + paddingRight: gutters.right || '', + paddingTop: gutters.top || '', + paddingBottom: gutters.bottom || '', + width: this.width != null ? this.width + (gutters.left || 0) + (gutters.right || 0) : '', + minWidth: this.minWidth != null ? this.minWidth + (gutters.left || 0) + (gutters.right || 0) : '' + }); + return this.bgEl.css({ + left: gutters.left || '', + right: gutters.right || '', + top: gutters.top || '', + bottom: gutters.bottom || '' + }); + }; + + return ScrollerCanvas; + +})(); + +ScrollJoiner = (function() { + ScrollJoiner.prototype.axis = null; + + ScrollJoiner.prototype.scrollers = null; + + ScrollJoiner.prototype.masterScroller = null; + + function ScrollJoiner(axis, scrollers) { + var j, len, ref, scroller; + this.axis = axis; + this.scrollers = scrollers; + ref = this.scrollers; + for (j = 0, len = ref.length; j < len; j++) { + scroller = ref[j]; + this.initScroller(scroller); + } + return; + } + + ScrollJoiner.prototype.initScroller = function(scroller) { + scroller.scrollEl.on('wheel mousewheel DomMouseScroll MozMousePixelScroll', (function(_this) { + return function() { + _this.assignMasterScroller(scroller); + }; + })(this)); + return scroller.on('scrollStart', (function(_this) { + return function() { + if (!_this.masterScroller) { + return _this.assignMasterScroller(scroller); + } + }; + })(this)).on('scroll', (function(_this) { + return function() { + var j, len, otherScroller, ref, results; + if (scroller === _this.masterScroller) { + ref = _this.scrollers; + results = []; + for (j = 0, len = ref.length; j < len; j++) { + otherScroller = ref[j]; + if (otherScroller !== scroller) { + switch (_this.axis) { + case 'horizontal': + results.push(otherScroller.setNativeScrollLeft(scroller.getNativeScrollLeft())); + break; + case 'vertical': + results.push(otherScroller.setScrollTop(scroller.getScrollTop())); + break; + default: + results.push(void 0); + } + } else { + results.push(void 0); + } + } + return results; + } + }; + })(this)).on('scrollEnd', (function(_this) { + return function() { + if (scroller === _this.masterScroller) { + return _this.unassignMasterScroller(); + } + }; + })(this)); + }; + + ScrollJoiner.prototype.assignMasterScroller = function(scroller) { + var j, len, otherScroller, ref; + this.unassignMasterScroller(); + this.masterScroller = scroller; + ref = this.scrollers; + for (j = 0, len = ref.length; j < len; j++) { + otherScroller = ref[j]; + if (otherScroller !== scroller) { + otherScroller.disableTouchScroll(); + } + } + }; + + ScrollJoiner.prototype.unassignMasterScroller = function() { + var j, len, otherScroller, ref; + if (this.masterScroller) { + ref = this.scrollers; + for (j = 0, len = ref.length; j < len; j++) { + otherScroller = ref[j]; + otherScroller.enableTouchScroll(); + } + this.masterScroller = null; + } + }; + + ScrollJoiner.prototype.update = function() { + var allWidths, i, j, k, len, len1, maxBottom, maxLeft, maxRight, maxTop, ref, scroller, widths; + allWidths = (function() { + var j, len, ref, results; + ref = this.scrollers; + results = []; + for (j = 0, len = ref.length; j < len; j++) { + scroller = ref[j]; + results.push(scroller.getScrollbarWidths()); + } + return results; + }).call(this); + maxLeft = maxRight = maxTop = maxBottom = 0; + for (j = 0, len = allWidths.length; j < len; j++) { + widths = allWidths[j]; + maxLeft = Math.max(maxLeft, widths.left); + maxRight = Math.max(maxRight, widths.right); + maxTop = Math.max(maxTop, widths.top); + maxBottom = Math.max(maxBottom, widths.bottom); + } + ref = this.scrollers; + for (i = k = 0, len1 = ref.length; k < len1; i = ++k) { + scroller = ref[i]; + widths = allWidths[i]; + scroller.canvas.setGutters(this.axis === 'horizontal' ? { + left: maxLeft - widths.left, + right: maxRight - widths.right + } : { + top: maxTop - widths.top, + bottom: maxBottom - widths.bottom + }); + } + }; + + return ScrollJoiner; + +})(); + +ScrollFollower = (function() { + ScrollFollower.prototype.scroller = null; + + ScrollFollower.prototype.scrollbarWidths = null; + + ScrollFollower.prototype.sprites = null; + + ScrollFollower.prototype.viewportRect = null; + + ScrollFollower.prototype.contentOffset = null; + + ScrollFollower.prototype.isHFollowing = true; + + ScrollFollower.prototype.isVFollowing = false; + + ScrollFollower.prototype.containOnNaturalLeft = false; + + ScrollFollower.prototype.containOnNaturalRight = false; + + ScrollFollower.prototype.minTravel = 0; + + ScrollFollower.prototype.isTouch = false; + + ScrollFollower.prototype.isForcedRelative = false; + + function ScrollFollower(scroller, isTouch) { + this.isTouch = isTouch; + this.scroller = scroller; + this.sprites = []; + if (this.isTouch) { + this.isForcedRelative = true; + } + scroller.on((this.isTouch ? 'scrollEnd' : 'scroll'), (function(_this) { + return function() { + return _this.handleScroll(); + }; + })(this)); + } + + ScrollFollower.prototype.setSprites = function(sprites) { + var j, len, sprite; + this.clearSprites(); + if (sprites instanceof $) { + return this.sprites = (function() { + var j, len, results; + results = []; + for (j = 0, len = sprites.length; j < len; j++) { + sprite = sprites[j]; + results.push(new ScrollFollowerSprite($(sprite), this)); + } + return results; + }).call(this); + } else { + for (j = 0, len = sprites.length; j < len; j++) { + sprite = sprites[j]; + sprite.follower = this; + } + return this.sprites = sprites; + } + }; + + ScrollFollower.prototype.clearSprites = function() { + var j, len, ref, sprite; + ref = this.sprites; + for (j = 0, len = ref.length; j < len; j++) { + sprite = ref[j]; + sprite.clear(); + } + return this.sprites = []; + }; + + ScrollFollower.prototype.handleScroll = function() { + this.updateViewport(); + return this.updatePositions(); + }; + + ScrollFollower.prototype.cacheDimensions = function() { + var j, len, ref, sprite; + this.updateViewport(); + this.scrollbarWidths = this.scroller.getScrollbarWidths(); + this.contentOffset = this.scroller.canvas.el.offset(); + ref = this.sprites; + for (j = 0, len = ref.length; j < len; j++) { + sprite = ref[j]; + sprite.cacheDimensions(); + } + }; + + ScrollFollower.prototype.updateViewport = function() { + var left, scroller, top; + scroller = this.scroller; + left = scroller.getScrollFromLeft(); + top = scroller.getScrollTop(); + return this.viewportRect = { + left: left, + right: left + scroller.getClientWidth(), + top: top, + bottom: top + scroller.getClientHeight() + }; + }; + + ScrollFollower.prototype.forceRelative = function() { + var j, len, ref, results, sprite; + if (!this.isForcedRelative) { + this.isForcedRelative = true; + ref = this.sprites; + results = []; + for (j = 0, len = ref.length; j < len; j++) { + sprite = ref[j]; + if (sprite.doAbsolute) { + results.push(sprite.assignPosition()); + } else { + results.push(void 0); + } + } + return results; + } + }; + + ScrollFollower.prototype.clearForce = function() { + var j, len, ref, results, sprite; + if (this.isForcedRelative && !this.isTouch) { + this.isForcedRelative = false; + ref = this.sprites; + results = []; + for (j = 0, len = ref.length; j < len; j++) { + sprite = ref[j]; + results.push(sprite.assignPosition()); + } + return results; + } + }; + + ScrollFollower.prototype.update = function() { + this.cacheDimensions(); + return this.updatePositions(); + }; + + ScrollFollower.prototype.updatePositions = function() { + var j, len, ref, sprite; + ref = this.sprites; + for (j = 0, len = ref.length; j < len; j++) { + sprite = ref[j]; + sprite.updatePosition(); + } + }; + + ScrollFollower.prototype.getContentRect = function(el) { + return getContentRect(el, this.contentOffset); + }; + + ScrollFollower.prototype.getBoundingRect = function(el) { + return getOuterRect(el, this.contentOffset); + }; + + return ScrollFollower; + +})(); + +ScrollFollowerSprite = (function() { + ScrollFollowerSprite.prototype.follower = null; + + ScrollFollowerSprite.prototype.el = null; + + ScrollFollowerSprite.prototype.absoluteEl = null; + + ScrollFollowerSprite.prototype.naturalRect = null; + + ScrollFollowerSprite.prototype.parentRect = null; + + ScrollFollowerSprite.prototype.containerRect = null; + + ScrollFollowerSprite.prototype.isEnabled = true; + + ScrollFollowerSprite.prototype.isHFollowing = false; + + ScrollFollowerSprite.prototype.isVFollowing = false; + + ScrollFollowerSprite.prototype.doAbsolute = false; + + ScrollFollowerSprite.prototype.isAbsolute = false; + + ScrollFollowerSprite.prototype.isCentered = false; + + ScrollFollowerSprite.prototype.rect = null; + + ScrollFollowerSprite.prototype.isBlock = false; + + ScrollFollowerSprite.prototype.naturalWidth = null; + + function ScrollFollowerSprite(el1, follower1) { + this.el = el1; + this.follower = follower1 != null ? follower1 : null; + this.isBlock = this.el.css('display') === 'block'; + this.el.css('position', 'relative'); + } + + ScrollFollowerSprite.prototype.disable = function() { + if (this.isEnabled) { + this.isEnabled = false; + this.resetPosition(); + return this.unabsolutize(); + } + }; + + ScrollFollowerSprite.prototype.enable = function() { + if (!this.isEnabled) { + this.isEnabled = true; + return this.assignPosition(); + } + }; + + ScrollFollowerSprite.prototype.clear = function() { + this.disable(); + this.follower = null; + return this.absoluteEl = null; + }; + + ScrollFollowerSprite.prototype.cacheDimensions = function() { + var containerRect, follower, isCentered, isHFollowing, isVFollowing, minTravel, naturalRect, parentEl; + isHFollowing = false; + isVFollowing = false; + isCentered = false; + this.naturalWidth = this.el.width(); + this.resetPosition(); + follower = this.follower; + naturalRect = this.naturalRect = follower.getBoundingRect(this.el); + parentEl = this.el.parent(); + this.parentRect = follower.getBoundingRect(parentEl); + containerRect = this.containerRect = joinRects(follower.getContentRect(parentEl), naturalRect); + minTravel = follower.minTravel; + if (follower.containOnNaturalLeft) { + containerRect.left = naturalRect.left; + } + if (follower.containOnNaturalRight) { + containerRect.right = naturalRect.right; + } + if (follower.isHFollowing) { + if (getRectWidth(containerRect) - getRectWidth(naturalRect) >= minTravel) { + isCentered = this.el.css('text-align') === 'center'; + isHFollowing = true; + } + } + if (follower.isVFollowing) { + if (getRectHeight(containerRect) - getRectHeight(naturalRect) >= minTravel) { + isVFollowing = true; + } + } + this.isHFollowing = isHFollowing; + this.isVFollowing = isVFollowing; + return this.isCentered = isCentered; + }; + + ScrollFollowerSprite.prototype.updatePosition = function() { + this.computePosition(); + return this.assignPosition(); + }; + + ScrollFollowerSprite.prototype.resetPosition = function() { + return this.el.css({ + top: '', + left: '' + }); + }; + + ScrollFollowerSprite.prototype.computePosition = function() { + var containerRect, doAbsolute, parentRect, rect, rectWidth, subjectRect, viewportRect, visibleParentRect; + viewportRect = this.follower.viewportRect; + parentRect = this.parentRect; + containerRect = this.containerRect; + visibleParentRect = intersectRects(viewportRect, parentRect); + rect = null; + doAbsolute = false; + if (visibleParentRect) { + rect = copyRect(this.naturalRect); + subjectRect = intersectRects(rect, parentRect); + if ((this.isCentered && !testRectContains(viewportRect, parentRect)) || (subjectRect && !testRectContains(viewportRect, subjectRect))) { + doAbsolute = true; + if (this.isHFollowing) { + if (this.isCentered) { + rectWidth = getRectWidth(rect); + rect.left = (visibleParentRect.left + visibleParentRect.right) / 2 - rectWidth / 2; + rect.right = rect.left + rectWidth; + } else { + if (!hContainRect(rect, viewportRect)) { + doAbsolute = false; + } + } + if (hContainRect(rect, containerRect)) { + doAbsolute = false; + } + } + if (this.isVFollowing) { + if (!vContainRect(rect, viewportRect)) { + doAbsolute = false; + } + if (vContainRect(rect, containerRect)) { + doAbsolute = false; + } + } + if (!testRectContains(viewportRect, rect)) { + doAbsolute = false; + } + } + } + this.rect = rect; + return this.doAbsolute = doAbsolute; + }; + + ScrollFollowerSprite.prototype.assignPosition = function() { + var left, top; + if (this.isEnabled) { + if (!this.rect) { + return this.unabsolutize(); + } else if (this.doAbsolute && !this.follower.isForcedRelative) { + this.absolutize(); + return this.absoluteEl.css({ + top: this.rect.top - this.follower.viewportRect.top + this.follower.scrollbarWidths.top, + left: this.rect.left - this.follower.viewportRect.left + this.follower.scrollbarWidths.left, + width: this.isBlock ? this.naturalWidth : '' + }); + } else { + top = this.rect.top - this.naturalRect.top; + left = this.rect.left - this.naturalRect.left; + this.unabsolutize(); + return this.el.toggleClass('fc-following', Boolean(top || left)).css({ + top: top, + left: left + }); + } + } + }; + + ScrollFollowerSprite.prototype.absolutize = function() { + if (!this.isAbsolute) { + if (!this.absoluteEl) { + this.absoluteEl = this.buildAbsoluteEl(); + } + this.absoluteEl.appendTo(this.follower.scroller.el); + this.el.css('visibility', 'hidden'); + return this.isAbsolute = true; + } + }; + + ScrollFollowerSprite.prototype.unabsolutize = function() { + if (this.isAbsolute) { + this.absoluteEl.detach(); + this.el.css('visibility', ''); + return this.isAbsolute = false; + } + }; + + ScrollFollowerSprite.prototype.buildAbsoluteEl = function() { + return this.el.clone().addClass('fc-following').css({ + 'position': 'absolute', + 'z-index': 1000, + 'font-weight': this.el.css('font-weight'), + 'font-size': this.el.css('font-size'), + 'font-family': this.el.css('font-family'), + 'color': this.el.css('color'), + 'padding-top': this.el.css('padding-top'), + 'padding-bottom': this.el.css('padding-bottom'), + 'padding-left': this.el.css('padding-left'), + 'padding-right': this.el.css('padding-right'), + 'pointer-events': 'none' + }); + }; + + return ScrollFollowerSprite; + +})(); + +copyRect = function(rect) { + return { + left: rect.left, + right: rect.right, + top: rect.top, + bottom: rect.bottom + }; +}; + +getRectWidth = function(rect) { + return rect.right - rect.left; +}; + +getRectHeight = function(rect) { + return rect.bottom - rect.top; +}; + +testRectContains = function(rect, innerRect) { + return testRectHContains(rect, innerRect) && testRectVContains(rect, innerRect); +}; + +testRectHContains = function(rect, innerRect) { + return innerRect.left >= rect.left && innerRect.right <= rect.right; +}; + +testRectVContains = function(rect, innerRect) { + return innerRect.top >= rect.top && innerRect.bottom <= rect.bottom; +}; + +hContainRect = function(rect, outerRect) { + if (rect.left < outerRect.left) { + rect.right = outerRect.left + getRectWidth(rect); + rect.left = outerRect.left; + return true; + } else if (rect.right > outerRect.right) { + rect.left = outerRect.right - getRectWidth(rect); + rect.right = outerRect.right; + return true; + } else { + return false; + } +}; + +vContainRect = function(rect, outerRect) { + if (rect.top < outerRect.top) { + rect.bottom = outerRect.top + getRectHeight(rect); + rect.top = outerRect.top; + return true; + } else if (rect.bottom > outerRect.bottom) { + rect.top = outerRect.bottom - getRectHeight(rect); + rect.bottom = outerRect.bottom; + return true; + } else { + return false; + } +}; + +joinRects = function(rect1, rect2) { + return { + left: Math.min(rect1.left, rect2.left), + right: Math.max(rect1.right, rect2.right), + top: Math.min(rect1.top, rect2.top), + bottom: Math.max(rect1.bottom, rect2.bottom) + }; +}; + +CalendarExtension = (function(superClass) { + extend(CalendarExtension, superClass); + + function CalendarExtension() { + return CalendarExtension.__super__.constructor.apply(this, arguments); + } + + CalendarExtension.prototype.resourceManager = null; + + CalendarExtension.prototype.initialize = function() { + return this.resourceManager = new ResourceManager(this); + }; + + CalendarExtension.prototype.instantiateView = function(viewType) { + var spec, viewClass; + spec = this.getViewSpec(viewType); + viewClass = spec['class']; + if (this.options.resources && spec.options.resources !== false) { + if (spec.queryResourceClass) { + viewClass = spec.queryResourceClass(spec) || viewClass; + } else if (spec.resourceClass) { + viewClass = spec.resourceClass; + } + } + return new viewClass(this, viewType, spec.options, spec.duration); + }; + + CalendarExtension.prototype.getResources = function() { + return Array.prototype.slice.call(this.resourceManager.topLevelResources); + }; + + CalendarExtension.prototype.addResource = function(resourceInput, scroll) { + var promise; + if (scroll == null) { + scroll = false; + } + promise = this.resourceManager.addResource(resourceInput); + if (scroll && this.view.scrollToResource) { + promise.done((function(_this) { + return function(resource) { + return _this.view.scrollToResource(resource); + }; + })(this)); + } + }; + + CalendarExtension.prototype.removeResource = function(idOrResource) { + return this.resourceManager.removeResource(idOrResource); + }; + + CalendarExtension.prototype.refetchResources = function() { + this.resourceManager.fetchResources(); + }; + + CalendarExtension.prototype.rerenderResources = function() { + this.resourceManager.resetResources(); + }; + + CalendarExtension.prototype.getPeerEvents = function(span, event) { + var filteredPeerEvents, isPeer, j, k, l, len, len1, len2, newResourceId, newResourceIds, peerEvent, peerEvents, peerResourceId, peerResourceIds; + peerEvents = CalendarExtension.__super__.getPeerEvents.apply(this, arguments); + newResourceIds = span.resourceId ? [span.resourceId] : event ? this.getEventResourceIds(event) : []; + filteredPeerEvents = []; + for (j = 0, len = peerEvents.length; j < len; j++) { + peerEvent = peerEvents[j]; + isPeer = false; + peerResourceIds = this.getEventResourceIds(peerEvent); + if (!peerResourceIds.length || !newResourceIds.length) { + isPeer = true; + } else { + for (k = 0, len1 = peerResourceIds.length; k < len1; k++) { + peerResourceId = peerResourceIds[k]; + for (l = 0, len2 = newResourceIds.length; l < len2; l++) { + newResourceId = newResourceIds[l]; + if (newResourceId === peerResourceId) { + isPeer = true; + break; + } + } + } + } + if (isPeer) { + filteredPeerEvents.push(peerEvent); + } + } + return filteredPeerEvents; + }; + + CalendarExtension.prototype.buildSelectSpan = function(startInput, endInput, resourceId) { + var span; + span = CalendarExtension.__super__.buildSelectSpan.apply(this, arguments); + if (resourceId) { + span.resourceId = resourceId; + } + return span; + }; + + CalendarExtension.prototype.getResourceById = function(id) { + return this.resourceManager.getResourceById(id); + }; + + CalendarExtension.prototype.normalizeEvent = function(event) { + CalendarExtension.__super__.normalizeEvent.apply(this, arguments); + if (event.resourceId == null) { + event.resourceId = null; + } + return event.resourceIds != null ? event.resourceIds : event.resourceIds = null; + }; + + CalendarExtension.prototype.getEventResourceId = function(event) { + return this.getEventResourceIds(event)[0]; + }; + + CalendarExtension.prototype.getEventResourceIds = function(event) { + var j, len, normalResourceId, normalResourceIds, ref, ref1, ref2, resourceId; + resourceId = String((ref = (ref1 = event[this.getEventResourceField()]) != null ? ref1 : event.resourceId) != null ? ref : ''); + if (resourceId) { + return [resourceId]; + } else if (event.resourceIds) { + normalResourceIds = []; + ref2 = event.resourceIds; + for (j = 0, len = ref2.length; j < len; j++) { + resourceId = ref2[j]; + normalResourceId = String(resourceId != null ? resourceId : ''); + if (normalResourceId) { + normalResourceIds.push(normalResourceId); + } + } + return normalResourceIds; + } else { + return []; + } + }; + + CalendarExtension.prototype.setEventResourceId = function(event, resourceId) { + return event[this.getEventResourceField()] = String(resourceId != null ? resourceId : ''); + }; + + CalendarExtension.prototype.getEventResourceField = function() { + return this.options['eventResourceField'] || 'resourceId'; + }; + + CalendarExtension.prototype.getResourceEvents = function(idOrResource) { + var resource; + resource = typeof idOrResource === 'object' ? idOrResource : this.getResourceById(idOrResource); + if (resource) { + return this.clientEvents((function(_this) { + return function(event) { + return $.inArray(resource.id, _this.getEventResourceIds(event)) !== -1; + }; + })(this)); + } else { + return []; + } + }; + + CalendarExtension.prototype.getEventResource = function(idOrEvent) { + return this.getEventResources(idOrEvent)[0]; + }; + + CalendarExtension.prototype.getEventResources = function(idOrEvent) { + var event, j, len, ref, resource, resourceId, resources; + event = typeof idOrEvent === 'object' ? idOrEvent : this.clientEvents(idOrEvent)[0]; + resources = []; + if (event) { + ref = this.getEventResourceIds(event); + for (j = 0, len = ref.length; j < len; j++) { + resourceId = ref[j]; + resource = this.getResourceById(resourceId); + if (resource) { + resources.push(resource); + } + } + } + return resources; + }; + + return CalendarExtension; + +})(Calendar); + +Calendar.prototype = CalendarExtension.prototype; + +origDisplayView = View.prototype.displayView; + +origRenderSkeleton = View.prototype.renderSkeleton; + +origUnrenderSkeleton = View.prototype.unrenderSkeleton; + +origDisplayEvents = View.prototype.displayEvents; + +View.prototype.isResourcesBound = false; + +View.prototype.settingResources = null; + +View.prototype.displayView = function() { + origDisplayView.apply(this, arguments); + processLicenseKey(this.calendar.options.schedulerLicenseKey, this.el); + this.bindResources(); + return this.whenResources(); +}; + +View.prototype.unrenderSkeleton = function() { + origUnrenderSkeleton.apply(this, arguments); + return this.unbindResources(true); +}; + +View.prototype.displayEvents = function(events) { + return this.whenResources((function(_this) { + return function() { + return origDisplayEvents.call(_this, events); + }; + })(this)); +}; + +View.prototype.bindResources = function() { + var setResources; + if (!this.isResourcesBound) { + this.isResourcesBound = true; + this.settingResources = $.Deferred(); + setResources = (function(_this) { + return function(resources) { + _this.setResources(resources); + return _this.settingResources.resolve(); + }; + })(this); + this.listenTo(this.calendar.resourceManager, { + set: setResources, + unset: this.unsetResources, + reset: this.resetResources, + add: this.addResource, + remove: this.removeResource + }); + if (this.calendar.resourceManager.hasFetched()) { + return setResources(this.calendar.resourceManager.topLevelResources); + } else { + return this.calendar.resourceManager.getResources(); + } + } +}; + +View.prototype.unbindResources = function(isDestroying) { + if (this.isResourcesBound) { + this.stopListeningTo(this.calendar.resourceManager); + if (this.settingResources.state() === 'resolved') { + this.unsetResources(isDestroying); + } + this.settingResources = null; + return this.isResourcesBound = false; + } +}; + +View.prototype.whenResources = function(thenFunc) { + if (this.settingResources.state() === 'resolved') { + return $.when(thenFunc ? thenFunc() : void 0); + } else if (thenFunc) { + return this.settingResources.then(thenFunc); + } else { + return this.settingResources.promise(); + } +}; + +View.prototype.setResources = function(resources) {}; + +View.prototype.unsetResources = function() {}; + +View.prototype.resetResources = function(resources) { + return this.calendar.rerenderEvents(); +}; + +View.prototype.addResource = function(resource) { + return this.resetResources(this.calendar.resourceManager.topLevelResources); +}; + +View.prototype.removeResource = function(resource) { + return this.resetResources(this.calendar.resourceManager.topLevelResources); +}; + +origGetSegClasses = Grid.prototype.getSegClasses; + +Grid.prototype.getSegClasses = function(seg) { + var classes, j, len, ref, resource; + classes = origGetSegClasses.apply(this, arguments); + ref = this.getSegResources(seg); + for (j = 0, len = ref.length; j < len; j++) { + resource = ref[j]; + classes = classes.concat(resource.eventClassName || []); + } + return classes; +}; + +Grid.prototype.getSegSkinCss = function(seg) { + var event, eventColor, getResourceBackgroundColor, getResourceBorderColor, getResourceTextColor, optionColor, resources, source, sourceColor, view; + view = this.view; + event = seg.event; + source = event.source || {}; + eventColor = event.color; + sourceColor = source.color; + optionColor = view.opt('eventColor'); + resources = this.getSegResources(seg); + getResourceBackgroundColor = function() { + var currentResource, j, len, val; + val = null; + for (j = 0, len = resources.length; j < len; j++) { + currentResource = resources[j]; + while (currentResource && !val) { + val = currentResource.eventBackgroundColor || currentResource.eventColor; + currentResource = currentResource._parent; + } + } + return val; + }; + getResourceBorderColor = function() { + var currentResource, j, len, val; + val = null; + for (j = 0, len = resources.length; j < len; j++) { + currentResource = resources[j]; + while (currentResource && !val) { + val = currentResource.eventBorderColor || currentResource.eventColor; + currentResource = currentResource._parent; + } + } + return val; + }; + getResourceTextColor = function() { + var currentResource, j, len, val; + val = null; + for (j = 0, len = resources.length; j < len; j++) { + currentResource = resources[j]; + while (currentResource && !val) { + val = currentResource.eventTextColor; + currentResource = currentResource._parent; + } + } + return val; + }; + return { + 'background-color': event.backgroundColor || eventColor || getResourceBackgroundColor() || source.backgroundColor || sourceColor || view.opt('eventBackgroundColor') || optionColor, + 'border-color': event.borderColor || eventColor || getResourceBorderColor() || source.borderColor || sourceColor || view.opt('eventBorderColor') || optionColor, + 'color': event.textColor || getResourceTextColor() || source.textColor || view.opt('eventTextColor') + }; +}; + +Grid.prototype.getSegResources = function(seg) { + if (seg.resource) { + return [seg.resource]; + } else { + return this.view.calendar.getEventResources(seg.event); + } +}; + +ResourceManager = (function(superClass) { + extend(ResourceManager, superClass); + + ResourceManager.mixin(EmitterMixin); + + ResourceManager.resourceGuid = 1; + + ResourceManager.ajaxDefaults = { + dataType: 'json', + cache: false + }; + + ResourceManager.prototype.calendar = null; + + ResourceManager.prototype.topLevelResources = null; + + ResourceManager.prototype.resourcesById = null; + + ResourceManager.prototype.fetching = null; + + function ResourceManager(calendar1) { + this.calendar = calendar1; + this.initializeCache(); + } + + ResourceManager.prototype.hasFetched = function() { + return this.fetching && this.fetching.state() === 'resolved'; + }; + + ResourceManager.prototype.getResources = function() { + var getting; + if (!this.fetching) { + getting = $.Deferred(); + this.fetchResources().done(function(resources) { + return getting.resolve(resources); + }).fail(function() { + return getting.resolve([]); + }); + return getting; + } else { + return $.Deferred().resolve(this.topLevelResources).promise(); + } + }; + + ResourceManager.prototype.fetchResources = function() { + var prevFetching; + prevFetching = this.fetching; + return $.when(prevFetching).then((function(_this) { + return function() { + return _this.fetching = _this.fetchResourceInputs().then(function(resourceInputs) { + _this.setResources(resourceInputs, Boolean(prevFetching)); + return _this.topLevelResources; + }); + }; + })(this)); + }; + + ResourceManager.prototype.fetchResourceInputs = function() { + var deferred, promise, source; + deferred = $.Deferred(); + source = this.calendar.options['resources']; + if ($.type(source) === 'string') { + source = { + url: source + }; + } + switch ($.type(source)) { + case 'function': + source((function(_this) { + return function(resourceInputs) { + return deferred.resolve(resourceInputs); + }; + })(this)); + break; + case 'object': + promise = $.ajax($.extend({}, ResourceManager.ajaxDefaults, source)); + break; + case 'array': + deferred.resolve(source); + break; + default: + deferred.resolve([]); + } + promise || (promise = deferred.promise()); + if (!promise.state() === 'pending') { + this.calendar.pushLoading(); + promise.always(function() { + return this.calendar.popLoading(); + }); + } + return promise; + }; + + ResourceManager.prototype.resetResources = function() { + return this.getResources().then((function(_this) { + return function() { + return _this.trigger('reset', _this.topLevelResources); + }; + })(this)); + }; + + ResourceManager.prototype.getResourceById = function(id) { + return this.resourcesById[id]; + }; + + ResourceManager.prototype.initializeCache = function() { + this.topLevelResources = []; + return this.resourcesById = {}; + }; + + ResourceManager.prototype.setResources = function(resourceInputs, isReset) { + var j, len, resource, resourceInput, resources, validResources; + this.initializeCache(); + resources = (function() { + var j, len, results; + results = []; + for (j = 0, len = resourceInputs.length; j < len; j++) { + resourceInput = resourceInputs[j]; + results.push(this.buildResource(resourceInput)); + } + return results; + }).call(this); + validResources = (function() { + var j, len, results; + results = []; + for (j = 0, len = resources.length; j < len; j++) { + resource = resources[j]; + if (this.addResourceToIndex(resource)) { + results.push(resource); + } + } + return results; + }).call(this); + for (j = 0, len = validResources.length; j < len; j++) { + resource = validResources[j]; + this.addResourceToTree(resource); + } + if (isReset) { + this.trigger('reset', this.topLevelResources); + } else { + this.trigger('set', this.topLevelResources); + } + return this.calendar.trigger('resourcesSet', null, this.topLevelResources); + }; + + ResourceManager.prototype.addResource = function(resourceInput) { + return $.when(this.fetching).then((function(_this) { + return function() { + var resource; + resource = _this.buildResource(resourceInput); + if (_this.addResourceToIndex(resource)) { + _this.addResourceToTree(resource); + _this.trigger('add', resource); + return resource; + } else { + return false; + } + }; + })(this)); + }; + + ResourceManager.prototype.addResourceToIndex = function(resource) { + var child, j, len, ref; + if (this.resourcesById[resource.id]) { + return false; + } else { + this.resourcesById[resource.id] = resource; + ref = resource.children; + for (j = 0, len = ref.length; j < len; j++) { + child = ref[j]; + this.addResourceToIndex(child); + } + return true; + } + }; + + ResourceManager.prototype.addResourceToTree = function(resource) { + var parent, parentId, ref, siblings; + if (!resource.parent) { + parentId = String((ref = resource['parentId']) != null ? ref : ''); + if (parentId) { + parent = this.resourcesById[parentId]; + if (parent) { + resource.parent = parent; + siblings = parent.children; + } else { + return false; + } + } else { + siblings = this.topLevelResources; + } + siblings.push(resource); + } + return true; + }; + + ResourceManager.prototype.removeResource = function(idOrResource) { + var id; + id = typeof idOrResource === 'object' ? idOrResource.id : idOrResource; + return $.when(this.fetching).then((function(_this) { + return function() { + var resource; + resource = _this.removeResourceFromIndex(id); + if (resource) { + _this.removeResourceFromTree(resource); + _this.trigger('remove', resource); + } + return resource; + }; + })(this)); + }; + + ResourceManager.prototype.removeResourceFromIndex = function(resourceId) { + var child, j, len, ref, resource; + resource = this.resourcesById[resourceId]; + if (resource) { + delete this.resourcesById[resourceId]; + ref = resource.children; + for (j = 0, len = ref.length; j < len; j++) { + child = ref[j]; + this.removeResourceFromIndex(child.id); + } + return resource; + } else { + return false; + } + }; + + ResourceManager.prototype.removeResourceFromTree = function(resource, siblings) { + var i, j, len, sibling; + if (siblings == null) { + siblings = this.topLevelResources; + } + for (i = j = 0, len = siblings.length; j < len; i = ++j) { + sibling = siblings[i]; + if (sibling === resource) { + resource.parent = null; + siblings.splice(i, 1); + return true; + } + if (this.removeResourceFromTree(resource, sibling.children)) { + return true; + } + } + return false; + }; + + ResourceManager.prototype.buildResource = function(resourceInput) { + var child, childInput, rawClassName, ref, resource; + resource = $.extend({}, resourceInput); + resource.id = String((ref = resourceInput.id) != null ? ref : '_fc' + ResourceManager.resourceGuid++); + rawClassName = resourceInput.eventClassName; + resource.eventClassName = (function() { + switch ($.type(rawClassName)) { + case 'string': + return rawClassName.split(/\s+/); + case 'array': + return rawClassName; + default: + return []; + } + })(); + resource.children = (function() { + var j, len, ref1, ref2, results; + ref2 = (ref1 = resourceInput.children) != null ? ref1 : []; + results = []; + for (j = 0, len = ref2.length; j < len; j++) { + childInput = ref2[j]; + child = this.buildResource(childInput); + child.parent = resource; + results.push(child); + } + return results; + }).call(this); + return resource; + }; + + return ResourceManager; + +})(Class); + +ResourceViewMixin = { + resourceTextFunc: null, + unsetResources: function() { + return this.clearEvents(); + }, + resetResources: function(resources) { + var scrollState; + scrollState = this.queryScroll(); + this.unsetResources(); + this.setResources(resources); + this.setScroll(scrollState); + return this.calendar.rerenderEvents(); + }, + getResourceText: function(resource) { + return this.getResourceTextFunc()(resource); + }, + getResourceTextFunc: function() { + var func; + if (this.resourceTextFunc) { + return this.resourceTextFunc; + } else { + func = this.opt('resourceText'); + if (typeof func !== 'function') { + func = function(resource) { + return resource.title || resource.id; + }; + } + return this.resourceTextFunc = func; + } + }, + triggerDayClick: function(span, dayEl, ev) { + var resourceManager; + resourceManager = this.calendar.resourceManager; + return this.trigger('dayClick', dayEl, this.calendar.applyTimezone(span.start), ev, this, resourceManager.getResourceById(span.resourceId)); + }, + triggerSelect: function(span, ev) { + var resourceManager; + resourceManager = this.calendar.resourceManager; + return this.trigger('select', null, this.calendar.applyTimezone(span.start), this.calendar.applyTimezone(span.end), ev, this, resourceManager.getResourceById(span.resourceId)); + }, + triggerExternalDrop: function(event, dropLocation, el, ev, ui) { + this.trigger('drop', el[0], dropLocation.start, ev, ui, dropLocation.resourceId); + if (event) { + return this.trigger('eventReceive', null, event); + } + }, + + /* Hacks + * ------------------------------------------------------------------------------------------------------------------ + These triggers usually call mutateEvent with dropLocation, which causes an event modification and rerender. + But mutateEvent isn't aware of eventResourceField, so it might be setting the wrong property. Workaround. + TODO: normalize somewhere else. maybe make a hook in core. + */ + reportEventDrop: function() { + var dropLocation, event, otherArgs, ref; + event = arguments[0], dropLocation = arguments[1], otherArgs = 3 <= arguments.length ? slice.call(arguments, 2) : []; + dropLocation = this.normalizeDropLocation(dropLocation); + if (dropLocation.resourceId && event.resourceIds) { + dropLocation.resourceIds = null; + } + return (ref = View.prototype.reportEventDrop).call.apply(ref, [this, event, dropLocation].concat(slice.call(otherArgs))); + }, + reportExternalDrop: function() { + var dropLocation, meta, otherArgs, ref; + meta = arguments[0], dropLocation = arguments[1], otherArgs = 3 <= arguments.length ? slice.call(arguments, 2) : []; + dropLocation = this.normalizeDropLocation(dropLocation); + return (ref = View.prototype.reportExternalDrop).call.apply(ref, [this, meta, dropLocation].concat(slice.call(otherArgs))); + }, + normalizeDropLocation: function(dropLocation) { + var out; + out = $.extend({}, dropLocation); + delete out.resourceId; + this.calendar.setEventResourceId(out, dropLocation.resourceId); + return out; + } +}; + +ResourceGridMixin = { + allowCrossResource: true, + eventRangeToSpans: function(range, event) { + var j, len, resourceId, resourceIds, results; + resourceIds = this.view.calendar.getEventResourceIds(event); + if (resourceIds.length) { + results = []; + for (j = 0, len = resourceIds.length; j < len; j++) { + resourceId = resourceIds[j]; + results.push($.extend({}, range, { + resourceId: resourceId + })); + } + return results; + } else if (FC.isBgEvent(event)) { + return Grid.prototype.eventRangeToSpans.apply(this, arguments); + } else { + return []; + } + }, + fabricateHelperEvent: function(eventLocation, seg) { + var event; + event = Grid.prototype.fabricateHelperEvent.apply(this, arguments); + this.view.calendar.setEventResourceId(event, eventLocation.resourceId); + return event; + }, + computeEventDrop: function(startSpan, endSpan, event) { + var allowResourceChange, dropLocation; + allowResourceChange = true; + if (!allowResourceChange && startSpan.resourceId !== endSpan.resourceId) { + return null; + } + dropLocation = Grid.prototype.computeEventDrop.apply(this, arguments); + if (dropLocation) { + dropLocation.resourceId = endSpan.resourceId; + } + return dropLocation; + }, + computeExternalDrop: function(span, meta) { + var dropLocation; + dropLocation = Grid.prototype.computeExternalDrop.apply(this, arguments); + if (dropLocation) { + dropLocation.resourceId = span.resourceId; + } + return dropLocation; + }, + computeEventResize: function(type, startSpan, endSpan, event) { + var resizeLocation; + if (!this.allowCrossResource && startSpan.resourceId !== endSpan.resourceId) { + return; + } + resizeLocation = Grid.prototype.computeEventResize.apply(this, arguments); + if (resizeLocation) { + resizeLocation.resourceId = startSpan.resourceId; + } + return resizeLocation; + }, + computeSelectionSpan: function(startSpan, endSpan) { + var selectionSpan; + if (!this.allowCrossResource && startSpan.resourceId !== endSpan.resourceId) { + return; + } + selectionSpan = Grid.prototype.computeSelectionSpan.apply(this, arguments); + if (selectionSpan) { + selectionSpan.resourceId = startSpan.resourceId; + } + return selectionSpan; + } +}; + + +/* +Requirements: +- must be a Grid +- grid must have a view that's a ResourceView +- DayTableMixin must already be mixed in + */ + +ResourceDayTableMixin = { + flattenedResources: null, + resourceCnt: 0, + datesAboveResources: false, + allowCrossResource: false, + setResources: function(resources) { + this.flattenedResources = this.flattenResources(resources); + this.resourceCnt = this.flattenedResources.length; + return this.updateDayTableCols(); + }, + unsetResources: function() { + this.flattenedResources = null; + this.resourceCnt = 0; + return this.updateDayTableCols(); + }, + flattenResources: function(resources) { + var orderSpecs, orderVal, res, sortFunc; + orderVal = this.view.opt('resourceOrder'); + if (orderVal) { + orderSpecs = parseFieldSpecs(orderVal); + sortFunc = function(a, b) { + return compareByFieldSpecs(a, b, orderSpecs); + }; + } else { + sortFunc = null; + } + res = []; + this.accumulateResources(resources, sortFunc, res); + return res; + }, + accumulateResources: function(resources, sortFunc, res) { + var j, len, resource, results, sortedResources; + if (sortFunc) { + sortedResources = resources.slice(0); + sortedResources.sort(sortFunc); + } else { + sortedResources = resources; + } + results = []; + for (j = 0, len = sortedResources.length; j < len; j++) { + resource = sortedResources[j]; + res.push(resource); + results.push(this.accumulateResources(resource.children, sortFunc, res)); + } + return results; + }, + updateDayTableCols: function() { + this.datesAboveResources = this.view.opt('groupByDateAndResource'); + return FC.DayTableMixin.updateDayTableCols.call(this); + }, + computeColCnt: function() { + return (this.resourceCnt || 1) * this.daysPerRow; + }, + getColDayIndex: function(col) { + if (this.isRTL) { + col = this.colCnt - 1 - col; + } + if (this.datesAboveResources) { + return Math.floor(col / (this.resourceCnt || 1)); + } else { + return col % this.daysPerRow; + } + }, + getColResource: function(col) { + return this.flattenedResources[this.getColResourceIndex(col)]; + }, + getColResourceIndex: function(col) { + if (this.isRTL) { + col = this.colCnt - 1 - col; + } + if (this.datesAboveResources) { + return col % (this.resourceCnt || 1); + } else { + return Math.floor(col / this.daysPerRow); + } + }, + indicesToCol: function(resourceIndex, dayIndex) { + var col; + col = this.datesAboveResources ? dayIndex * (this.resourceCnt || 1) + resourceIndex : resourceIndex * this.daysPerRow + dayIndex; + if (this.isRTL) { + col = this.colCnt - 1 - col; + } + return col; + }, + renderHeadTrHtml: function() { + if (!this.resourceCnt) { + return FC.DayTableMixin.renderHeadTrHtml.call(this); + } else { + if (this.daysPerRow > 1) { + if (this.datesAboveResources) { + return this.renderHeadDateAndResourceHtml(); + } else { + return this.renderHeadResourceAndDateHtml(); + } + } else { + return this.renderHeadResourceHtml(); + } + } + }, + renderHeadResourceHtml: function() { + var j, len, ref, resource, resourceHtmls; + resourceHtmls = []; + ref = this.flattenedResources; + for (j = 0, len = ref.length; j < len; j++) { + resource = ref[j]; + resourceHtmls.push(this.renderHeadResourceCellHtml(resource)); + } + return this.wrapTr(resourceHtmls, 'renderHeadIntroHtml'); + }, + renderHeadResourceAndDateHtml: function() { + var date, dateHtmls, dayIndex, j, k, len, ref, ref1, resource, resourceHtmls; + resourceHtmls = []; + dateHtmls = []; + ref = this.flattenedResources; + for (j = 0, len = ref.length; j < len; j++) { + resource = ref[j]; + resourceHtmls.push(this.renderHeadResourceCellHtml(resource, null, this.daysPerRow)); + for (dayIndex = k = 0, ref1 = this.daysPerRow; k < ref1; dayIndex = k += 1) { + date = this.dayDates[dayIndex].clone(); + dateHtmls.push(this.renderHeadResourceDateCellHtml(date, resource)); + } + } + return this.wrapTr(resourceHtmls, 'renderHeadIntroHtml') + this.wrapTr(dateHtmls, 'renderHeadIntroHtml'); + }, + renderHeadDateAndResourceHtml: function() { + var date, dateHtmls, dayIndex, j, k, len, ref, ref1, resource, resourceHtmls; + dateHtmls = []; + resourceHtmls = []; + for (dayIndex = j = 0, ref = this.daysPerRow; j < ref; dayIndex = j += 1) { + date = this.dayDates[dayIndex].clone(); + dateHtmls.push(this.renderHeadDateCellHtml(date, this.resourceCnt)); + ref1 = this.flattenedResources; + for (k = 0, len = ref1.length; k < len; k++) { + resource = ref1[k]; + resourceHtmls.push(this.renderHeadResourceCellHtml(resource, date)); + } + } + return this.wrapTr(dateHtmls, 'renderHeadIntroHtml') + this.wrapTr(resourceHtmls, 'renderHeadIntroHtml'); + }, + renderHeadResourceCellHtml: function(resource, date, colspan) { + return ' 1 ? ' colspan="' + colspan + '"' : '') + '>' + htmlEscape(this.view.getResourceText(resource)) + ''; + }, + renderHeadResourceDateCellHtml: function(date, resource, colspan) { + return this.renderHeadDateCellHtml(date, colspan, 'data-resource-id="' + resource.id + '"'); + }, + processHeadResourceEls: function(containerEl) { + return containerEl.find('.fc-resource-cell').each((function(_this) { + return function(col, node) { + var resource; + if (_this.datesAboveResources) { + resource = _this.getColResource(col); + } else { + resource = _this.flattenedResources[_this.isRTL ? _this.flattenedResources.length - 1 - col : col]; + } + return _this.view.trigger('resourceRender', resource, resource, $(node), $()); + }; + })(this)); + }, + renderBgCellsHtml: function(row) { + var col, date, htmls, j, ref, resource; + if (!this.resourceCnt) { + return FC.DayTableMixin.renderBgCellsHtml.call(this, row); + } else { + htmls = []; + for (col = j = 0, ref = this.colCnt; j < ref; col = j += 1) { + date = this.getCellDate(row, col); + resource = this.getColResource(col); + htmls.push(this.renderResourceBgCellHtml(date, resource)); + } + return htmls.join(''); + } + }, + renderResourceBgCellHtml: function(date, resource) { + return this.renderBgCellHtml(date, 'data-resource-id="' + resource.id + '"'); + }, + wrapTr: function(cellHtmls, introMethodName) { + if (this.isRTL) { + cellHtmls.reverse(); + return '' + cellHtmls.join('') + this[introMethodName]() + ''; + } else { + return '' + this[introMethodName]() + cellHtmls.join('') + ''; + } + } +}; + +ResourceDayGrid = (function(superClass) { + extend(ResourceDayGrid, superClass); + + function ResourceDayGrid() { + return ResourceDayGrid.__super__.constructor.apply(this, arguments); + } + + ResourceDayGrid.mixin(ResourceGridMixin); + + ResourceDayGrid.mixin(ResourceDayTableMixin); + + ResourceDayGrid.prototype.getHitSpan = function(hit) { + var span; + span = ResourceDayGrid.__super__.getHitSpan.apply(this, arguments); + if (this.resourceCnt) { + span.resourceId = this.getColResource(hit.col).id; + } + return span; + }; + + ResourceDayGrid.prototype.spanToSegs = function(span) { + var copy, genericSegs, j, k, l, len, len1, ref, resourceCnt, resourceIndex, resourceObj, resourceSegs, seg; + resourceCnt = this.resourceCnt; + genericSegs = this.datesAboveResources ? this.sliceRangeByDay(span) : this.sliceRangeByRow(span); + if (!resourceCnt) { + for (j = 0, len = genericSegs.length; j < len; j++) { + seg = genericSegs[j]; + if (this.isRTL) { + seg.leftCol = seg.lastRowDayIndex; + seg.rightCol = seg.firstRowDayIndex; + } else { + seg.leftCol = seg.firstRowDayIndex; + seg.rightCol = seg.lastRowDayIndex; + } + } + return genericSegs; + } else { + resourceSegs = []; + for (k = 0, len1 = genericSegs.length; k < len1; k++) { + seg = genericSegs[k]; + for (resourceIndex = l = 0, ref = resourceCnt; l < ref; resourceIndex = l += 1) { + resourceObj = this.flattenedResources[resourceIndex]; + if (!span.resourceId || span.resourceId === resourceObj.id) { + copy = $.extend({}, seg); + copy.resource = resourceObj; + if (this.isRTL) { + copy.leftCol = this.indicesToCol(resourceIndex, seg.lastRowDayIndex); + copy.rightCol = this.indicesToCol(resourceIndex, seg.firstRowDayIndex); + } else { + copy.leftCol = this.indicesToCol(resourceIndex, seg.firstRowDayIndex); + copy.rightCol = this.indicesToCol(resourceIndex, seg.lastRowDayIndex); + } + resourceSegs.push(copy); + } + } + } + return resourceSegs; + } + }; + + return ResourceDayGrid; + +})(FC.DayGrid); + +ResourceTimeGrid = (function(superClass) { + extend(ResourceTimeGrid, superClass); + + function ResourceTimeGrid() { + return ResourceTimeGrid.__super__.constructor.apply(this, arguments); + } + + ResourceTimeGrid.mixin(ResourceGridMixin); + + ResourceTimeGrid.mixin(ResourceDayTableMixin); + + ResourceTimeGrid.prototype.getHitSpan = function(hit) { + var span; + span = ResourceTimeGrid.__super__.getHitSpan.apply(this, arguments); + if (this.resourceCnt) { + span.resourceId = this.getColResource(hit.col).id; + } + return span; + }; + + ResourceTimeGrid.prototype.spanToSegs = function(span) { + var copy, genericSegs, j, k, l, len, len1, ref, resourceCnt, resourceIndex, resourceObj, resourceSegs, seg; + resourceCnt = this.resourceCnt; + genericSegs = this.sliceRangeByTimes(span); + if (!resourceCnt) { + for (j = 0, len = genericSegs.length; j < len; j++) { + seg = genericSegs[j]; + seg.col = seg.dayIndex; + } + return genericSegs; + } else { + resourceSegs = []; + for (k = 0, len1 = genericSegs.length; k < len1; k++) { + seg = genericSegs[k]; + for (resourceIndex = l = 0, ref = resourceCnt; l < ref; resourceIndex = l += 1) { + resourceObj = this.flattenedResources[resourceIndex]; + if (!span.resourceId || span.resourceId === resourceObj.id) { + copy = $.extend({}, seg); + copy.resource = resourceObj; + copy.col = this.indicesToCol(resourceIndex, seg.dayIndex); + resourceSegs.push(copy); + } + } + } + return resourceSegs; + } + }; + + return ResourceTimeGrid; + +})(FC.TimeGrid); + +TimelineView = (function(superClass) { + extend(TimelineView, superClass); + + function TimelineView() { + return TimelineView.__super__.constructor.apply(this, arguments); + } + + TimelineView.prototype.timeGrid = null; + + TimelineView.prototype.isScrolled = false; + + TimelineView.prototype.initialize = function() { + this.timeGrid = this.instantiateGrid(); + return this.intervalDuration = this.timeGrid.duration; + }; + + TimelineView.prototype.instantiateGrid = function() { + return new TimelineGrid(this); + }; + + TimelineView.prototype.setRange = function(range) { + TimelineView.__super__.setRange.apply(this, arguments); + return this.timeGrid.setRange(range); + }; + + TimelineView.prototype.renderSkeleton = function() { + this.el.addClass('fc-timeline'); + if (this.opt('eventOverlap') === false) { + this.el.addClass('fc-no-overlap'); + } + this.el.html(this.renderSkeletonHtml()); + return this.renderTimeGridSkeleton(); + }; + + TimelineView.prototype.renderSkeletonHtml = function() { + return '
'; + }; + + TimelineView.prototype.renderTimeGridSkeleton = function() { + this.timeGrid.setElement(this.el.find('tbody .fc-time-area')); + this.timeGrid.headEl = this.el.find('thead .fc-time-area'); + this.timeGrid.renderSkeleton(); + this.isScrolled = false; + return this.timeGrid.bodyScroller.on('scroll', proxy(this, 'handleBodyScroll')); + }; + + TimelineView.prototype.handleBodyScroll = function(top, left) { + if (top) { + if (!this.isScrolled) { + this.isScrolled = true; + return this.el.addClass('fc-scrolled'); + } + } else { + if (this.isScrolled) { + this.isScrolled = false; + return this.el.removeClass('fc-scrolled'); + } + } + }; + + TimelineView.prototype.unrenderSkeleton = function() { + this.timeGrid.removeElement(); + this.handleBodyScroll(0); + return TimelineView.__super__.unrenderSkeleton.apply(this, arguments); + }; + + TimelineView.prototype.renderDates = function() { + return this.timeGrid.renderDates(); + }; + + TimelineView.prototype.unrenderDates = function() { + return this.timeGrid.unrenderDates(); + }; + + TimelineView.prototype.renderBusinessHours = function() { + return this.timeGrid.renderBusinessHours(); + }; + + TimelineView.prototype.unrenderBusinessHours = function() { + return this.timeGrid.unrenderBusinessHours(); + }; + + TimelineView.prototype.getNowIndicatorUnit = function() { + return this.timeGrid.getNowIndicatorUnit(); + }; + + TimelineView.prototype.renderNowIndicator = function(date) { + return this.timeGrid.renderNowIndicator(date); + }; + + TimelineView.prototype.unrenderNowIndicator = function() { + return this.timeGrid.unrenderNowIndicator(); + }; + + TimelineView.prototype.prepareHits = function() { + return this.timeGrid.prepareHits(); + }; + + TimelineView.prototype.releaseHits = function() { + return this.timeGrid.releaseHits(); + }; + + TimelineView.prototype.queryHit = function(leftOffset, topOffset) { + return this.timeGrid.queryHit(leftOffset, topOffset); + }; + + TimelineView.prototype.getHitSpan = function(hit) { + return this.timeGrid.getHitSpan(hit); + }; + + TimelineView.prototype.getHitEl = function(hit) { + return this.timeGrid.getHitEl(hit); + }; + + TimelineView.prototype.updateWidth = function() { + return this.timeGrid.updateWidth(); + }; + + TimelineView.prototype.setHeight = function(totalHeight, isAuto) { + var bodyHeight; + if (isAuto) { + bodyHeight = 'auto'; + } else { + bodyHeight = totalHeight - this.timeGrid.headHeight() - this.queryMiscHeight(); + } + return this.timeGrid.bodyScroller.setHeight(bodyHeight); + }; + + TimelineView.prototype.queryMiscHeight = function() { + return this.el.outerHeight() - this.timeGrid.headScroller.el.outerHeight() - this.timeGrid.bodyScroller.el.outerHeight(); + }; + + TimelineView.prototype.computeInitialScroll = function(prevScrollState) { + return this.timeGrid.computeInitialScroll(prevScrollState); + }; + + TimelineView.prototype.queryScroll = function() { + return this.timeGrid.queryScroll(); + }; + + TimelineView.prototype.setScroll = function(state) { + return this.timeGrid.setScroll(state); + }; + + TimelineView.prototype.renderEvents = function(events) { + this.timeGrid.renderEvents(events); + return this.updateWidth(); + }; + + TimelineView.prototype.unrenderEvents = function() { + this.timeGrid.unrenderEvents(); + return this.updateWidth(); + }; + + TimelineView.prototype.renderDrag = function(dropLocation, seg) { + return this.timeGrid.renderDrag(dropLocation, seg); + }; + + TimelineView.prototype.unrenderDrag = function() { + return this.timeGrid.unrenderDrag(); + }; + + TimelineView.prototype.getEventSegs = function() { + return this.timeGrid.getEventSegs(); + }; + + TimelineView.prototype.renderSelection = function(range) { + return this.timeGrid.renderSelection(range); + }; + + TimelineView.prototype.unrenderSelection = function() { + return this.timeGrid.unrenderSelection(); + }; + + return TimelineView; + +})(View); + +cssToStr = FC.cssToStr; + +TimelineGrid = (function(superClass) { + extend(TimelineGrid, superClass); + + TimelineGrid.prototype.slotDates = null; + + TimelineGrid.prototype.slotCnt = null; + + TimelineGrid.prototype.snapCnt = null; + + TimelineGrid.prototype.snapsPerSlot = null; + + TimelineGrid.prototype.snapDiffToIndex = null; + + TimelineGrid.prototype.snapIndexToDiff = null; + + TimelineGrid.prototype.headEl = null; + + TimelineGrid.prototype.slatContainerEl = null; + + TimelineGrid.prototype.slatEls = null; + + TimelineGrid.prototype.containerCoordCache = null; + + TimelineGrid.prototype.slatCoordCache = null; + + TimelineGrid.prototype.slatInnerCoordCache = null; + + TimelineGrid.prototype.headScroller = null; + + TimelineGrid.prototype.bodyScroller = null; + + TimelineGrid.prototype.joiner = null; + + TimelineGrid.prototype.follower = null; + + TimelineGrid.prototype.eventTitleFollower = null; + + TimelineGrid.prototype.minTime = null; + + TimelineGrid.prototype.maxTime = null; + + TimelineGrid.prototype.timeWindowMs = null; + + TimelineGrid.prototype.slotDuration = null; + + TimelineGrid.prototype.snapDuration = null; + + TimelineGrid.prototype.duration = null; + + TimelineGrid.prototype.labelInterval = null; + + TimelineGrid.prototype.headerFormats = null; + + TimelineGrid.prototype.isTimeScale = null; + + TimelineGrid.prototype.largeUnit = null; + + TimelineGrid.prototype.emphasizeWeeks = false; + + TimelineGrid.prototype.titleFollower = null; + + TimelineGrid.prototype.segContainerEl = null; + + TimelineGrid.prototype.segContainerHeight = null; + + TimelineGrid.prototype.bgSegContainerEl = null; + + TimelineGrid.prototype.helperEls = null; + + TimelineGrid.prototype.innerEl = null; + + function TimelineGrid() { + var input; + TimelineGrid.__super__.constructor.apply(this, arguments); + this.initScaleProps(); + this.minTime = moment.duration(this.opt('minTime') || '00:00'); + this.maxTime = moment.duration(this.opt('maxTime') || '24:00'); + this.timeWindowMs = this.maxTime - this.minTime; + this.snapDuration = (input = this.opt('snapDuration')) ? moment.duration(input) : this.slotDuration; + this.minResizeDuration = this.snapDuration; + this.snapsPerSlot = divideDurationByDuration(this.slotDuration, this.snapDuration); + this.slotWidth = this.opt('slotWidth'); + } + + TimelineGrid.prototype.opt = function(name) { + return this.view.opt(name); + }; + + TimelineGrid.prototype.isValidDate = function(date) { + var ms; + if (this.view.isHiddenDay(date)) { + return false; + } else if (this.isTimeScale) { + ms = date.time() - this.minTime; + ms = ((ms % 86400000) + 86400000) % 86400000; + return ms < this.timeWindowMs; + } else { + return true; + } + }; + + TimelineGrid.prototype.computeDisplayEventTime = function() { + return !this.isTimeScale; + }; + + TimelineGrid.prototype.computeDisplayEventEnd = function() { + return false; + }; + + TimelineGrid.prototype.computeEventTimeFormat = function() { + return this.opt('extraSmallTimeFormat'); + }; + + + /* + Makes the given date consistent with isTimeScale/largeUnit, + so, either removes the times, ensures a time, or makes it the startOf largeUnit. + Strips all timezones. Returns new copy. + TODO: should maybe be called "normalizeRangeDate". + */ + + TimelineGrid.prototype.normalizeGridDate = function(date) { + var normalDate; + if (this.isTimeScale) { + normalDate = date.clone(); + if (!normalDate.hasTime()) { + normalDate.time(0); + } + } else { + normalDate = date.clone().stripTime(); + if (this.largeUnit) { + normalDate.startOf(this.largeUnit); + } + } + return normalDate; + }; + + TimelineGrid.prototype.normalizeGridRange = function(range) { + var adjustedEnd, normalRange; + if (this.isTimeScale) { + normalRange = { + start: this.normalizeGridDate(range.start), + end: this.normalizeGridDate(range.end) + }; + } else { + normalRange = this.view.computeDayRange(range); + if (this.largeUnit) { + normalRange.start.startOf(this.largeUnit); + adjustedEnd = normalRange.end.clone().startOf(this.largeUnit); + if (!adjustedEnd.isSame(normalRange.end) || !adjustedEnd.isAfter(normalRange.start)) { + adjustedEnd.add(this.slotDuration); + } + normalRange.end = adjustedEnd; + } + } + return normalRange; + }; + + TimelineGrid.prototype.rangeUpdated = function() { + var date, slotDates; + this.start = this.normalizeGridDate(this.start); + this.end = this.normalizeGridDate(this.end); + if (this.isTimeScale) { + this.start.add(this.minTime); + this.end.subtract(1, 'day').add(this.maxTime); + } + slotDates = []; + date = this.start.clone(); + while (date < this.end) { + if (this.isValidDate(date)) { + slotDates.push(date.clone()); + } + date.add(this.slotDuration); + } + this.slotDates = slotDates; + return this.updateGridDates(); + }; + + TimelineGrid.prototype.updateGridDates = function() { + var date, snapDiff, snapDiffToIndex, snapIndex, snapIndexToDiff; + snapIndex = -1; + snapDiff = 0; + snapDiffToIndex = []; + snapIndexToDiff = []; + date = this.start.clone(); + while (date < this.end) { + if (this.isValidDate(date)) { + snapIndex++; + snapDiffToIndex.push(snapIndex); + snapIndexToDiff.push(snapDiff); + } else { + snapDiffToIndex.push(snapIndex + 0.5); + } + date.add(this.snapDuration); + snapDiff++; + } + this.snapDiffToIndex = snapDiffToIndex; + this.snapIndexToDiff = snapIndexToDiff; + this.snapCnt = snapIndex + 1; + return this.slotCnt = this.snapCnt / this.snapsPerSlot; + }; + + TimelineGrid.prototype.spanToSegs = function(span) { + var normalRange, seg; + normalRange = this.normalizeGridRange(span); + if (this.computeDateSnapCoverage(span.start) < this.computeDateSnapCoverage(span.end)) { + seg = intersectRanges(normalRange, this); + if (seg) { + if (seg.isStart && !this.isValidDate(seg.start)) { + seg.isStart = false; + } + if (seg.isEnd && seg.end && !this.isValidDate(seg.end.clone().subtract(1))) { + seg.isEnd = false; + } + return [seg]; + } + } + return []; + }; + + TimelineGrid.prototype.prepareHits = function() { + return this.buildCoords(); + }; + + TimelineGrid.prototype.queryHit = function(leftOffset, topOffset) { + var containerCoordCache, localSnapIndex, partial, slatCoordCache, slatIndex, slatLeft, slatRight, slatWidth, snapIndex, snapLeft, snapRight, snapsPerSlot; + snapsPerSlot = this.snapsPerSlot; + slatCoordCache = this.slatCoordCache; + containerCoordCache = this.containerCoordCache; + if (containerCoordCache.getVerticalIndex(topOffset) != null) { + slatIndex = slatCoordCache.getHorizontalIndex(leftOffset); + if (slatIndex != null) { + slatWidth = slatCoordCache.getWidth(slatIndex); + if (this.isRTL) { + slatRight = slatCoordCache.getRightOffset(slatIndex); + partial = (slatRight - leftOffset) / slatWidth; + localSnapIndex = Math.floor(partial * snapsPerSlot); + snapIndex = slatIndex * snapsPerSlot + localSnapIndex; + snapRight = slatRight - (localSnapIndex / snapsPerSlot) * slatWidth; + snapLeft = snapRight - ((localSnapIndex + 1) / snapsPerSlot) * slatWidth; + } else { + slatLeft = slatCoordCache.getLeftOffset(slatIndex); + partial = (leftOffset - slatLeft) / slatWidth; + localSnapIndex = Math.floor(partial * snapsPerSlot); + snapIndex = slatIndex * snapsPerSlot + localSnapIndex; + snapLeft = slatLeft + (localSnapIndex / snapsPerSlot) * slatWidth; + snapRight = slatLeft + ((localSnapIndex + 1) / snapsPerSlot) * slatWidth; + } + return { + snap: snapIndex, + component: this, + left: snapLeft, + right: snapRight, + top: containerCoordCache.getTopOffset(0), + bottom: containerCoordCache.getBottomOffset(0) + }; + } + } + }; + + TimelineGrid.prototype.getHitSpan = function(hit) { + return this.getSnapRange(hit.snap); + }; + + TimelineGrid.prototype.getHitEl = function(hit) { + return this.getSnapEl(hit.snap); + }; + + TimelineGrid.prototype.getSnapRange = function(snapIndex) { + var end, start; + start = this.start.clone(); + start.add(multiplyDuration(this.snapDuration, this.snapIndexToDiff[snapIndex])); + end = start.clone().add(this.snapDuration); + return { + start: start, + end: end + }; + }; + + TimelineGrid.prototype.getSnapEl = function(snapIndex) { + return this.slatEls.eq(Math.floor(snapIndex / this.snapsPerSlot)); + }; + + TimelineGrid.prototype.renderSkeleton = function() { + this.headScroller = new ClippedScroller({ + overflowX: 'clipped-scroll', + overflowY: 'hidden' + }); + this.headScroller.canvas = new ScrollerCanvas(); + this.headScroller.render(); + this.headEl.append(this.headScroller.el); + this.bodyScroller = new ClippedScroller(); + this.bodyScroller.canvas = new ScrollerCanvas(); + this.bodyScroller.render(); + this.el.append(this.bodyScroller.el); + this.innerEl = this.bodyScroller.canvas.contentEl; + this.slatContainerEl = $('
').appendTo(this.bodyScroller.canvas.bgEl); + this.segContainerEl = $('
').appendTo(this.bodyScroller.canvas.contentEl); + this.bgSegContainerEl = this.bodyScroller.canvas.bgEl; + this.containerCoordCache = new CoordCache({ + els: this.bodyScroller.canvas.el, + isHorizontal: true, + isVertical: true + }); + this.joiner = new ScrollJoiner('horizontal', [this.headScroller, this.bodyScroller]); + if (true) { + this.follower = new ScrollFollower(this.headScroller, this.view.calendar.isTouch); + } + if (true) { + this.eventTitleFollower = new ScrollFollower(this.bodyScroller, this.view.calendar.isTouch); + this.eventTitleFollower.minTravel = 50; + if (this.isRTL) { + this.eventTitleFollower.containOnNaturalRight = true; + } else { + this.eventTitleFollower.containOnNaturalLeft = true; + } + } + return TimelineGrid.__super__.renderSkeleton.apply(this, arguments); + }; + + TimelineGrid.prototype.headColEls = null; + + TimelineGrid.prototype.slatColEls = null; + + TimelineGrid.prototype.renderDates = function() { + var date, i, j, len, ref; + this.headScroller.canvas.contentEl.html(this.renderHeadHtml()); + this.headColEls = this.headScroller.canvas.contentEl.find('col'); + this.slatContainerEl.html(this.renderSlatHtml()); + this.slatColEls = this.slatContainerEl.find('col'); + this.slatEls = this.slatContainerEl.find('td'); + this.slatCoordCache = new CoordCache({ + els: this.slatEls, + isHorizontal: true + }); + this.slatInnerCoordCache = new CoordCache({ + els: this.slatEls.find('> div'), + isHorizontal: true, + offsetParent: this.bodyScroller.canvas.el + }); + ref = this.slotDates; + for (i = j = 0, len = ref.length; j < len; i = ++j) { + date = ref[i]; + this.view.trigger('dayRender', null, date, this.slatEls.eq(i)); + } + if (this.follower) { + return this.follower.setSprites(this.headEl.find('tr:not(:last-child) span')); + } + }; + + TimelineGrid.prototype.unrenderDates = function() { + if (this.follower) { + this.follower.clearSprites(); + } + this.headScroller.canvas.contentEl.empty(); + this.slatContainerEl.empty(); + this.headScroller.canvas.clearWidth(); + return this.bodyScroller.canvas.clearWidth(); + }; + + TimelineGrid.prototype.renderHeadHtml = function() { + var cell, cellRows, date, dateData, format, formats, html, i, isChrono, isLast, isSuperRow, isWeekStart, j, k, l, labelInterval, leadingCell, len, len1, len2, len3, len4, len5, len6, m, n, newCell, p, prevWeekNumber, q, row, rowCells, slatHtml, slotCells, slotDates, text, weekNumber; + labelInterval = this.labelInterval; + formats = this.headerFormats; + cellRows = (function() { + var j, len, results; + results = []; + for (j = 0, len = formats.length; j < len; j++) { + format = formats[j]; + results.push([]); + } + return results; + })(); + leadingCell = null; + prevWeekNumber = null; + slotDates = this.slotDates; + slotCells = []; + for (j = 0, len = slotDates.length; j < len; j++) { + date = slotDates[j]; + weekNumber = date.week(); + isWeekStart = this.emphasizeWeeks && prevWeekNumber !== null && prevWeekNumber !== weekNumber; + for (row = k = 0, len1 = formats.length; k < len1; row = ++k) { + format = formats[row]; + rowCells = cellRows[row]; + leadingCell = rowCells[rowCells.length - 1]; + isSuperRow = formats.length > 1 && row < formats.length - 1; + newCell = null; + if (isSuperRow) { + text = date.format(format); + dateData = date.format(); + if (!leadingCell || leadingCell.text !== text) { + newCell = { + text: text, + dateData: dateData, + colspan: 1 + }; + } else { + leadingCell.colspan += 1; + } + } else { + if (!leadingCell || isInt(divideRangeByDuration(this.start, date, labelInterval))) { + text = date.format(format); + dateData = date.format(); + newCell = { + text: text, + dateData: dateData, + colspan: 1 + }; + } else { + leadingCell.colspan += 1; + } + } + if (newCell) { + newCell.weekStart = isWeekStart; + rowCells.push(newCell); + } + } + slotCells.push({ + weekStart: isWeekStart + }); + prevWeekNumber = weekNumber; + } + isChrono = labelInterval > this.slotDuration; + html = ''; + html += ''; + for (l = 0, len2 = slotDates.length; l < len2; l++) { + date = slotDates[l]; + html += ''; + } + html += ''; + html += ''; + for (i = m = 0, len3 = cellRows.length; m < len3; i = ++m) { + rowCells = cellRows[i]; + isLast = i === cellRows.length - 1; + html += ''; + for (n = 0, len4 = rowCells.length; n < len4; n++) { + cell = rowCells[n]; + html += ''; + } + html += ''; + } + html += '
1 ? ' colspan="' + cell.colspan + '"' : '') + '>' + '
' + '' + htmlEscape(cell.text) + '' + '
' + '
'; + slatHtml = ''; + slatHtml += ''; + for (p = 0, len5 = slotCells.length; p < len5; p++) { + cell = slotCells[p]; + slatHtml += ''; + } + slatHtml += ''; + slatHtml += ''; + for (i = q = 0, len6 = slotCells.length; q < len6; i = ++q) { + cell = slotCells[i]; + date = slotDates[i]; + slatHtml += this.slatCellHtml(date, cell.weekStart); + } + slatHtml += '
'; + this._slatHtml = slatHtml; + return html; + }; + + TimelineGrid.prototype.renderSlatHtml = function() { + return this._slatHtml; + }; + + TimelineGrid.prototype.slatCellHtml = function(date, isEm) { + var classes; + if (this.isTimeScale) { + classes = []; + classes.push(isInt(divideRangeByDuration(this.start, date, this.labelInterval)) ? 'fc-major' : 'fc-minor'); + } else { + classes = this.getDayClasses(date); + classes.push('fc-day'); + } + classes.unshift(this.view.widgetContentClass); + if (isEm) { + classes.push('fc-em-cell'); + } + return '
'; + }; + + TimelineGrid.prototype.businessHourSegs = null; + + TimelineGrid.prototype.renderBusinessHours = function() { + var events, segs; + if (!this.largeUnit) { + events = this.view.calendar.getBusinessHoursEvents(!this.isTimeScale); + segs = this.businessHourSegs = this.eventsToSegs(events); + return this.renderFill('businessHours', segs, 'bgevent'); + } + }; + + TimelineGrid.prototype.unrenderBusinessHours = function() { + return this.unrenderFill('businessHours'); + }; + + TimelineGrid.prototype.nowIndicatorEls = null; + + TimelineGrid.prototype.getNowIndicatorUnit = function() { + if (this.isTimeScale) { + return computeIntervalUnit(this.slotDuration); + } + }; + + TimelineGrid.prototype.renderNowIndicator = function(date) { + var coord, css, nodes; + nodes = []; + date = this.normalizeGridDate(date); + if (date >= this.start && date < this.end) { + coord = this.dateToCoord(date); + css = this.isRTL ? { + right: -coord + } : { + left: coord + }; + nodes.push($("
").css(css).appendTo(this.headScroller.canvas.el)[0]); + nodes.push($("
").css(css).appendTo(this.bodyScroller.canvas.el)[0]); + } + return this.nowIndicatorEls = $(nodes); + }; + + TimelineGrid.prototype.unrenderNowIndicator = function() { + if (this.nowIndicatorEls) { + this.nowIndicatorEls.remove(); + return this.nowIndicatorEls = null; + } + }; + + TimelineGrid.prototype.explicitSlotWidth = null; + + TimelineGrid.prototype.defaultSlotWidth = null; + + TimelineGrid.prototype.updateWidth = function() { + var availableWidth, containerMinWidth, containerWidth, nonLastSlotWidth, slotWidth; + slotWidth = Math.round(this.slotWidth || (this.slotWidth = this.computeSlotWidth())); + containerWidth = slotWidth * this.slotDates.length; + containerMinWidth = ''; + nonLastSlotWidth = slotWidth; + availableWidth = this.bodyScroller.getClientWidth(); + if (availableWidth > containerWidth) { + containerMinWidth = availableWidth; + containerWidth = ''; + nonLastSlotWidth = Math.floor(availableWidth / this.slotDates.length); + } + this.headScroller.canvas.setWidth(containerWidth); + this.headScroller.canvas.setMinWidth(containerMinWidth); + this.bodyScroller.canvas.setWidth(containerWidth); + this.bodyScroller.canvas.setMinWidth(containerMinWidth); + this.headColEls.slice(0, -1).add(this.slatColEls.slice(0, -1)).width(nonLastSlotWidth); + this.headScroller.updateSize(); + this.bodyScroller.updateSize(); + this.joiner.update(); + this.buildCoords(); + this.updateSegPositions(); + this.view.updateNowIndicator(); + if (this.follower) { + this.follower.update(); + } + if (this.eventTitleFollower) { + return this.eventTitleFollower.update(); + } + }; + + TimelineGrid.prototype.computeSlotWidth = function() { + var headerWidth, innerEls, maxInnerWidth, minWidth, slotWidth, slotsPerLabel; + maxInnerWidth = 0; + innerEls = this.headEl.find('tr:last-child th span'); + innerEls.each(function(i, node) { + var innerWidth; + innerWidth = $(node).outerWidth(); + return maxInnerWidth = Math.max(maxInnerWidth, innerWidth); + }); + headerWidth = maxInnerWidth + 1; + slotsPerLabel = divideDurationByDuration(this.labelInterval, this.slotDuration); + slotWidth = Math.ceil(headerWidth / slotsPerLabel); + minWidth = this.headColEls.eq(0).css('min-width'); + if (minWidth) { + minWidth = parseInt(minWidth, 10); + if (minWidth) { + slotWidth = Math.max(slotWidth, minWidth); + } + } + return slotWidth; + }; + + TimelineGrid.prototype.buildCoords = function() { + this.containerCoordCache.build(); + this.slatCoordCache.build(); + return this.slatInnerCoordCache.build(); + }; + + TimelineGrid.prototype.computeDateSnapCoverage = function(date) { + var snapCoverage, snapDiff, snapDiffInt; + snapDiff = divideRangeByDuration(this.start, date, this.snapDuration); + if (snapDiff < 0) { + return 0; + } else if (snapDiff >= this.snapDiffToIndex.length) { + return this.snapCnt; + } else { + snapDiffInt = Math.floor(snapDiff); + snapCoverage = this.snapDiffToIndex[snapDiffInt]; + if (isInt(snapCoverage)) { + snapCoverage += snapDiff - snapDiffInt; + } else { + snapCoverage = Math.ceil(snapCoverage); + } + return snapCoverage; + } + }; + + TimelineGrid.prototype.dateToCoord = function(date) { + var coordCache, partial, slotCoverage, slotIndex, snapCoverage; + snapCoverage = this.computeDateSnapCoverage(date); + slotCoverage = snapCoverage / this.snapsPerSlot; + slotIndex = Math.floor(slotCoverage); + slotIndex = Math.min(slotIndex, this.slotCnt - 1); + partial = slotCoverage - slotIndex; + coordCache = this.slatInnerCoordCache; + if (this.isRTL) { + return (coordCache.getRightPosition(slotIndex) - coordCache.getWidth(slotIndex) * partial) - this.containerCoordCache.getWidth(0); + } else { + return coordCache.getLeftPosition(slotIndex) + coordCache.getWidth(slotIndex) * partial; + } + }; + + TimelineGrid.prototype.rangeToCoords = function(range) { + if (this.isRTL) { + return { + right: this.dateToCoord(range.start), + left: this.dateToCoord(range.end) + }; + } else { + return { + left: this.dateToCoord(range.start), + right: this.dateToCoord(range.end) + }; + } + }; + + TimelineGrid.prototype.headHeight = function() { + var table; + table = this.headScroller.canvas.contentEl.find('table'); + return table.height.apply(table, arguments); + }; + + TimelineGrid.prototype.updateSegPositions = function() { + var coords, j, len, seg, segs; + segs = (this.segs || []).concat(this.businessHourSegs || []); + for (j = 0, len = segs.length; j < len; j++) { + seg = segs[j]; + coords = this.rangeToCoords(seg); + seg.el.css({ + left: (seg.left = coords.left), + right: -(seg.right = coords.right) + }); + } + }; + + TimelineGrid.prototype.computeInitialScroll = function(prevState) { + var left, scrollTime; + left = 0; + if (this.isTimeScale) { + scrollTime = this.opt('scrollTime'); + if (scrollTime) { + scrollTime = moment.duration(scrollTime); + left = this.dateToCoord(this.start.clone().time(scrollTime)); + } + } + return { + left: left, + top: 0 + }; + }; + + TimelineGrid.prototype.queryScroll = function() { + return { + left: this.bodyScroller.getScrollLeft(), + top: this.bodyScroller.getScrollTop() + }; + }; + + TimelineGrid.prototype.setScroll = function(state) { + this.headScroller.setScrollLeft(state.left); + this.headScroller.setScrollLeft(state.left); + return this.bodyScroller.setScrollTop(state.top); + }; + + TimelineGrid.prototype.renderFgSegs = function(segs) { + segs = this.renderFgSegEls(segs); + this.renderFgSegsInContainers([[this, segs]]); + this.updateSegFollowers(segs); + return segs; + }; + + TimelineGrid.prototype.unrenderFgSegs = function() { + this.clearSegFollowers(); + return this.unrenderFgContainers([this]); + }; + + TimelineGrid.prototype.renderFgSegsInContainers = function(pairs) { + var container, coords, j, k, l, len, len1, len2, len3, len4, len5, len6, len7, m, n, p, q, r, ref, ref1, ref2, ref3, results, seg, segs; + for (j = 0, len = pairs.length; j < len; j++) { + ref = pairs[j], container = ref[0], segs = ref[1]; + for (k = 0, len1 = segs.length; k < len1; k++) { + seg = segs[k]; + coords = this.rangeToCoords(seg); + seg.el.css({ + left: (seg.left = coords.left), + right: -(seg.right = coords.right) + }); + } + } + for (l = 0, len2 = pairs.length; l < len2; l++) { + ref1 = pairs[l], container = ref1[0], segs = ref1[1]; + for (m = 0, len3 = segs.length; m < len3; m++) { + seg = segs[m]; + seg.el.appendTo(container.segContainerEl); + } + } + for (n = 0, len4 = pairs.length; n < len4; n++) { + ref2 = pairs[n], container = ref2[0], segs = ref2[1]; + for (p = 0, len5 = segs.length; p < len5; p++) { + seg = segs[p]; + seg.height = seg.el.outerHeight(true); + } + this.buildSegLevels(segs); + container.segContainerHeight = computeOffsetForSegs(segs); + } + results = []; + for (q = 0, len6 = pairs.length; q < len6; q++) { + ref3 = pairs[q], container = ref3[0], segs = ref3[1]; + for (r = 0, len7 = segs.length; r < len7; r++) { + seg = segs[r]; + seg.el.css('top', seg.top); + } + results.push(container.segContainerEl.height(container.segContainerHeight)); + } + return results; + }; + + TimelineGrid.prototype.buildSegLevels = function(segs) { + var belowSeg, isLevelCollision, j, k, l, len, len1, len2, level, placedSeg, ref, ref1, segLevels, unplacedSeg; + segLevels = []; + this.sortEventSegs(segs); + for (j = 0, len = segs.length; j < len; j++) { + unplacedSeg = segs[j]; + unplacedSeg.above = []; + level = 0; + while (level < segLevels.length) { + isLevelCollision = false; + ref = segLevels[level]; + for (k = 0, len1 = ref.length; k < len1; k++) { + placedSeg = ref[k]; + if (timeRowSegsCollide(unplacedSeg, placedSeg)) { + unplacedSeg.above.push(placedSeg); + isLevelCollision = true; + } + } + if (isLevelCollision) { + level += 1; + } else { + break; + } + } + (segLevels[level] || (segLevels[level] = [])).push(unplacedSeg); + level += 1; + while (level < segLevels.length) { + ref1 = segLevels[level]; + for (l = 0, len2 = ref1.length; l < len2; l++) { + belowSeg = ref1[l]; + if (timeRowSegsCollide(unplacedSeg, belowSeg)) { + belowSeg.above.push(unplacedSeg); + } + } + level += 1; + } + } + return segLevels; + }; + + TimelineGrid.prototype.unrenderFgContainers = function(containers) { + var container, j, len, results; + results = []; + for (j = 0, len = containers.length; j < len; j++) { + container = containers[j]; + container.segContainerEl.empty(); + container.segContainerEl.height(''); + results.push(container.segContainerHeight = null); + } + return results; + }; + + TimelineGrid.prototype.fgSegHtml = function(seg, disableResizing) { + var classes, event, isDraggable, isResizableFromEnd, isResizableFromStart, timeText; + event = seg.event; + isDraggable = this.view.isEventDraggable(event); + isResizableFromStart = seg.isStart && this.view.isEventResizableFromStart(event); + isResizableFromEnd = seg.isEnd && this.view.isEventResizableFromEnd(event); + classes = this.getSegClasses(seg, isDraggable, isResizableFromStart || isResizableFromEnd); + classes.unshift('fc-timeline-event', 'fc-h-event'); + timeText = this.getEventTimeText(event); + return '' + '
' + (timeText ? '' + htmlEscape(timeText) + '' : '') + '' + (event.title ? htmlEscape(event.title) : ' ') + '' + '
' + '
' + (isResizableFromStart ? '
' : '') + (isResizableFromEnd ? '
' : '') + ''; + }; + + TimelineGrid.prototype.updateSegFollowers = function(segs) { + var j, len, seg, sprites, titleEl; + if (this.eventTitleFollower) { + sprites = []; + for (j = 0, len = segs.length; j < len; j++) { + seg = segs[j]; + titleEl = seg.el.find('.fc-title'); + if (titleEl.length) { + sprites.push(new ScrollFollowerSprite(titleEl)); + } + } + return this.eventTitleFollower.setSprites(sprites); + } + }; + + TimelineGrid.prototype.clearSegFollowers = function() { + if (this.eventTitleFollower) { + return this.eventTitleFollower.clearSprites(); + } + }; + + TimelineGrid.prototype.segDragStart = function() { + TimelineGrid.__super__.segDragStart.apply(this, arguments); + if (this.eventTitleFollower) { + return this.eventTitleFollower.forceRelative(); + } + }; + + TimelineGrid.prototype.segDragEnd = function() { + TimelineGrid.__super__.segDragEnd.apply(this, arguments); + if (this.eventTitleFollower) { + return this.eventTitleFollower.clearForce(); + } + }; + + TimelineGrid.prototype.segResizeStart = function() { + TimelineGrid.__super__.segResizeStart.apply(this, arguments); + if (this.eventTitleFollower) { + return this.eventTitleFollower.forceRelative(); + } + }; + + TimelineGrid.prototype.segResizeEnd = function() { + TimelineGrid.__super__.segResizeEnd.apply(this, arguments); + if (this.eventTitleFollower) { + return this.eventTitleFollower.clearForce(); + } + }; + + TimelineGrid.prototype.renderHelper = function(event, sourceSeg) { + var segs; + segs = this.eventToSegs(event); + segs = this.renderFgSegEls(segs); + return this.renderHelperSegsInContainers([[this, segs]], sourceSeg); + }; + + TimelineGrid.prototype.renderHelperSegsInContainers = function(pairs, sourceSeg) { + var containerObj, coords, helperContainerEl, helperNodes, j, k, l, len, len1, len2, len3, m, ref, ref1, ref2, seg, segNodes, segs; + helperNodes = []; + segNodes = []; + for (j = 0, len = pairs.length; j < len; j++) { + ref = pairs[j], containerObj = ref[0], segs = ref[1]; + for (k = 0, len1 = segs.length; k < len1; k++) { + seg = segs[k]; + coords = this.rangeToCoords(seg); + seg.el.css({ + left: (seg.left = coords.left), + right: -(seg.right = coords.right) + }); + if (sourceSeg && sourceSeg.resourceId === ((ref1 = containerObj.resource) != null ? ref1.id : void 0)) { + seg.el.css('top', sourceSeg.el.css('top')); + } else { + seg.el.css('top', 0); + } + } + } + for (l = 0, len2 = pairs.length; l < len2; l++) { + ref2 = pairs[l], containerObj = ref2[0], segs = ref2[1]; + helperContainerEl = $('
').appendTo(containerObj.innerEl); + helperNodes.push(helperContainerEl[0]); + for (m = 0, len3 = segs.length; m < len3; m++) { + seg = segs[m]; + helperContainerEl.append(seg.el); + segNodes.push(seg.el[0]); + } + } + if (this.helperEls) { + this.helperEls = this.helperEls.add($(helperNodes)); + } else { + this.helperEls = $(helperNodes); + } + return $(segNodes); + }; + + TimelineGrid.prototype.unrenderHelper = function() { + if (this.helperEls) { + this.helperEls.remove(); + return this.helperEls = null; + } + }; + + TimelineGrid.prototype.renderEventResize = function(resizeLocation, seg) { + this.renderHighlight(this.eventToSpan(resizeLocation)); + return this.renderEventLocationHelper(resizeLocation, seg); + }; + + TimelineGrid.prototype.unrenderEventResize = function() { + this.unrenderHighlight(); + return this.unrenderHelper(); + }; + + TimelineGrid.prototype.renderFill = function(type, segs, className) { + segs = this.renderFillSegEls(type, segs); + this.renderFillInContainers(type, [[this, segs]], className); + return segs; + }; + + TimelineGrid.prototype.renderFillInContainers = function(type, pairs, className) { + var containerObj, j, len, ref, results, segs; + results = []; + for (j = 0, len = pairs.length; j < len; j++) { + ref = pairs[j], containerObj = ref[0], segs = ref[1]; + results.push(this.renderFillInContainer(type, containerObj, segs, className)); + } + return results; + }; + + TimelineGrid.prototype.renderFillInContainer = function(type, containerObj, segs, className) { + var containerEl, coords, j, len, seg; + if (segs.length) { + className || (className = type.toLowerCase()); + containerEl = $('
').appendTo(containerObj.bgSegContainerEl); + for (j = 0, len = segs.length; j < len; j++) { + seg = segs[j]; + coords = this.rangeToCoords(seg); + seg.el.css({ + left: (seg.left = coords.left), + right: -(seg.right = coords.right) + }); + seg.el.appendTo(containerEl); + } + if (this.elsByFill[type]) { + return this.elsByFill[type] = this.elsByFill[type].add(containerEl); + } else { + return this.elsByFill[type] = containerEl; + } + } + }; + + TimelineGrid.prototype.renderDrag = function(dropLocation, seg) { + if (seg) { + return this.renderEventLocationHelper(dropLocation, seg); + } else { + this.renderHighlight(this.eventToSpan(dropLocation)); + return null; + } + }; + + TimelineGrid.prototype.unrenderDrag = function() { + this.unrenderHelper(); + return this.unrenderHighlight(); + }; + + return TimelineGrid; + +})(Grid); + +computeOffsetForSegs = function(segs) { + var j, len, max, seg; + max = 0; + for (j = 0, len = segs.length; j < len; j++) { + seg = segs[j]; + max = Math.max(max, computeOffsetForSeg(seg)); + } + return max; +}; + +computeOffsetForSeg = function(seg) { + if (seg.top == null) { + seg.top = computeOffsetForSegs(seg.above); + } + return seg.top + seg.height; +}; + +timeRowSegsCollide = function(seg0, seg1) { + return seg0.left < seg1.right && seg0.right > seg1.left; +}; + +MIN_AUTO_LABELS = 18; + +MAX_AUTO_SLOTS_PER_LABEL = 6; + +MAX_AUTO_CELLS = 200; + +MAX_CELLS = 1000; + +DEFAULT_GRID_DURATION = { + months: 1 +}; + +STOCK_SUB_DURATIONS = [ + { + years: 1 + }, { + months: 1 + }, { + days: 1 + }, { + hours: 1 + }, { + minutes: 30 + }, { + minutes: 15 + }, { + minutes: 10 + }, { + minutes: 5 + }, { + minutes: 1 + }, { + seconds: 30 + }, { + seconds: 15 + }, { + seconds: 10 + }, { + seconds: 5 + }, { + seconds: 1 + }, { + milliseconds: 500 + }, { + milliseconds: 100 + }, { + milliseconds: 10 + }, { + milliseconds: 1 + } +]; + +TimelineGrid.prototype.initScaleProps = function() { + var input, slotUnit, type; + this.labelInterval = this.queryDurationOption('slotLabelInterval'); + this.slotDuration = this.queryDurationOption('slotDuration'); + this.ensureGridDuration(); + this.validateLabelAndSlot(); + this.ensureLabelInterval(); + this.ensureSlotDuration(); + input = this.opt('slotLabelFormat'); + type = $.type(input); + this.headerFormats = type === 'array' ? input : type === 'string' ? [input] : this.computeHeaderFormats(); + this.isTimeScale = durationHasTime(this.slotDuration); + this.largeUnit = !this.isTimeScale ? (slotUnit = computeIntervalUnit(this.slotDuration), /year|month|week/.test(slotUnit) ? slotUnit : void 0) : void 0; + return this.emphasizeWeeks = this.slotDuration.as('days') === 1 && this.duration.as('weeks') >= 2 && !this.opt('businessHours'); + + /* + console.log('view duration =', @duration.humanize()) + console.log('label interval =', @labelInterval.humanize()) + console.log('slot duration =', @slotDuration.humanize()) + console.log('header formats =', @headerFormats) + console.log('isTimeScale', @isTimeScale) + console.log('largeUnit', @largeUnit) + */ +}; + +TimelineGrid.prototype.queryDurationOption = function(name) { + var dur, input; + input = this.opt(name); + if (input != null) { + dur = moment.duration(input); + if (+dur) { + return dur; + } + } +}; + +TimelineGrid.prototype.validateLabelAndSlot = function() { + var labelCnt, slotCnt, slotsPerLabel; + if (this.labelInterval) { + labelCnt = divideDurationByDuration(this.duration, this.labelInterval); + if (labelCnt > MAX_CELLS) { + FC.warn('slotLabelInterval results in too many cells'); + this.labelInterval = null; + } + } + if (this.slotDuration) { + slotCnt = divideDurationByDuration(this.duration, this.slotDuration); + if (slotCnt > MAX_CELLS) { + FC.warn('slotDuration results in too many cells'); + this.slotDuration = null; + } + } + if (this.labelInterval && this.slotDuration) { + slotsPerLabel = divideDurationByDuration(this.labelInterval, this.slotDuration); + if (!isInt(slotsPerLabel) || slotsPerLabel < 1) { + FC.warn('slotLabelInterval must be a multiple of slotDuration'); + return this.slotDuration = null; + } + } +}; + +TimelineGrid.prototype.ensureGridDuration = function() { + var gridDuration, input, j, labelCnt, labelInterval; + gridDuration = this.duration; + if (!gridDuration) { + gridDuration = this.view.intervalDuration; + if (!gridDuration) { + if (!this.labelInterval && !this.slotDuration) { + gridDuration = moment.duration(DEFAULT_GRID_DURATION); + } else { + labelInterval = this.ensureLabelInterval(); + for (j = STOCK_SUB_DURATIONS.length - 1; j >= 0; j += -1) { + input = STOCK_SUB_DURATIONS[j]; + gridDuration = moment.duration(input); + labelCnt = divideDurationByDuration(gridDuration, labelInterval); + if (labelCnt >= MIN_AUTO_LABELS) { + break; + } + } + } + } + this.duration = gridDuration; + } + return gridDuration; +}; + +TimelineGrid.prototype.ensureLabelInterval = function() { + var input, j, k, labelCnt, labelInterval, len, len1, slotsPerLabel, tryLabelInterval; + labelInterval = this.labelInterval; + if (!labelInterval) { + if (!this.duration && !this.slotDuration) { + this.ensureGridDuration(); + } + if (this.slotDuration) { + for (j = 0, len = STOCK_SUB_DURATIONS.length; j < len; j++) { + input = STOCK_SUB_DURATIONS[j]; + tryLabelInterval = moment.duration(input); + slotsPerLabel = divideDurationByDuration(tryLabelInterval, this.slotDuration); + if (isInt(slotsPerLabel) && slotsPerLabel <= MAX_AUTO_SLOTS_PER_LABEL) { + labelInterval = tryLabelInterval; + break; + } + } + if (!labelInterval) { + labelInterval = this.slotDuration; + } + } else { + for (k = 0, len1 = STOCK_SUB_DURATIONS.length; k < len1; k++) { + input = STOCK_SUB_DURATIONS[k]; + labelInterval = moment.duration(input); + labelCnt = divideDurationByDuration(this.duration, labelInterval); + if (labelCnt >= MIN_AUTO_LABELS) { + break; + } + } + } + this.labelInterval = labelInterval; + } + return labelInterval; +}; + +TimelineGrid.prototype.ensureSlotDuration = function() { + var input, j, labelInterval, len, slotCnt, slotDuration, slotsPerLabel, trySlotDuration; + slotDuration = this.slotDuration; + if (!slotDuration) { + labelInterval = this.ensureLabelInterval(); + for (j = 0, len = STOCK_SUB_DURATIONS.length; j < len; j++) { + input = STOCK_SUB_DURATIONS[j]; + trySlotDuration = moment.duration(input); + slotsPerLabel = divideDurationByDuration(labelInterval, trySlotDuration); + if (isInt(slotsPerLabel) && slotsPerLabel > 1 && slotsPerLabel <= MAX_AUTO_SLOTS_PER_LABEL) { + slotDuration = trySlotDuration; + break; + } + } + if (slotDuration && this.duration) { + slotCnt = divideDurationByDuration(this.duration, slotDuration); + if (slotCnt > MAX_AUTO_CELLS) { + slotDuration = null; + } + } + if (!slotDuration) { + slotDuration = labelInterval; + } + this.slotDuration = slotDuration; + } + return slotDuration; +}; + +TimelineGrid.prototype.computeHeaderFormats = function() { + var format0, format1, format2, gridDuration, labelInterval, unit, view, weekNumbersVisible; + view = this.view; + gridDuration = this.duration; + labelInterval = this.labelInterval; + unit = computeIntervalUnit(labelInterval); + weekNumbersVisible = this.opt('weekNumbers'); + format0 = format1 = format2 = null; + if (unit === 'week' && !weekNumbersVisible) { + unit = 'day'; + } + switch (unit) { + case 'year': + format0 = 'YYYY'; + break; + case 'month': + if (gridDuration.asYears() > 1) { + format0 = 'YYYY'; + } + format1 = 'MMM'; + break; + case 'week': + if (gridDuration.asYears() > 1) { + format0 = 'YYYY'; + } + format1 = this.opt('shortWeekFormat'); + break; + case 'day': + if (gridDuration.asYears() > 1) { + format0 = this.opt('monthYearFormat'); + } else if (gridDuration.asMonths() > 1) { + format0 = 'MMMM'; + } + if (weekNumbersVisible) { + format1 = this.opt('weekFormat'); + } + format2 = 'dd D'; + break; + case 'hour': + if (weekNumbersVisible) { + format0 = this.opt('weekFormat'); + } + if (gridDuration.asDays() > 1) { + format1 = this.opt('dayOfMonthFormat'); + } + format2 = this.opt('smallTimeFormat'); + break; + case 'minute': + if (labelInterval.asMinutes() / 60 >= MAX_AUTO_SLOTS_PER_LABEL) { + format0 = this.opt('hourFormat'); + format1 = '[:]mm'; + } else { + format0 = this.opt('mediumTimeFormat'); + } + break; + case 'second': + if (labelInterval.asSeconds() / 60 >= MAX_AUTO_SLOTS_PER_LABEL) { + format0 = 'LT'; + format1 = '[:]ss'; + } else { + format0 = 'LTS'; + } + break; + case 'millisecond': + format0 = 'LTS'; + format1 = '[.]SSS'; + } + return [].concat(format0 || [], format1 || [], format2 || []); +}; + +FC.views.timeline = { + "class": TimelineView, + defaults: { + eventResizableFromStart: true + } +}; + +FC.views.timelineDay = { + type: 'timeline', + duration: { + days: 1 + } +}; + +FC.views.timelineWeek = { + type: 'timeline', + duration: { + weeks: 1 + } +}; + +FC.views.timelineMonth = { + type: 'timeline', + duration: { + months: 1 + } +}; + +FC.views.timelineYear = { + type: 'timeline', + duration: { + years: 1 + } +}; + +ResourceTimelineView = (function(superClass) { + extend(ResourceTimelineView, superClass); + + function ResourceTimelineView() { + return ResourceTimelineView.__super__.constructor.apply(this, arguments); + } + + ResourceTimelineView.mixin(ResourceViewMixin); + + ResourceTimelineView.prototype.resourceGrid = null; + + ResourceTimelineView.prototype.tbodyHash = null; + + ResourceTimelineView.prototype.joiner = null; + + ResourceTimelineView.prototype.dividerEls = null; + + ResourceTimelineView.prototype.superHeaderText = null; + + ResourceTimelineView.prototype.isVGrouping = null; + + ResourceTimelineView.prototype.isHGrouping = null; + + ResourceTimelineView.prototype.groupSpecs = null; + + ResourceTimelineView.prototype.colSpecs = null; + + ResourceTimelineView.prototype.orderSpecs = null; + + ResourceTimelineView.prototype.rowHierarchy = null; + + ResourceTimelineView.prototype.resourceRowHash = null; + + ResourceTimelineView.prototype.nestingCnt = 0; + + ResourceTimelineView.prototype.isNesting = null; + + ResourceTimelineView.prototype.dividerWidth = null; + + ResourceTimelineView.prototype.initialize = function() { + ResourceTimelineView.__super__.initialize.apply(this, arguments); + this.processResourceOptions(); + this.resourceGrid = new Spreadsheet(this); + this.rowHierarchy = new RowParent(this); + return this.resourceRowHash = {}; + }; + + ResourceTimelineView.prototype.instantiateGrid = function() { + return new ResourceTimelineGrid(this); + }; + + ResourceTimelineView.prototype.processResourceOptions = function() { + var allColSpecs, allOrderSpecs, colSpec, defaultLabelText, groupColSpecs, groupSpec, groupSpecs, hGroupField, isGroup, isHGrouping, isVGrouping, j, k, l, labelText, len, len1, len2, orderSpec, plainColSpecs, plainOrderSpecs, superHeaderText; + allColSpecs = this.opt('resourceColumns') || []; + labelText = this.opt('resourceLabelText'); + defaultLabelText = 'Resources'; + superHeaderText = null; + if (!allColSpecs.length) { + allColSpecs.push({ + labelText: labelText || defaultLabelText, + text: this.getResourceTextFunc() + }); + } else { + superHeaderText = labelText; + } + plainColSpecs = []; + groupColSpecs = []; + groupSpecs = []; + isVGrouping = false; + isHGrouping = false; + for (j = 0, len = allColSpecs.length; j < len; j++) { + colSpec = allColSpecs[j]; + if (colSpec.group) { + groupColSpecs.push(colSpec); + } else { + plainColSpecs.push(colSpec); + } + } + plainColSpecs[0].isMain = true; + if (groupColSpecs.length) { + groupSpecs = groupColSpecs; + isVGrouping = true; + } else { + hGroupField = this.opt('resourceGroupField'); + if (hGroupField) { + isHGrouping = true; + groupSpecs.push({ + field: hGroupField, + text: this.opt('resourceGroupText'), + render: this.opt('resourceGroupRender') + }); + } + } + allOrderSpecs = parseFieldSpecs(this.opt('resourceOrder')); + plainOrderSpecs = []; + for (k = 0, len1 = allOrderSpecs.length; k < len1; k++) { + orderSpec = allOrderSpecs[k]; + isGroup = false; + for (l = 0, len2 = groupSpecs.length; l < len2; l++) { + groupSpec = groupSpecs[l]; + if (groupSpec.field === orderSpec.field) { + groupSpec.order = orderSpec.order; + isGroup = true; + break; + } + } + if (!isGroup) { + plainOrderSpecs.push(orderSpec); + } + } + this.superHeaderText = superHeaderText; + this.isVGrouping = isVGrouping; + this.isHGrouping = isHGrouping; + this.groupSpecs = groupSpecs; + this.colSpecs = groupColSpecs.concat(plainColSpecs); + return this.orderSpecs = plainOrderSpecs; + }; + + ResourceTimelineView.prototype.renderSkeleton = function() { + ResourceTimelineView.__super__.renderSkeleton.apply(this, arguments); + this.renderResourceGridSkeleton(); + this.tbodyHash = { + spreadsheet: this.resourceGrid.tbodyEl, + event: this.timeGrid.tbodyEl + }; + this.joiner = new ScrollJoiner('vertical', [this.resourceGrid.bodyScroller, this.timeGrid.bodyScroller]); + return this.initDividerMoving(); + }; + + ResourceTimelineView.prototype.renderSkeletonHtml = function() { + return '
'; + }; + + ResourceTimelineView.prototype.renderResourceGridSkeleton = function() { + this.resourceGrid.el = this.el.find('tbody .fc-resource-area'); + this.resourceGrid.headEl = this.el.find('thead .fc-resource-area'); + return this.resourceGrid.renderSkeleton(); + }; + + ResourceTimelineView.prototype.initDividerMoving = function() { + var ref; + this.dividerEls = this.el.find('.fc-divider'); + this.dividerWidth = (ref = this.opt('resourceAreaWidth')) != null ? ref : this.resourceGrid.tableWidth; + if (this.dividerWidth != null) { + this.positionDivider(this.dividerWidth); + } + return this.dividerEls.on('mousedown', (function(_this) { + return function(ev) { + return _this.dividerMousedown(ev); + }; + })(this)); + }; + + ResourceTimelineView.prototype.dividerMousedown = function(ev) { + var dragListener, isRTL, maxWidth, minWidth, origWidth; + isRTL = this.opt('isRTL'); + minWidth = 30; + maxWidth = this.el.width() - 30; + origWidth = this.getNaturalDividerWidth(); + dragListener = new DragListener({ + dragStart: (function(_this) { + return function() { + return _this.dividerEls.addClass('fc-active'); + }; + })(this), + drag: (function(_this) { + return function(dx, dy) { + var width; + if (isRTL) { + width = origWidth - dx; + } else { + width = origWidth + dx; + } + width = Math.max(width, minWidth); + width = Math.min(width, maxWidth); + _this.dividerWidth = width; + _this.positionDivider(width); + return _this.updateWidth(); + }; + })(this), + dragEnd: (function(_this) { + return function() { + return _this.dividerEls.removeClass('fc-active'); + }; + })(this) + }); + return dragListener.startInteraction(ev); + }; + + ResourceTimelineView.prototype.getNaturalDividerWidth = function() { + return this.el.find('.fc-resource-area').width(); + }; + + ResourceTimelineView.prototype.positionDivider = function(w) { + return this.el.find('.fc-resource-area').width(w); + }; + + ResourceTimelineView.prototype.renderEvents = function(events) { + this.timeGrid.renderEvents(events); + this.syncRowHeights(); + return this.updateWidth(); + }; + + ResourceTimelineView.prototype.unrenderEvents = function() { + this.timeGrid.unrenderEvents(); + this.syncRowHeights(); + return this.updateWidth(); + }; + + ResourceTimelineView.prototype.updateWidth = function() { + ResourceTimelineView.__super__.updateWidth.apply(this, arguments); + this.resourceGrid.updateWidth(); + this.joiner.update(); + if (this.cellFollower) { + return this.cellFollower.update(); + } + }; + + ResourceTimelineView.prototype.updateHeight = function(isResize) { + ResourceTimelineView.__super__.updateHeight.apply(this, arguments); + if (isResize) { + return this.syncRowHeights(); + } + }; + + ResourceTimelineView.prototype.setHeight = function(totalHeight, isAuto) { + var bodyHeight, headHeight; + headHeight = this.syncHeadHeights(); + if (isAuto) { + bodyHeight = 'auto'; + } else { + bodyHeight = totalHeight - headHeight - this.queryMiscHeight(); + } + this.timeGrid.bodyScroller.setHeight(bodyHeight); + return this.resourceGrid.bodyScroller.setHeight(bodyHeight); + }; + + ResourceTimelineView.prototype.queryMiscHeight = function() { + return this.el.outerHeight() - Math.max(this.resourceGrid.headScroller.el.outerHeight(), this.timeGrid.headScroller.el.outerHeight()) - Math.max(this.resourceGrid.bodyScroller.el.outerHeight(), this.timeGrid.bodyScroller.el.outerHeight()); + }; + + ResourceTimelineView.prototype.syncHeadHeights = function() { + var headHeight; + this.resourceGrid.headHeight('auto'); + this.timeGrid.headHeight('auto'); + headHeight = Math.max(this.resourceGrid.headHeight(), this.timeGrid.headHeight()); + this.resourceGrid.headHeight(headHeight); + this.timeGrid.headHeight(headHeight); + return headHeight; + }; + + ResourceTimelineView.prototype.scrollToResource = function(resource) { + return this.timeGrid.scrollToResource(resource); + }; + + ResourceTimelineView.prototype.setResources = function(resources) { + var j, len, resource; + this.batchRows(); + for (j = 0, len = resources.length; j < len; j++) { + resource = resources[j]; + this.insertResource(resource); + } + this.rowHierarchy.show(); + this.unbatchRows(); + return this.reinitializeCellFollowers(); + }; + + ResourceTimelineView.prototype.unsetResources = function() { + this.clearEvents(); + this.batchRows(); + this.rowHierarchy.removeChildren(); + this.unbatchRows(); + return this.reinitializeCellFollowers(); + }; + + + /* + TODO: the scenario where there were previously unassociated events that are now + attached to this resource. should render those events immediately. + + Responsible for rendering the new resource + */ + + ResourceTimelineView.prototype.addResource = function(resource) { + this.insertResource(resource); + return this.reinitializeCellFollowers(); + }; + + ResourceTimelineView.prototype.removeResource = function(resource) { + var row; + row = this.getResourceRow(resource.id); + if (row) { + this.batchRows(); + row.remove(); + this.unbatchRows(); + return this.reinitializeCellFollowers(); + } + }; + + ResourceTimelineView.prototype.cellFollower = null; + + ResourceTimelineView.prototype.reinitializeCellFollowers = function() { + var cellContent, j, len, nodes, ref, row; + if (this.cellFollower) { + this.cellFollower.clearSprites(); + } + this.cellFollower = new ScrollFollower(this.resourceGrid.bodyScroller, this.calendar.isTouch); + this.cellFollower.isHFollowing = false; + this.cellFollower.isVFollowing = true; + nodes = []; + ref = this.rowHierarchy.getNodes(); + for (j = 0, len = ref.length; j < len; j++) { + row = ref[j]; + if (row instanceof VRowGroup) { + if (row.groupTd) { + cellContent = row.groupTd.find('.fc-cell-content'); + if (cellContent.length) { + nodes.push(cellContent[0]); + } + } + } + } + return this.cellFollower.setSprites($(nodes)); + }; + + ResourceTimelineView.prototype.insertResource = function(resource, parentResourceRow) { + var childResource, j, len, parentId, ref, results, row; + row = new ResourceRow(this, resource); + if (parentResourceRow == null) { + parentId = resource.parentId; + if (parentId) { + parentResourceRow = this.getResourceRow(parentId); + } + } + if (parentResourceRow) { + this.insertRowAsChild(row, parentResourceRow); + } else { + this.insertRow(row); + } + ref = resource.children; + results = []; + for (j = 0, len = ref.length; j < len; j++) { + childResource = ref[j]; + results.push(this.insertResource(childResource, row)); + } + return results; + }; + + ResourceTimelineView.prototype.insertRow = function(row, parent, groupSpecs) { + var group; + if (parent == null) { + parent = this.rowHierarchy; + } + if (groupSpecs == null) { + groupSpecs = this.groupSpecs; + } + if (groupSpecs.length) { + group = this.ensureResourceGroup(row, parent, groupSpecs[0]); + if (group instanceof HRowGroup) { + return this.insertRowAsChild(row, group); + } else { + return this.insertRow(row, group, groupSpecs.slice(1)); + } + } else { + return this.insertRowAsChild(row, parent); + } + }; + + ResourceTimelineView.prototype.insertRowAsChild = function(row, parent) { + return parent.addChild(row, this.computeChildRowPosition(row, parent)); + }; + + ResourceTimelineView.prototype.computeChildRowPosition = function(child, parent) { + var cmp, i, j, len, ref, sibling; + if (this.orderSpecs.length) { + ref = parent.children; + for (i = j = 0, len = ref.length; j < len; i = ++j) { + sibling = ref[i]; + cmp = this.compareResources(sibling.resource || {}, child.resource || {}); + if (cmp > 0) { + return i; + } + } + } + return null; + }; + + ResourceTimelineView.prototype.compareResources = function(a, b) { + return compareByFieldSpecs(a, b, this.orderSpecs); + }; + + ResourceTimelineView.prototype.ensureResourceGroup = function(row, parent, spec) { + var cmp, group, groupValue, i, j, k, len, len1, ref, ref1, testGroup; + groupValue = (row.resource || {})[spec.field]; + group = null; + if (spec.order) { + ref = parent.children; + for (i = j = 0, len = ref.length; j < len; i = ++j) { + testGroup = ref[i]; + cmp = flexibleCompare(testGroup.groupValue, groupValue) * spec.order; + if (cmp === 0) { + group = testGroup; + break; + } else if (cmp > 0) { + break; + } + } + } else { + ref1 = parent.children; + for (i = k = 0, len1 = ref1.length; k < len1; i = ++k) { + testGroup = ref1[i]; + if (testGroup.groupValue === groupValue) { + group = testGroup; + break; + } + } + } + if (!group) { + if (this.isVGrouping) { + group = new VRowGroup(this, spec, groupValue); + } else { + group = new HRowGroup(this, spec, groupValue); + } + parent.addChild(group, i); + } + return group; + }; + + ResourceTimelineView.prototype.pairSegsWithRows = function(segs) { + var j, len, pair, pairs, pairsById, resourceId, rowObj, seg; + pairs = []; + pairsById = {}; + for (j = 0, len = segs.length; j < len; j++) { + seg = segs[j]; + resourceId = seg.resourceId; + if (resourceId) { + rowObj = this.getResourceRow(resourceId); + if (rowObj) { + pair = pairsById[resourceId]; + if (!pair) { + pair = [rowObj, []]; + pairs.push(pair); + pairsById[resourceId] = pair; + } + pair[1].push(seg); + } + } + } + return pairs; + }; + + ResourceTimelineView.prototype.rowAdded = function(row) { + var isNesting, wasNesting; + if (row instanceof ResourceRow) { + this.resourceRowHash[row.resource.id] = row; + } + wasNesting = this.isNesting; + isNesting = Boolean(this.nestingCnt += row.depth ? 1 : 0); + if (wasNesting !== isNesting) { + this.el.toggleClass('fc-nested', isNesting); + this.el.toggleClass('fc-flat', !isNesting); + } + return this.isNesting = isNesting; + }; + + ResourceTimelineView.prototype.rowRemoved = function(row) { + var isNesting, wasNesting; + if (row instanceof ResourceRow) { + delete this.resourceRowHash[row.resource.id]; + } + wasNesting = this.isNesting; + isNesting = Boolean(this.nestingCnt -= row.depth ? 1 : 0); + if (wasNesting !== isNesting) { + this.el.toggleClass('fc-nested', isNesting); + this.el.toggleClass('fc-flat', !isNesting); + } + return this.isNesting = isNesting; + }; + + ResourceTimelineView.prototype.batchRowDepth = 0; + + ResourceTimelineView.prototype.shownRowBatch = null; + + ResourceTimelineView.prototype.hiddenRowBatch = null; + + ResourceTimelineView.prototype.batchRows = function() { + if (!(this.batchRowDepth++)) { + this.shownRowBatch = []; + return this.hiddenRowBatch = []; + } + }; + + ResourceTimelineView.prototype.unbatchRows = function() { + if (!(--this.batchRowDepth)) { + if (this.hiddenRowBatch.length) { + this.rowsHidden(this.hiddenRowBatch); + } + if (this.shownRowBatch.length) { + this.rowsShown(this.shownRowBatch); + } + this.hiddenRowBatch = null; + return this.shownRowBatch = null; + } + }; + + ResourceTimelineView.prototype.rowShown = function(row) { + if (this.shownRowBatch) { + return this.shownRowBatch.push(row); + } else { + return this.rowsShown([row]); + } + }; + + ResourceTimelineView.prototype.rowHidden = function(row) { + if (this.hiddenRowBatch) { + return this.hiddenRowBatch.push(row); + } else { + return this.rowsHidden([row]); + } + }; + + ResourceTimelineView.prototype.rowsShown = function(rows) { + this.syncRowHeights(rows); + return this.updateWidth(); + }; + + ResourceTimelineView.prototype.rowsHidden = function(rows) { + return this.updateWidth(); + }; + + ResourceTimelineView.prototype.syncRowHeights = function(visibleRows, safe) { + var h, h1, h2, i, innerHeights, j, k, len, len1, row; + if (safe == null) { + safe = false; + } + if (visibleRows == null) { + visibleRows = this.getVisibleRows(); + } + for (j = 0, len = visibleRows.length; j < len; j++) { + row = visibleRows[j]; + row.setTrInnerHeight(''); + } + innerHeights = (function() { + var k, len1, results; + results = []; + for (k = 0, len1 = visibleRows.length; k < len1; k++) { + row = visibleRows[k]; + h = row.getMaxTrInnerHeight(); + if (safe) { + h += h % 2; + } + results.push(h); + } + return results; + })(); + for (i = k = 0, len1 = visibleRows.length; k < len1; i = ++k) { + row = visibleRows[i]; + row.setTrInnerHeight(innerHeights[i]); + } + if (!safe) { + h1 = this.resourceGrid.tbodyEl.height(); + h2 = this.timeGrid.tbodyEl.height(); + if (Math.abs(h1 - h2) > 1) { + return this.syncRowHeights(visibleRows, true); + } + } + }; + + ResourceTimelineView.prototype.getVisibleRows = function() { + var j, len, ref, results, row; + ref = this.rowHierarchy.getRows(); + results = []; + for (j = 0, len = ref.length; j < len; j++) { + row = ref[j]; + if (row.isShown) { + results.push(row); + } + } + return results; + }; + + ResourceTimelineView.prototype.getEventRows = function() { + var j, len, ref, results, row; + ref = this.rowHierarchy.getRows(); + results = []; + for (j = 0, len = ref.length; j < len; j++) { + row = ref[j]; + if (row instanceof EventRow) { + results.push(row); + } + } + return results; + }; + + ResourceTimelineView.prototype.getResourceRow = function(resourceId) { + return this.resourceRowHash[resourceId]; + }; + + ResourceTimelineView.prototype.setScroll = function(state) { + ResourceTimelineView.__super__.setScroll.apply(this, arguments); + return this.resourceGrid.bodyScroller.setScrollTop(state.top); + }; + + return ResourceTimelineView; + +})(TimelineView); + +ResourceTimelineGrid = (function(superClass) { + extend(ResourceTimelineGrid, superClass); + + function ResourceTimelineGrid() { + return ResourceTimelineGrid.__super__.constructor.apply(this, arguments); + } + + ResourceTimelineGrid.mixin(ResourceGridMixin); + + ResourceTimelineGrid.prototype.eventRows = null; + + ResourceTimelineGrid.prototype.shownEventRows = null; + + ResourceTimelineGrid.prototype.tbodyEl = null; + + ResourceTimelineGrid.prototype.rowCoordCache = null; + + ResourceTimelineGrid.prototype.spanToSegs = function(span) { + var calendar, j, len, resourceId, seg, segs; + segs = ResourceTimelineGrid.__super__.spanToSegs.apply(this, arguments); + calendar = this.view.calendar; + resourceId = span.resourceId; + if (resourceId) { + for (j = 0, len = segs.length; j < len; j++) { + seg = segs[j]; + seg.resource = calendar.getResourceById(resourceId); + seg.resourceId = resourceId; + } + } + return segs; + }; + + ResourceTimelineGrid.prototype.prepareHits = function() { + var row, trArray; + ResourceTimelineGrid.__super__.prepareHits.apply(this, arguments); + this.eventRows = this.view.getEventRows(); + this.shownEventRows = (function() { + var j, len, ref, results; + ref = this.eventRows; + results = []; + for (j = 0, len = ref.length; j < len; j++) { + row = ref[j]; + if (row.isShown) { + results.push(row); + } + } + return results; + }).call(this); + trArray = (function() { + var j, len, ref, results; + ref = this.shownEventRows; + results = []; + for (j = 0, len = ref.length; j < len; j++) { + row = ref[j]; + results.push(row.getTr('event')[0]); + } + return results; + }).call(this); + this.rowCoordCache = new CoordCache({ + els: trArray, + isVertical: true + }); + return this.rowCoordCache.build(); + }; + + ResourceTimelineGrid.prototype.releaseHits = function() { + ResourceTimelineGrid.__super__.releaseHits.apply(this, arguments); + this.eventRows = null; + this.shownEventRows = null; + return this.rowCoordCache.clear(); + }; + + ResourceTimelineGrid.prototype.queryHit = function(leftOffset, topOffset) { + var rowIndex, simpleHit; + simpleHit = ResourceTimelineGrid.__super__.queryHit.apply(this, arguments); + if (simpleHit) { + rowIndex = this.rowCoordCache.getVerticalIndex(topOffset); + if (rowIndex != null) { + return { + resourceId: this.shownEventRows[rowIndex].resource.id, + snap: simpleHit.snap, + component: this, + left: simpleHit.left, + right: simpleHit.right, + top: this.rowCoordCache.getTopOffset(rowIndex), + bottom: this.rowCoordCache.getBottomOffset(rowIndex) + }; + } + } + }; + + ResourceTimelineGrid.prototype.getHitSpan = function(hit) { + var span; + span = this.getSnapRange(hit.snap); + span.resourceId = hit.resourceId; + return span; + }; + + ResourceTimelineGrid.prototype.getHitEl = function(hit) { + return this.getSnapEl(hit.snap); + }; + + ResourceTimelineGrid.prototype.renderSkeleton = function() { + var rowContainerEl; + ResourceTimelineGrid.__super__.renderSkeleton.apply(this, arguments); + this.segContainerEl.remove(); + this.segContainerEl = null; + rowContainerEl = $('
').appendTo(this.bodyScroller.canvas.contentEl); + return this.tbodyEl = rowContainerEl.find('tbody'); + }; + + ResourceTimelineGrid.prototype.renderFgSegs = function(segs) { + var containerObj, containerSegs, j, len, pair, pairs, visiblePairs; + segs = this.renderFgSegEls(segs); + pairs = this.view.pairSegsWithRows(segs); + visiblePairs = []; + for (j = 0, len = pairs.length; j < len; j++) { + pair = pairs[j]; + containerObj = pair[0], containerSegs = pair[1]; + containerObj.fgSegs = containerSegs; + if (containerObj.isShown) { + containerObj.isSegsRendered = true; + visiblePairs.push(pair); + } + } + this.renderFgSegsInContainers(visiblePairs); + this.updateSegFollowers(segs); + return segs; + }; + + ResourceTimelineGrid.prototype.unrenderFgSegs = function() { + var eventRow, eventRows, j, len; + this.clearSegFollowers(); + eventRows = this.view.getEventRows(); + for (j = 0, len = eventRows.length; j < len; j++) { + eventRow = eventRows[j]; + eventRow.fgSegs = null; + eventRow.isSegsRendered = false; + } + return this.unrenderFgContainers(eventRows); + }; + + ResourceTimelineGrid.prototype.renderFill = function(type, segs, className) { + var j, k, len, len1, nonResourceSegs, pair, pairs, resourceSegs, rowObj, rowSegs, seg, visiblePairs; + segs = this.renderFillSegEls(type, segs); + resourceSegs = []; + nonResourceSegs = []; + for (j = 0, len = segs.length; j < len; j++) { + seg = segs[j]; + if (seg.resourceId) { + resourceSegs.push(seg); + } else { + nonResourceSegs.push(seg); + } + } + pairs = this.view.pairSegsWithRows(resourceSegs); + visiblePairs = []; + for (k = 0, len1 = pairs.length; k < len1; k++) { + pair = pairs[k]; + rowObj = pair[0], rowSegs = pair[1]; + if (type === 'bgEvent') { + rowObj.bgSegs = rowSegs; + } + if (rowObj.isShown) { + visiblePairs.push(pair); + } + } + if (nonResourceSegs.length) { + visiblePairs.unshift([this, nonResourceSegs]); + } + this.renderFillInContainers(type, visiblePairs, className); + return segs; + }; + + ResourceTimelineGrid.prototype.renderHelper = function(event, sourceSeg) { + var pairs, segs; + segs = this.eventToSegs(event); + segs = this.renderFgSegEls(segs); + pairs = this.view.pairSegsWithRows(segs); + return this.renderHelperSegsInContainers(pairs, sourceSeg); + }; + + ResourceTimelineGrid.prototype.computeInitialScroll = function(prevState) { + var state; + state = ResourceTimelineGrid.__super__.computeInitialScroll.apply(this, arguments); + if (prevState) { + state.resourceId = prevState.resourceId; + state.bottom = prevState.bottom; + } + return state; + }; + + ResourceTimelineGrid.prototype.queryScroll = function() { + var el, elBottom, j, len, ref, rowObj, scrollerTop, state; + state = ResourceTimelineGrid.__super__.queryScroll.apply(this, arguments); + scrollerTop = this.bodyScroller.scrollEl.offset().top; + ref = this.view.getVisibleRows(); + for (j = 0, len = ref.length; j < len; j++) { + rowObj = ref[j]; + if (rowObj.resource) { + el = rowObj.getTr('event'); + elBottom = el.offset().top + el.outerHeight(); + if (elBottom > scrollerTop) { + state.resourceId = rowObj.resource.id; + state.bottom = elBottom - scrollerTop; + break; + } + } + } + return state; + }; + + ResourceTimelineGrid.prototype.setScroll = function(state) { + var el, elBottom, innerTop, row; + if (state.resourceId) { + row = this.view.getResourceRow(state.resourceId); + if (row) { + el = row.getTr('event'); + if (el) { + innerTop = this.bodyScroller.canvas.el.offset().top; + elBottom = el.offset().top + el.outerHeight(); + state.top = elBottom - state.bottom - innerTop; + } + } + } + return ResourceTimelineGrid.__super__.setScroll.call(this, state); + }; + + ResourceTimelineGrid.prototype.scrollToResource = function(resource) { + var el, innerTop, row, scrollTop; + row = this.view.getResourceRow(resource.id); + if (row) { + el = row.getTr('event'); + if (el) { + innerTop = this.bodyScroller.canvas.el.offset().top; + scrollTop = el.offset().top - innerTop; + return this.bodyScroller.scrollEl.scrollTop(scrollTop); + } + } + }; + + return ResourceTimelineGrid; + +})(TimelineGrid); + +COL_MIN_WIDTH = 30; + +Spreadsheet = (function() { + Spreadsheet.prototype.view = null; + + Spreadsheet.prototype.headEl = null; + + Spreadsheet.prototype.el = null; + + Spreadsheet.prototype.tbodyEl = null; + + Spreadsheet.prototype.headScroller = null; + + Spreadsheet.prototype.bodyScroller = null; + + Spreadsheet.prototype.joiner = null; + + function Spreadsheet(view1) { + var colSpec; + this.view = view1; + this.isRTL = this.view.opt('isRTL'); + this.givenColWidths = this.colWidths = (function() { + var j, len, ref, results; + ref = this.view.colSpecs; + results = []; + for (j = 0, len = ref.length; j < len; j++) { + colSpec = ref[j]; + results.push(colSpec.width); + } + return results; + }).call(this); + } + + Spreadsheet.prototype.colGroupHtml = ''; + + Spreadsheet.prototype.headTable = null; + + Spreadsheet.prototype.headColEls = null; + + Spreadsheet.prototype.headCellEls = null; + + Spreadsheet.prototype.bodyColEls = null; + + Spreadsheet.prototype.bodyTable = null; + + Spreadsheet.prototype.renderSkeleton = function() { + this.headScroller = new ClippedScroller({ + overflowX: 'clipped-scroll', + overflowY: 'hidden' + }); + this.headScroller.canvas = new ScrollerCanvas(); + this.headScroller.render(); + this.headScroller.canvas.contentEl.html(this.renderHeadHtml()); + this.headEl.append(this.headScroller.el); + this.bodyScroller = new ClippedScroller({ + overflowY: 'clipped-scroll' + }); + this.bodyScroller.canvas = new ScrollerCanvas(); + this.bodyScroller.render(); + this.bodyScroller.canvas.contentEl.html('' + this.colGroupHtml + '
'); + this.tbodyEl = this.bodyScroller.canvas.contentEl.find('tbody'); + this.el.append(this.bodyScroller.el); + this.joiner = new ScrollJoiner('horizontal', [this.headScroller, this.bodyScroller]); + this.headTable = this.headEl.find('table'); + this.headColEls = this.headEl.find('col'); + this.headCellEls = this.headScroller.canvas.contentEl.find('tr:last-child th'); + this.bodyColEls = this.el.find('col'); + this.bodyTable = this.el.find('table'); + this.colMinWidths = this.computeColMinWidths(); + this.applyColWidths(); + return this.initColResizing(); + }; + + Spreadsheet.prototype.renderHeadHtml = function() { + var colGroupHtml, colSpecs, html, i, isLast, isMainCol, j, k, len, len1, o; + colSpecs = this.view.colSpecs; + html = ''; + colGroupHtml = ''; + for (j = 0, len = colSpecs.length; j < len; j++) { + o = colSpecs[j]; + if (o.isMain) { + colGroupHtml += ''; + } else { + colGroupHtml += ''; + } + } + colGroupHtml += ''; + this.colGroupHtml = colGroupHtml; + html += colGroupHtml; + html += ''; + if (this.view.superHeaderText) { + html += '' + '' + ''; + } + html += ''; + isMainCol = true; + for (i = k = 0, len1 = colSpecs.length; k < len1; i = ++k) { + o = colSpecs[i]; + isLast = i === colSpecs.length - 1; + html += ''; + } + html += ''; + html += '
' + '
' + '' + htmlEscape(this.view.superHeaderText) + '' + '
' + '
' + '
' + '
' + (o.isMain ? '' + '' + '' : '') + '' + htmlEscape(o.labelText || '') + '' + '
' + (!isLast ? '
' : '') + '
' + '
'; + return html; + }; + + Spreadsheet.prototype.givenColWidths = null; + + Spreadsheet.prototype.colWidths = null; + + Spreadsheet.prototype.colMinWidths = null; + + Spreadsheet.prototype.tableWidth = null; + + Spreadsheet.prototype.tableMinWidth = null; + + Spreadsheet.prototype.initColResizing = function() { + return this.headEl.find('th .fc-col-resizer').each((function(_this) { + return function(i, resizerEl) { + resizerEl = $(resizerEl); + return resizerEl.on('mousedown', function(ev) { + return _this.colResizeMousedown(i, ev, resizerEl); + }); + }; + })(this)); + }; + + Spreadsheet.prototype.colResizeMousedown = function(i, ev, resizerEl) { + var colWidths, dragListener, minWidth, origColWidth; + colWidths = this.colWidths = this.queryColWidths(); + colWidths.pop(); + colWidths.push(null); + origColWidth = colWidths[i]; + minWidth = Math.min(this.colMinWidths[i], COL_MIN_WIDTH); + dragListener = new DragListener({ + dragStart: (function(_this) { + return function() { + return resizerEl.addClass('fc-active'); + }; + })(this), + drag: (function(_this) { + return function(dx, dy) { + var width; + width = origColWidth + (_this.isRTL ? -dx : dx); + width = Math.max(width, minWidth); + colWidths[i] = width; + return _this.applyColWidths(); + }; + })(this), + dragEnd: (function(_this) { + return function() { + return resizerEl.removeClass('fc-active'); + }; + })(this) + }); + return dragListener.startInteraction(ev); + }; + + Spreadsheet.prototype.applyColWidths = function() { + var allNumbers, anyPercentages, colMinWidths, colWidth, colWidths, cssWidth, cssWidths, defaultCssWidth, i, j, k, l, len, len1, len2, tableMinWidth, total; + colMinWidths = this.colMinWidths; + colWidths = this.colWidths; + allNumbers = true; + anyPercentages = false; + total = 0; + for (j = 0, len = colWidths.length; j < len; j++) { + colWidth = colWidths[j]; + if (typeof colWidth === 'number') { + total += colWidth; + } else { + allNumbers = false; + if (colWidth) { + anyPercentages = true; + } + } + } + defaultCssWidth = anyPercentages && !this.view.isHGrouping ? 'auto' : ''; + cssWidths = (function() { + var k, len1, results; + results = []; + for (i = k = 0, len1 = colWidths.length; k < len1; i = ++k) { + colWidth = colWidths[i]; + results.push(colWidth != null ? colWidth : defaultCssWidth); + } + return results; + })(); + tableMinWidth = 0; + for (i = k = 0, len1 = cssWidths.length; k < len1; i = ++k) { + cssWidth = cssWidths[i]; + tableMinWidth += typeof cssWidth === 'number' ? cssWidth : colMinWidths[i]; + } + for (i = l = 0, len2 = cssWidths.length; l < len2; i = ++l) { + cssWidth = cssWidths[i]; + this.headColEls.eq(i).width(cssWidth); + this.bodyColEls.eq(i).width(cssWidth); + } + this.headScroller.canvas.setMinWidth(tableMinWidth); + this.bodyScroller.canvas.setMinWidth(tableMinWidth); + this.tableMinWidth = tableMinWidth; + return this.tableWidth = allNumbers ? total : void 0; + }; + + Spreadsheet.prototype.computeColMinWidths = function() { + var i, j, len, ref, results, width; + ref = this.givenColWidths; + results = []; + for (i = j = 0, len = ref.length; j < len; i = ++j) { + width = ref[i]; + if (typeof width === 'number') { + results.push(width); + } else { + results.push(parseInt(this.headColEls.eq(i).css('min-width')) || COL_MIN_WIDTH); + } + } + return results; + }; + + Spreadsheet.prototype.queryColWidths = function() { + var j, len, node, ref, results; + ref = this.headCellEls; + results = []; + for (j = 0, len = ref.length; j < len; j++) { + node = ref[j]; + results.push($(node).outerWidth()); + } + return results; + }; + + Spreadsheet.prototype.updateWidth = function() { + this.headScroller.updateSize(); + this.bodyScroller.updateSize(); + this.joiner.update(); + if (this.follower) { + return this.follower.update(); + } + }; + + Spreadsheet.prototype.headHeight = function() { + var table; + table = this.headScroller.canvas.contentEl.find('table'); + return table.height.apply(table, arguments); + }; + + return Spreadsheet; + +})(); + + +/* +An abstract node in a row-hierarchy tree. +May be a self-contained single row, a row with subrows, +OR a grouping of rows without its own distinct row. + */ + +RowParent = (function() { + RowParent.prototype.view = null; + + RowParent.prototype.parent = null; + + RowParent.prototype.prevSibling = null; + + RowParent.prototype.children = null; + + RowParent.prototype.depth = 0; + + RowParent.prototype.hasOwnRow = false; + + RowParent.prototype.trHash = null; + + RowParent.prototype.trs = null; + + RowParent.prototype.isRendered = false; + + RowParent.prototype.isExpanded = true; + + RowParent.prototype.isShown = false; + + function RowParent(view1) { + this.view = view1; + this.children = []; + this.trHash = {}; + this.trs = $(); + } + + + /* + Adds the given node as a child. + Will be inserted at the `index`. If not given, will be appended to the end. + */ + + RowParent.prototype.addChild = function(child, index) { + var children, j, len, node, ref; + child.remove(); + children = this.children; + if (index != null) { + children.splice(index, 0, child); + } else { + index = children.length; + children.push(child); + } + child.prevSibling = index > 0 ? children[index - 1] : null; + if (index < children.length - 1) { + children[index + 1].prevSibling = child; + } + child.parent = this; + child.depth = this.depth + (this.hasOwnRow ? 1 : 0); + ref = child.getNodes(); + for (j = 0, len = ref.length; j < len; j++) { + node = ref[j]; + node.added(); + } + if (this.isShown && this.isExpanded) { + return child.show(); + } + }; + + + /* + Removes the given child from the node. Assumes it is a direct child. + If not a direct child, returns false and nothing happens. + Unrenders the child and triggers handlers. + */ + + RowParent.prototype.removeChild = function(child) { + var children, i, isFound, j, k, len, len1, ref, row, testChild; + children = this.children; + isFound = false; + for (i = j = 0, len = children.length; j < len; i = ++j) { + testChild = children[i]; + if (testChild === child) { + isFound = true; + break; + } + } + if (!isFound) { + return false; + } else { + if (i < children.length - 1) { + children[i + 1].prevSibling = child.prevSibling; + } + children.splice(i, 1); + child.recursivelyUnrender(); + ref = child.getNodes(); + for (k = 0, len1 = ref.length; k < len1; k++) { + row = ref[k]; + row.removed(); + } + child.parent = null; + child.prevSibling = null; + return child; + } + }; + + + /* + Removes all of the node's children from the hierarchy. Unrenders them and triggers callbacks. + NOTE: batchRows/unbatchRows should probably be called before this happens :( + */ + + RowParent.prototype.removeChildren = function() { + var child, j, k, len, len1, ref, ref1; + ref = this.children; + for (j = 0, len = ref.length; j < len; j++) { + child = ref[j]; + child.recursivelyUnrender(); + } + ref1 = this.getDescendants(); + for (k = 0, len1 = ref1.length; k < len1; k++) { + child = ref1[k]; + child.removed(); + } + return this.children = []; + }; + + + /* + Removes this node from its parent + */ + + RowParent.prototype.remove = function() { + if (this.parent) { + return this.parent.removeChild(this); + } + }; + + + /* + Gets the last direct child node + */ + + RowParent.prototype.getLastChild = function() { + var children; + children = this.children; + return children[children.length - 1]; + }; + + + /* + Walks backward in the hierarchy to find the previous row leaf node. + When looking at the hierarchy in a flat linear fashion, this is the revealed row just before the current. + */ + + RowParent.prototype.getPrevRow = function() { + var lastChild, node; + node = this; + while (node) { + if (node.prevSibling) { + node = node.prevSibling; + while ((lastChild = node.getLastChild())) { + node = lastChild; + } + } else { + node = node.parent; + } + if (node && node.hasOwnRow && node.isShown) { + return node; + } + } + return null; + }; + + + /* + Returns the first node in the subtree that has a revealed row + */ + + RowParent.prototype.getLeadingRow = function() { + if (this.hasOwnRow) { + return this; + } else if (this.isExpanded && this.children.length) { + return this.children[0].getLeadingRow(); + } + }; + + + /* + Generates a flat array containing all the row-nodes of the subtree. Descendants + self + */ + + RowParent.prototype.getRows = function(batchArray) { + var child, j, len, ref; + if (batchArray == null) { + batchArray = []; + } + if (this.hasOwnRow) { + batchArray.push(this); + } + ref = this.children; + for (j = 0, len = ref.length; j < len; j++) { + child = ref[j]; + child.getRows(batchArray); + } + return batchArray; + }; + + + /* + Generates a flat array containing all the nodes (row/non-row) of the subtree. Descendants + self + */ + + RowParent.prototype.getNodes = function(batchArray) { + var child, j, len, ref; + if (batchArray == null) { + batchArray = []; + } + batchArray.push(this); + ref = this.children; + for (j = 0, len = ref.length; j < len; j++) { + child = ref[j]; + child.getNodes(batchArray); + } + return batchArray; + }; + + + /* + Generates a flat array containing all the descendant nodes the current node + */ + + RowParent.prototype.getDescendants = function() { + var batchArray, child, j, len, ref; + batchArray = []; + ref = this.children; + for (j = 0, len = ref.length; j < len; j++) { + child = ref[j]; + child.getNodes(batchArray); + } + return batchArray; + }; + + + /* + Builds and populates the TRs for each row type. Inserts them into the DOM. + Does this only for this single row. Not recursive. If not a row (hasOwnRow=false), does not render anything. + PRECONDITION: assumes the parent has already been rendered. + */ + + RowParent.prototype.render = function() { + var prevRow, ref, renderMethodName, tbody, tr, trNodes, type; + this.trHash = {}; + trNodes = []; + if (this.hasOwnRow) { + prevRow = this.getPrevRow(); + ref = this.view.tbodyHash; + for (type in ref) { + tbody = ref[type]; + tr = $(''); + this.trHash[type] = tr; + trNodes.push(tr[0]); + renderMethodName = 'render' + capitaliseFirstLetter(type) + 'Content'; + if (this[renderMethodName]) { + this[renderMethodName](tr); + } + if (prevRow) { + prevRow.trHash[type].after(tr); + } else { + tbody.prepend(tr); + } + } + } + this.trs = $(trNodes).on('click', '.fc-expander', proxy(this, 'toggleExpanded')); + return this.isRendered = true; + }; + + + /* + Unpopulates and removes all of this row's TRs from the DOM. Only for this single row. Not recursive. + Will trigger "hidden". + */ + + RowParent.prototype.unrender = function() { + var ref, tr, type, unrenderMethodName; + if (this.isRendered) { + ref = this.trHash; + for (type in ref) { + tr = ref[type]; + unrenderMethodName = 'unrender' + capitaliseFirstLetter(type) + 'Content'; + if (this[unrenderMethodName]) { + this[unrenderMethodName](tr); + } + } + this.trHash = {}; + this.trs.remove(); + this.trs = $(); + this.isRendered = false; + this.isShown = false; + return this.hidden(); + } + }; + + + /* + Like unrender(), but does it for this row AND all descendants. + NOTE: batchRows/unbatchRows should probably be called before this happens :( + */ + + RowParent.prototype.recursivelyUnrender = function() { + var child, j, len, ref, results; + this.unrender(); + ref = this.children; + results = []; + for (j = 0, len = ref.length; j < len; j++) { + child = ref[j]; + results.push(child.recursivelyUnrender()); + } + return results; + }; + + + /* + A simple getter for retrieving a TR jQuery object of a certain row type + */ + + RowParent.prototype.getTr = function(type) { + return this.trHash[type]; + }; + + + /* + Renders this row if not already rendered, making sure it is visible. + Also renders descendants of this subtree, based on whether they are expanded or not. + NOTE: If called externally, batchRows/unbatchRows should probably be called before this happens :( + */ + + RowParent.prototype.show = function() { + var child, j, len, ref, results; + if (!this.isShown) { + if (!this.isRendered) { + this.render(); + } else { + this.trs.css('display', ''); + } + if (this.ensureSegsRendered) { + this.ensureSegsRendered(); + } + if (this.isExpanded) { + this.indicateExpanded(); + } else { + this.indicateCollapsed(); + } + this.isShown = true; + this.shown(); + if (this.isExpanded) { + ref = this.children; + results = []; + for (j = 0, len = ref.length; j < len; j++) { + child = ref[j]; + results.push(child.show()); + } + return results; + } + } + }; + + + /* + Temporarily hides this node's TRs (if applicable) as well as all nodes in the subtree + */ + + RowParent.prototype.hide = function() { + var child, j, len, ref, results; + if (this.isShown) { + if (this.isRendered) { + this.trs.hide(); + } + this.isShown = false; + this.hidden(); + if (this.isExpanded) { + ref = this.children; + results = []; + for (j = 0, len = ref.length; j < len; j++) { + child = ref[j]; + results.push(child.hide()); + } + return results; + } + } + }; + + + /* + Reveals this node's children if they have not already been revealed. Changes any expander icon. + */ + + RowParent.prototype.expand = function() { + var child, j, len, ref; + if (!this.isExpanded) { + this.isExpanded = true; + this.indicateExpanded(); + this.view.batchRows(); + ref = this.children; + for (j = 0, len = ref.length; j < len; j++) { + child = ref[j]; + child.show(); + } + this.view.unbatchRows(); + return this.animateExpand(); + } + }; + + + /* + Hides this node's children if they are not already hidden. Changes any expander icon. + */ + + RowParent.prototype.collapse = function() { + var child, j, len, ref; + if (this.isExpanded) { + this.isExpanded = false; + this.indicateCollapsed(); + this.view.batchRows(); + ref = this.children; + for (j = 0, len = ref.length; j < len; j++) { + child = ref[j]; + child.hide(); + } + return this.view.unbatchRows(); + } + }; + + + /* + Switches between expanded/collapsed states + */ + + RowParent.prototype.toggleExpanded = function() { + if (this.isExpanded) { + return this.collapse(); + } else { + return this.expand(); + } + }; + + + /* + Changes the expander icon to the "expanded" state + */ + + RowParent.prototype.indicateExpanded = function() { + return this.trs.find('.fc-expander .fc-icon').removeClass(this.getCollapsedIcon()).addClass(this.getExpandedIcon()); + }; + + + /* + Changes the expander icon to the "collapsed" state + */ + + RowParent.prototype.indicateCollapsed = function() { + return this.trs.find('.fc-expander .fc-icon').removeClass(this.getExpandedIcon()).addClass(this.getCollapsedIcon()); + }; + + + /* + */ + + RowParent.prototype.enableExpanding = function() { + return this.trs.find('.fc-expander-space').addClass('fc-expander'); + }; + + + /* + */ + + RowParent.prototype.disableExpanding = function() { + return this.trs.find('.fc-expander-space').removeClass('fc-expander').find('.fc-icon').removeClass(this.getExpandedIcon()).removeClass(this.getCollapsedIcon()); + }; + + RowParent.prototype.getExpandedIcon = function() { + return 'fc-icon-down-triangle'; + }; + + RowParent.prototype.getCollapsedIcon = function() { + var dir; + dir = this.view.isRTL ? 'left' : 'right'; + return 'fc-icon-' + dir + '-triangle'; + }; + + + /* + Causes a slide-down CSS transition to demonstrate that the expand has happened + */ + + RowParent.prototype.animateExpand = function() { + var ref, ref1, trs; + trs = (ref = this.children[0]) != null ? (ref1 = ref.getLeadingRow()) != null ? ref1.trs : void 0 : void 0; + if (trs) { + trs.addClass('fc-collapsed'); + setTimeout(function() { + trs.addClass('fc-transitioning'); + return trs.removeClass('fc-collapsed'); + }); + return trs.one('webkitTransitionEnd otransitionend oTransitionEnd msTransitionEnd transitionend', function() { + return trs.removeClass('fc-transitioning'); + }); + } + }; + + + /* + Find each TRs "inner div" (div within first cell). This div controls each TRs height. + Returns the max pixel height. + */ + + RowParent.prototype.getMaxTrInnerHeight = function() { + var max; + max = 0; + $.each(this.trHash, (function(_this) { + return function(type, tr) { + var innerEl; + innerEl = getOwnCells(tr).find('> div:not(.fc-cell-content):first'); + return max = Math.max(innerEl.height(), max); + }; + })(this)); + return max; + }; + + + /* + Find each TRs "inner div" and sets all of their heights to the same value. + */ + + RowParent.prototype.setTrInnerHeight = function(height) { + return $.each(this.trHash, (function(_this) { + return function(type, tr) { + return getOwnCells(tr).find('> div:not(.fc-cell-content):first').height(height); + }; + })(this)); + }; + + + /* + Triggered when the current node has been shown (either freshly rendered or re-shown) + when it had previously been unrendered or hidden. `shown` does not bubble up the hierarchy. + */ + + RowParent.prototype.shown = function() { + if (this.hasOwnRow) { + return this.rowShown(this); + } + }; + + + /* + Triggered when the current node has been hidden (either temporarily or permanently) + when it had previously been shown. `hidden` does not bubble up the hierarchy. + */ + + RowParent.prototype.hidden = function() { + if (this.hasOwnRow) { + return this.rowHidden(this); + } + }; + + + /* + Just like `shown`, but only triggered for nodes that are actual rows. Bubbles up the hierarchy. + */ + + RowParent.prototype.rowShown = function(row) { + return (this.parent || this.view).rowShown(row); + }; + + + /* + Just like `hidden`, but only triggered for nodes that are actual rows. Bubbles up the hierarchy. + */ + + RowParent.prototype.rowHidden = function(row) { + return (this.parent || this.view).rowHidden(row); + }; + + + /* + Triggered when the current node has been added to the hierarchy. `added` does not bubble up. + */ + + RowParent.prototype.added = function() { + if (this.hasOwnRow) { + return this.rowAdded(this); + } + }; + + + /* + Triggered when the current node has been removed from the hierarchy. `removed` does not bubble up. + */ + + RowParent.prototype.removed = function() { + if (this.hasOwnRow) { + return this.rowRemoved(this); + } + }; + + + /* + Just like `added`, but only triggered for nodes that are actual rows. Bubbles up the hierarchy. + */ + + RowParent.prototype.rowAdded = function(row) { + return (this.parent || this.view).rowAdded(row); + }; + + + /* + Just like `removed`, but only triggered for nodes that are actual rows. Bubbles up the hierarchy. + */ + + RowParent.prototype.rowRemoved = function(row) { + return (this.parent || this.view).rowRemoved(row); + }; + + return RowParent; + +})(); + + +/* +An abstract node in a row-hierarchy tree that contains other nodes. +Will have some sort of rendered label indicating the grouping, +up to the subclass for determining what to do with it. + */ + +RowGroup = (function(superClass) { + extend(RowGroup, superClass); + + RowGroup.prototype.groupSpec = null; + + RowGroup.prototype.groupValue = null; + + function RowGroup(view, groupSpec1, groupValue1) { + this.groupSpec = groupSpec1; + this.groupValue = groupValue1; + RowGroup.__super__.constructor.apply(this, arguments); + } + + + /* + Called when this row (if it renders a row) or a subrow is removed + */ + + RowGroup.prototype.rowRemoved = function(row) { + RowGroup.__super__.rowRemoved.apply(this, arguments); + if (row !== this && !this.children.length) { + return this.remove(); + } + }; + + + /* + Renders the content wrapper element that will be inserted into this row's TD cell + */ + + RowGroup.prototype.renderGroupContentEl = function() { + var contentEl, filter; + contentEl = $('
').append(this.renderGroupTextEl()); + filter = this.groupSpec.render; + if (typeof filter === 'function') { + contentEl = filter(contentEl, this.groupValue) || contentEl; + } + return contentEl; + }; + + + /* + Renders the text span element that will be inserted into this row's TD cell. + Goes within the content element. + */ + + RowGroup.prototype.renderGroupTextEl = function() { + var filter, text; + text = this.groupValue || ''; + filter = this.groupSpec.text; + if (typeof filter === 'function') { + text = filter(text) || text; + } + return $('').text(text); + }; + + return RowGroup; + +})(RowParent); + + +/* +A row grouping that renders as a single solid row that spans width-wise (like a horizontal rule) + */ + +HRowGroup = (function(superClass) { + extend(HRowGroup, superClass); + + function HRowGroup() { + return HRowGroup.__super__.constructor.apply(this, arguments); + } + + HRowGroup.prototype.hasOwnRow = true; + + + /* + Renders this row's TR for the "spreadsheet" quadrant, the area with info about each resource + */ + + HRowGroup.prototype.renderSpreadsheetContent = function(tr) { + var contentEl; + contentEl = this.renderGroupContentEl(); + contentEl.prepend('' + '' + ''); + return $('').attr('colspan', this.view.colSpecs.length).append($('
').append(contentEl)).appendTo(tr); + }; + + + /* + Renders this row's TR for the quadrant that contains a resource's events + */ + + HRowGroup.prototype.renderEventContent = function(tr) { + return tr.append('
'); + }; + + return HRowGroup; + +})(RowGroup); + + +/* +A row grouping that renders as a tall multi-cell vertical span in the "spreadsheet" area + */ + +VRowGroup = (function(superClass) { + extend(VRowGroup, superClass); + + function VRowGroup() { + return VRowGroup.__super__.constructor.apply(this, arguments); + } + + VRowGroup.prototype.rowspan = 0; + + VRowGroup.prototype.leadingTr = null; + + VRowGroup.prototype.groupTd = null; + + + /* + Called when a row somewhere within the grouping is shown + */ + + VRowGroup.prototype.rowShown = function(row) { + this.rowspan += 1; + this.renderRowspan(); + return VRowGroup.__super__.rowShown.apply(this, arguments); + }; + + + /* + Called when a row somewhere within the grouping is hidden + */ + + VRowGroup.prototype.rowHidden = function(row) { + this.rowspan -= 1; + this.renderRowspan(); + return VRowGroup.__super__.rowHidden.apply(this, arguments); + }; + + + /* + Makes sure the groupTd has the correct rowspan / place in the DOM. + PRECONDITION: in the case of multiple group nesting, a child's renderRowspan() + will be called before the parent's renderRowspan(). + */ + + VRowGroup.prototype.renderRowspan = function() { + var leadingTr; + if (this.rowspan) { + if (!this.groupTd) { + this.groupTd = $('').append(this.renderGroupContentEl()); + } + this.groupTd.attr('rowspan', this.rowspan); + leadingTr = this.getLeadingRow().getTr('spreadsheet'); + if (leadingTr !== this.leadingTr) { + if (leadingTr) { + leadingTr.prepend(this.groupTd); + } + return this.leadingTr = leadingTr; + } + } else { + if (this.groupTd) { + this.groupTd.remove(); + this.groupTd = null; + } + return this.leadingTr = null; + } + }; + + return VRowGroup; + +})(RowGroup); + +EventRow = (function(superClass) { + extend(EventRow, superClass); + + function EventRow() { + return EventRow.__super__.constructor.apply(this, arguments); + } + + EventRow.prototype.hasOwnRow = true; + + EventRow.prototype.segContainerEl = null; + + EventRow.prototype.segContainerHeight = null; + + EventRow.prototype.innerEl = null; + + EventRow.prototype.bgSegContainerEl = null; + + EventRow.prototype.isSegsRendered = false; + + EventRow.prototype.bgSegs = null; + + EventRow.prototype.fgSegs = null; + + EventRow.prototype.renderEventContent = function(tr) { + tr.html('
'); + this.segContainerEl = tr.find('.fc-event-container'); + this.innerEl = this.bgSegContainerEl = tr.find('td > div'); + return this.ensureSegsRendered(); + }; + + EventRow.prototype.ensureSegsRendered = function() { + if (!this.isSegsRendered) { + if (this.bgSegs) { + this.view.timeGrid.renderFillInContainer('bgEvent', this, this.bgSegs); + } + if (this.fgSegs) { + this.view.timeGrid.renderFgSegsInContainers([[this, this.fgSegs]]); + } + return this.isSegsRendered = true; + } + }; + + EventRow.prototype.unrenderEventContent = function() { + this.bgSegs = null; + this.fgSegs = null; + return this.isSegsRendered = false; + }; + + return EventRow; + +})(RowParent); + + +/* +A row that renders information about a particular resource, as well as it events (handled by superclass) + */ + +ResourceRow = (function(superClass) { + extend(ResourceRow, superClass); + + ResourceRow.prototype.resource = null; + + function ResourceRow(view, resource1) { + this.resource = resource1; + ResourceRow.__super__.constructor.apply(this, arguments); + } + + + /* + Called when a row in the tree has been added + */ + + ResourceRow.prototype.rowAdded = function(row) { + ResourceRow.__super__.rowAdded.apply(this, arguments); + if (row !== this && this.isRendered) { + if (this.children.length === 1) { + this.enableExpanding(); + if (this.isExpanded) { + return this.indicateExpanded(); + } else { + return this.indicateCollapsed(); + } + } + } + }; + + + /* + Called when a row in the tree has been removed + */ + + ResourceRow.prototype.rowRemoved = function(row) { + ResourceRow.__super__.rowRemoved.apply(this, arguments); + if (row !== this && this.isRendered) { + if (!this.children.length) { + return this.disableExpanding(); + } + } + }; + + ResourceRow.prototype.render = function() { + ResourceRow.__super__.render.apply(this, arguments); + if (this.children.length > 0) { + this.enableExpanding(); + } else { + this.disableExpanding(); + } + return this.view.trigger('resourceRender', this.resource, this.resource, this.getTr('spreadsheet').find('> td'), this.getTr('event').find('> td')); + }; + + ResourceRow.prototype.renderEventContent = function(tr) { + ResourceRow.__super__.renderEventContent.apply(this, arguments); + return tr.attr('data-resource-id', this.resource.id); + }; + + + /* + Populates the TR with cells containing data about the resource + */ + + ResourceRow.prototype.renderSpreadsheetContent = function(tr) { + var colSpec, contentEl, input, j, len, ref, resource, td, text; + resource = this.resource; + ref = this.view.colSpecs; + for (j = 0, len = ref.length; j < len; j++) { + colSpec = ref[j]; + if (colSpec.group) { + continue; + } + input = colSpec.field ? resource[colSpec.field] || null : resource; + text = typeof colSpec.text === 'function' ? colSpec.text(resource, input) : input; + contentEl = $('
' + (colSpec.isMain ? this.renderGutterHtml() : '') + '' + (text ? htmlEscape(text) : ' ') + '' + '
'); + if (typeof colSpec.render === 'function') { + contentEl = colSpec.render(resource, contentEl, input) || contentEl; + } + td = $('').append(contentEl); + if (colSpec.isMain) { + td.wrapInner('
'); + } + tr.append(td); + } + return tr.attr('data-resource-id', resource.id); + }; + + + /* + Renders the HTML responsible for the subrow expander area, + as well as the space before it (used to align expanders of similar depths) + */ + + ResourceRow.prototype.renderGutterHtml = function() { + var html, i, j, ref; + html = ''; + for (i = j = 0, ref = this.depth; j < ref; i = j += 1) { + html += ''; + } + html += '' + '' + ''; + return html; + }; + + return ResourceRow; + +})(EventRow); + +FC.views.timeline.resourceClass = ResourceTimelineView; + +ResourceAgendaView = (function(superClass) { + extend(ResourceAgendaView, superClass); + + function ResourceAgendaView() { + return ResourceAgendaView.__super__.constructor.apply(this, arguments); + } + + ResourceAgendaView.mixin(ResourceViewMixin); + + ResourceAgendaView.prototype.timeGridClass = ResourceTimeGrid; + + ResourceAgendaView.prototype.dayGridClass = ResourceDayGrid; + + ResourceAgendaView.prototype.renderHead = function() { + ResourceAgendaView.__super__.renderHead.apply(this, arguments); + return this.timeGrid.processHeadResourceEls(this.headContainerEl); + }; + + ResourceAgendaView.prototype.setResources = function(resources) { + this.timeGrid.setResources(resources); + if (this.dayGrid) { + this.dayGrid.setResources(resources); + } + this.clearView(); + return this.displayView(); + }; + + ResourceAgendaView.prototype.unsetResources = function(isDestroying) { + this.clearEvents(); + this.timeGrid.unsetResources(); + if (this.dayGrid) { + this.dayGrid.unsetResources(); + } + if (!isDestroying) { + this.clearView(); + return this.displayView(); + } + }; + + return ResourceAgendaView; + +})(FC.AgendaView); + +FC.views.agenda.queryResourceClass = function(viewSpec) { + var ref; + if ((ref = viewSpec.options.groupByResource || viewSpec.options.groupByDateAndResource) != null ? ref : viewSpec.duration.as('days') === 1) { + return ResourceAgendaView; + } +}; + +ResourceBasicView = (function(superClass) { + extend(ResourceBasicView, superClass); + + function ResourceBasicView() { + return ResourceBasicView.__super__.constructor.apply(this, arguments); + } + + ResourceBasicView.mixin(ResourceViewMixin); + + ResourceBasicView.prototype.dayGridClass = ResourceDayGrid; + + ResourceBasicView.prototype.renderHead = function() { + ResourceBasicView.__super__.renderHead.apply(this, arguments); + return this.dayGrid.processHeadResourceEls(this.headContainerEl); + }; + + ResourceBasicView.prototype.setResources = function(resources) { + this.dayGrid.setResources(resources); + this.clearView(); + return this.displayView(); + }; + + ResourceBasicView.prototype.unsetResources = function(isDestroying) { + this.clearEvents(); + this.dayGrid.unsetResources(); + if (!isDestroying) { + this.clearView(); + return this.displayView(); + } + }; + + return ResourceBasicView; + +})(FC.BasicView); + +ResourceMonthView = (function(superClass) { + extend(ResourceMonthView, superClass); + + function ResourceMonthView() { + return ResourceMonthView.__super__.constructor.apply(this, arguments); + } + + ResourceMonthView.mixin(ResourceViewMixin); + + ResourceMonthView.prototype.dayGridClass = ResourceDayGrid; + + ResourceMonthView.prototype.renderHead = function() { + ResourceMonthView.__super__.renderHead.apply(this, arguments); + return this.dayGrid.processHeadResourceEls(this.headContainerEl); + }; + + ResourceMonthView.prototype.setResources = function(resources) { + this.dayGrid.setResources(resources); + this.clearView(); + return this.displayView(); + }; + + ResourceMonthView.prototype.unsetResources = function() { + this.clearEvents(); + this.dayGrid.unsetResources(); + this.clearView(); + return this.displayView(); + }; + + return ResourceMonthView; + +})(FC.MonthView); + +FC.views.basic.queryResourceClass = function(viewSpec) { + var ref; + if ((ref = viewSpec.options.groupByResource || viewSpec.options.groupByDateAndResource) != null ? ref : viewSpec.duration.as('days') === 1) { + return ResourceBasicView; + } +}; + +FC.views.month.queryResourceClass = function(viewSpec) { + if (viewSpec.options.groupByResource || viewSpec.options.groupByDateAndResource) { + return ResourceMonthView; + } +}; + +RELEASE_DATE = '2016-06-02'; + +UPGRADE_WINDOW = { + years: 1, + weeks: 1 +}; + +LICENSE_INFO_URL = 'http://fullcalendar.io/scheduler/license/'; + +PRESET_LICENSE_KEYS = ['GPL-My-Project-Is-Open-Source', 'CC-Attribution-NonCommercial-NoDerivatives']; + +processLicenseKey = function(key, containerEl) { + if (!isImmuneUrl(window.location.href) && !isValidKey(key)) { + if (!detectWarningInContainer(containerEl)) { + return renderingWarningInContainer('Please use a valid license key. More Info', containerEl); + } + } +}; + + +/* +This decryption is not meant to be bulletproof. Just a way to remind about an upgrade. + */ + +isValidKey = function(key) { + var minPurchaseDate, parts, purchaseDate, releaseDate; + if ($.inArray(key, PRESET_LICENSE_KEYS) !== -1) { + return true; + } + parts = (key || '').match(/^(\d+)\-fcs\-(\d+)$/); + if (parts && parts[1].length === 10) { + purchaseDate = moment.utc(parseInt(parts[2]) * 1000); + releaseDate = moment.utc(FC.mockSchedulerReleaseDate || RELEASE_DATE); + if (releaseDate.isValid()) { + minPurchaseDate = releaseDate.clone().subtract(UPGRADE_WINDOW); + if (purchaseDate.isAfter(minPurchaseDate)) { + return true; + } + } + } + return false; +}; + +isImmuneUrl = function(url) { + return Boolean(url.match(/\w+\:\/\/fullcalendar\.io\/|\/demos\/[\w-]+\.html$/)); +}; + +renderingWarningInContainer = function(messageHtml, containerEl) { + return containerEl.append($('
').html(messageHtml)); +}; + +detectWarningInContainer = function(containerEl) { + return containerEl.find('.fc-license-message').length >= 1; +}; + +}); diff --git a/src/calendar/widget/calendar.js b/src/calendar/widget/calendar.js index 52261d0..254fb4d 100644 --- a/src/calendar/widget/calendar.js +++ b/src/calendar/widget/calendar.js @@ -16,8 +16,9 @@ define([ "calendar/lib/jquery", "calendar/lib/moment", "calendar/lib/fullcalendar", - "calendar/lib/lang-all" -], function (declare, _WidgetBase, dom, dojoDom, domQuery, domProp, domGeom, domClass, domStyle, domConstruct, dojoArray, lang, _jQuery, moment, fullCalendar, calendarLang) { + "calendar/lib/lang-all", + "calendar/lib/scheduler" +], function (declare, _WidgetBase, dom, dojoDom, domQuery, domProp, domGeom, domClass, domStyle, domConstruct, dojoArray, lang, _jQuery, moment, fullCalendar, calendarLang, scheduler) { "use strict"; var $ = _jQuery.noConflict(true); @@ -44,7 +45,6 @@ define([ postCreate: function () { logger.debug(this.id + ".postCreate"); - this._colors = this.notused; //workaround for legacy users this._availableViews = this.notused1; //workaround for legacy users this._setDefaults(); //set default formatting options @@ -96,6 +96,52 @@ define([ this._fcNode.fullCalendar("render"); }, + _setSchedulerOptions: function(options) { + logger.debug(this.id + "._setSchedulerOptions"); + if (options.views.timelineThreeDays) { + options.views.timelineThreeDays = { + eventLimit: options.views.timelineThreeDays.eventLimit, + type: 'timeline', + duration: { days: 3 } + } + }; + options.resources = []; + options.resourceLabelText = this.resourceLabelText; + + return options; + }, + + _getResources: function(entity, callback) { + logger.debug(this.id + "._getResources"); + mx.data.get({ + xpath: "//" + this.resourceEntity, + callback: lang.hitch(this, function (objs) { + logger.debug(this.id + "._getResources callback:", objs ? objs.length + " objects" : "null"); + if (callback) { + callback(objs); + } + }), + error: function (error) { + if (callback) { + callback(); + } + console.warn(error.description); + } + }); + }, + + _prepareResources: function(resources) { + var resourceTitle = this.resourceTitle + var node = this._fcNode + + resources.forEach(function(resource) { + var fullCalenderResource = {} + fullCalenderResource.title = resource.get(resourceTitle) + fullCalenderResource.id = resource.getGuid() + node.fullCalendar('addResource', fullCalenderResource) + }) + }, + _addSubscriptions: function () { logger.debug(this.id + "._addSubscriptions"); var subscription = mx.data.subscribe({ @@ -154,6 +200,11 @@ define([ xpath = null, errordiv = null; + if (this.resourceEntity) { + logger.debug(this.id + "._fetchObjects resources"); + this._getResources(this.resourceEntity, lang.hitch(this, this._prepareResources)); + } + if (this.dataSourceType === "xpath") { logger.debug(this.id + "._fetchObjects xpath"); constraint = this.eventConstraint; @@ -287,48 +338,64 @@ define([ _createEvents: function (objs, titles) { logger.debug(this.id + "._createEvents"); var events = [], - objcolors = null; + objcolors = null, + resourceEntity = this.resourceEntity, + resourceEventPath = this.resourceEventPath, + promises = []; $.each(objs, lang.hitch(this, function (index, obj) { - //get the colors - if (this._colors.length > 0 && this.typeAttr) { - objcolors = this._getObjectColors(obj); - } - //get the dates - var start = new Date(obj.get(this.startAttr)), - end = new Date(obj.get(this.endAttr)), - //create a new calendar event - newEvent = { - title: titles[obj.getGuid()], - start: start, - end: end, - allDay: obj.get(this.alldayAttr), - editable: this.editable, - mxobject: obj //we add the mxobject to be able to handle events with relative ease. - }; - - if (objcolors) { - newEvent.backgroundColor = objcolors.backgroundColor; - newEvent.borderColor = objcolors.borderColor; - newEvent.textColor = objcolors.textColor; - } - events.push(newEvent); + + var promise = $.Deferred(lang.hitch(this, function(callback) { + obj.fetch(resourceEventPath, lang.hitch(this, function(resource) { + var resourceRefId = (resource !== null) ? resource.getGuid() : 0; + + //get the colors + if (this._colors.length > 0 && this.typeAttr) { + objcolors = this._getObjectColors(obj); + } + //get the dates + var start = new Date(obj.get(this.startAttr)), + end = new Date(obj.get(this.endAttr)), + //create a new calendar event + newEvent = { + title: titles[obj.getGuid()], + resourceId: resourceRefId, + start: start, + end: end, + allDay: obj.get(this.alldayAttr), + editable: this.editable, + mxobject: obj //we add the mxobject to be able to handle events with relative ease. + }; + + if (objcolors) { + newEvent.backgroundColor = objcolors.backgroundColor; + newEvent.borderColor = objcolors.borderColor; + newEvent.textColor = objcolors.textColor; + } + + events.push(newEvent); + callback.resolve(); + }))})) + promises.push(promise); })); - //check if the calendar already exists (are we just updating events here?) - if (this._fcNode.hasClass("fc")) { - //if it does, remove, add the new source and refetch - this._fcNode.fullCalendar("render"); - if (this._eventSource && this._eventSource.length >= 1) { - this._fcNode.fullCalendar("removeEventSource", this._eventSource); - } - this._fcNode.fullCalendar("addEventSource", events); - this._fcNode.fullCalendar("refetchEvents"); - } else { - //else create the calendar - this._renderCalendar(events); - } - this._eventSource = events; + $.when.apply($, promises).done(lang.hitch(this, function() { + //check if the calendar already exists (are we just updating events here?) + if (this._fcNode.hasClass("fc")) { + //if it does, remove, add the new source and refetch + this._fcNode.fullCalendar("render"); + if (this._eventSource && this._eventSource.length >= 1) { + this._fcNode.fullCalendar("removeEventSource", this._eventSource); + } + + this._fcNode.fullCalendar("addEventSource", events); + this._fcNode.fullCalendar("refetchEvents"); + } else { + //else create the calendar + this._renderCalendar(events); + } + this._eventSource = events; + })); }, _renderCalendar: function (events) { @@ -594,6 +661,8 @@ define([ } } + if (this.resourceEntity) options = this._setSchedulerOptions(options) + return options; }, diff --git a/src/calendar/widget/ui/calendar.css b/src/calendar/widget/ui/calendar.css index 9f395b4..4e4d547 100644 --- a/src/calendar/widget/ui/calendar.css +++ b/src/calendar/widget/ui/calendar.css @@ -2,4 +2,10 @@ * FullCalendar v2.8.0 Stylesheet * Docs & License: http://fullcalendar.io/ * (c) 2016 Adam Shaw - */.fc-bgevent,.fc-highlight{opacity:.3;filter:alpha(opacity=30)}.fc-icon,body .fc{font-size:1em}.fc-button-group,.fc-icon{display:inline-block}.fc-bg,.fc-row .fc-bgevent-skeleton,.fc-row .fc-highlight-skeleton{bottom:0}.fc-icon,.fc-unselectable{-khtml-user-select:none;-webkit-touch-callout:none}.fc .fc-axis,.fc button,.fc-time-grid-event .fc-time,.fc-time-grid-event.fc-short .fc-content{white-space:nowrap}.fc{direction:ltr;text-align:left}.fc-rtl{text-align:right}.fc th,.fc-basic-view .fc-week-number,.fc-icon,.fc-toolbar{text-align:center}.fc-unthemed .fc-content,.fc-unthemed .fc-divider,.fc-unthemed .fc-popover,.fc-unthemed .fc-row,.fc-unthemed tbody,.fc-unthemed td,.fc-unthemed th,.fc-unthemed thead{border-color:#ddd}.fc-unthemed .fc-popover{background-color:#fff}.fc-unthemed .fc-divider,.fc-unthemed .fc-popover .fc-header{background:#eee}.fc-unthemed .fc-popover .fc-header .fc-close{color:#666}.fc-unthemed .fc-today{background:#fcf8e3}.fc-highlight{background:#bce8f1}.fc-bgevent{background:#8fdf82}.fc-nonbusiness{background:#d7d7d7}.fc-icon{height:1em;line-height:1em;overflow:hidden;font-family:"Courier New",Courier,monospace;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.fc-icon:after{position:relative}.fc-icon-left-single-arrow:after{content:"\02039";font-weight:700;font-size:200%;top:-7%}.fc-icon-right-single-arrow:after{content:"\0203A";font-weight:700;font-size:200%;top:-7%}.fc-icon-left-double-arrow:after{content:"\000AB";font-size:160%;top:-7%}.fc-icon-right-double-arrow:after{content:"\000BB";font-size:160%;top:-7%}.fc-icon-left-triangle:after{content:"\25C4";font-size:125%;top:3%}.fc-icon-right-triangle:after{content:"\25BA";font-size:125%;top:3%}.fc-icon-down-triangle:after{content:"\25BC";font-size:125%;top:2%}.fc-icon-x:after{content:"\000D7";font-size:200%;top:6%}.fc button{-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box;margin:0;height:2.1em;padding:0 .6em;font-size:1em;cursor:pointer}.fc button::-moz-focus-inner{margin:0;padding:0}.fc-state-default{border:1px solid;background-color:#f5f5f5;background-image:-moz-linear-gradient(top,#fff,#e6e6e6);background-image:-webkit-gradient(linear,0 0,0 100%,from(#fff),to(#e6e6e6));background-image:-webkit-linear-gradient(top,#fff,#e6e6e6);background-image:-o-linear-gradient(top,#fff,#e6e6e6);background-image:linear-gradient(to bottom,#fff,#e6e6e6);background-repeat:repeat-x;border-color:#e6e6e6 #e6e6e6 #bfbfbf;border-color:rgba(0,0,0,.1) rgba(0,0,0,.1) rgba(0,0,0,.25);color:#333;text-shadow:0 1px 1px rgba(255,255,255,.75);box-shadow:inset 0 1px 0 rgba(255,255,255,.2),0 1px 2px rgba(0,0,0,.05)}.fc-state-default.fc-corner-left{border-top-left-radius:4px;border-bottom-left-radius:4px}.fc-state-default.fc-corner-right{border-top-right-radius:4px;border-bottom-right-radius:4px}.fc button .fc-icon{position:relative;top:-.05em;margin:0 .2em;vertical-align:middle}.fc-state-active,.fc-state-disabled,.fc-state-down,.fc-state-hover{color:#333;background-color:#e6e6e6}.fc-state-hover{color:#333;text-decoration:none;background-position:0 -15px;-webkit-transition:background-position .1s linear;-moz-transition:background-position .1s linear;-o-transition:background-position .1s linear;transition:background-position .1s linear}.fc-state-active,.fc-state-down{background-color:#ccc;background-image:none;box-shadow:inset 0 2px 4px rgba(0,0,0,.15),0 1px 2px rgba(0,0,0,.05)}.fc-state-disabled{cursor:default;background-image:none;opacity:.65;filter:alpha(opacity=65);box-shadow:none}.fc-event.fc-draggable,.fc-event[href],.fc-popover .fc-header .fc-close{cursor:pointer}.fc .fc-button-group>*{float:left;margin:0 0 0 -1px}.fc .fc-button-group>:first-child{margin-left:0}.fc-popover{position:absolute;box-shadow:0 2px 6px rgba(0,0,0,.15)}.fc-popover .fc-header{padding:2px 4px}.fc-popover .fc-header .fc-title{margin:0 2px}.fc-ltr .fc-popover .fc-header .fc-title,.fc-rtl .fc-popover .fc-header .fc-close{float:left}.fc-ltr .fc-popover .fc-header .fc-close,.fc-rtl .fc-popover .fc-header .fc-title{float:right}.fc-unthemed .fc-popover{border-width:1px;border-style:solid}.fc-unthemed .fc-popover .fc-header .fc-close{font-size:.9em;margin-top:2px}.fc-popover>.ui-widget-header+.ui-widget-content{border-top:0}.fc-divider{border-style:solid;border-width:1px}hr.fc-divider{height:0;margin:0;padding:0 0 2px;border-width:1px 0}.fc-bg table,.fc-row .fc-bgevent-skeleton table,.fc-row .fc-highlight-skeleton table{height:100%}.fc-clear{clear:both}.fc-bg,.fc-bgevent-skeleton,.fc-helper-skeleton,.fc-highlight-skeleton{position:absolute;top:0;left:0;right:0}.fc table{width:100%;box-sizing:border-box;table-layout:fixed;border-collapse:collapse;border-spacing:0;font-size:1em}.fc td,.fc th{border-style:solid;border-width:1px;padding:0;vertical-align:top}.fc td.fc-today{border-style:double}.fc .fc-row{border-style:solid;border-width:0}.fc-row table{border-left:0 hidden transparent;border-right:0 hidden transparent;border-bottom:0 hidden transparent}.fc-row:first-child table{border-top:0 hidden transparent}.fc-row{position:relative}.fc-row .fc-bg{z-index:1}.fc-row .fc-bgevent-skeleton td,.fc-row .fc-highlight-skeleton td{border-color:transparent}.fc-row .fc-bgevent-skeleton{z-index:2}.fc-row .fc-highlight-skeleton{z-index:3}.fc-row .fc-content-skeleton{position:relative;z-index:4;padding-bottom:2px}.fc-row .fc-helper-skeleton{z-index:5}.fc-row .fc-content-skeleton td,.fc-row .fc-helper-skeleton td{background:0 0;border-color:transparent;border-bottom:0}.fc-row .fc-content-skeleton tbody td,.fc-row .fc-helper-skeleton tbody td{border-top:0}.fc-scroller{-webkit-overflow-scrolling:touch}.fc-row.fc-rigid,.fc-time-grid-event{overflow:hidden}.fc-scroller>.fc-day-grid,.fc-scroller>.fc-time-grid{position:relative;width:100%}.fc-event{position:relative;display:block;font-size:.85em;line-height:1.3;border-radius:3px;border:1px solid #3a87ad;background-color:#3a87ad;font-weight:400}.fc-event,.fc-event:hover,.ui-widget .fc-event{color:#fff;text-decoration:none}.fc-not-allowed,.fc-not-allowed .fc-event{cursor:not-allowed}.fc-event .fc-bg{z-index:1;background:#fff;opacity:.25;filter:alpha(opacity=25)}.fc-event .fc-content{position:relative;z-index:2}.fc-event .fc-resizer{position:absolute;z-index:4;display:none}.fc-event.fc-allow-mouse-resize .fc-resizer,.fc-event.fc-selected .fc-resizer{display:block}.fc-event.fc-selected .fc-resizer:before{content:"";position:absolute;z-index:9999;top:50%;left:50%;width:40px;height:40px;margin-left:-20px;margin-top:-20px}.fc-event.fc-selected{z-index:9999!important;box-shadow:0 2px 5px rgba(0,0,0,.2)}.fc-event.fc-selected.fc-dragging{box-shadow:0 2px 7px rgba(0,0,0,.3)}.fc-h-event.fc-selected:before{content:"";position:absolute;z-index:3;top:-10px;bottom:-10px;left:0;right:0}.fc-ltr .fc-h-event.fc-not-start,.fc-rtl .fc-h-event.fc-not-end{margin-left:0;border-left-width:0;padding-left:1px;border-top-left-radius:0;border-bottom-left-radius:0}.fc-ltr .fc-h-event.fc-not-end,.fc-rtl .fc-h-event.fc-not-start{margin-right:0;border-right-width:0;padding-right:1px;border-top-right-radius:0;border-bottom-right-radius:0}.fc-ltr .fc-h-event .fc-start-resizer,.fc-rtl .fc-h-event .fc-end-resizer{cursor:w-resize;left:-1px}.fc-ltr .fc-h-event .fc-end-resizer,.fc-rtl .fc-h-event .fc-start-resizer{cursor:e-resize;right:-1px}.fc-h-event.fc-allow-mouse-resize .fc-resizer{width:7px;top:-1px;bottom:-1px}.fc-h-event.fc-selected .fc-resizer{border-radius:4px;border-width:1px;width:6px;height:6px;border-style:solid;border-color:inherit;background:#fff;top:50%;margin-top:-4px}.fc-ltr .fc-h-event.fc-selected .fc-start-resizer,.fc-rtl .fc-h-event.fc-selected .fc-end-resizer{margin-left:-4px}.fc-ltr .fc-h-event.fc-selected .fc-end-resizer,.fc-rtl .fc-h-event.fc-selected .fc-start-resizer{margin-right:-4px}.fc-day-grid-event{margin:1px 2px 0;padding:0 1px}.fc-day-grid-event.fc-selected:after{content:"";position:absolute;z-index:1;top:-1px;right:-1px;bottom:-1px;left:-1px;background:#000;opacity:.25;filter:alpha(opacity=25)}.fc-day-grid-event .fc-content{white-space:nowrap;overflow:hidden}.fc-day-grid-event .fc-time{font-weight:700}.fc-ltr .fc-day-grid-event.fc-allow-mouse-resize .fc-start-resizer,.fc-rtl .fc-day-grid-event.fc-allow-mouse-resize .fc-end-resizer{margin-left:-2px}.fc-ltr .fc-day-grid-event.fc-allow-mouse-resize .fc-end-resizer,.fc-rtl .fc-day-grid-event.fc-allow-mouse-resize .fc-start-resizer{margin-right:-2px}a.fc-more{margin:1px 3px;font-size:.85em;cursor:pointer;text-decoration:none}a.fc-more:hover{text-decoration:underline}.fc-limited{display:none}.fc-day-grid .fc-row{z-index:1}.fc-more-popover{z-index:2;width:220px}.fc-more-popover .fc-event-container{padding:10px}.fc-now-indicator{position:absolute;border:0 solid red}.fc-unselectable{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-tap-highlight-color:transparent}.fc-toolbar{margin-bottom:1em}.fc-toolbar .fc-left{float:left}.fc-toolbar .fc-right{float:right}.fc-toolbar .fc-center{display:inline-block}.fc .fc-toolbar>*>*{float:left;margin-left:.75em}.fc .fc-toolbar>*>:first-child{margin-left:0}.fc-toolbar h2{margin:0}.fc-toolbar button{position:relative}.fc-toolbar .fc-state-hover,.fc-toolbar .ui-state-hover{z-index:2}.fc-toolbar .fc-state-down{z-index:3}.fc-toolbar .fc-state-active,.fc-toolbar .ui-state-active{z-index:4}.fc-toolbar button:focus{z-index:5}.fc-view-container *,.fc-view-container :after,.fc-view-container :before{-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box}.fc-view,.fc-view>table{position:relative;z-index:1}.fc-basicDay-view .fc-content-skeleton,.fc-basicWeek-view .fc-content-skeleton{padding-top:1px;padding-bottom:1em}.fc-basic-view .fc-body .fc-row{min-height:4em}.fc-row.fc-rigid .fc-content-skeleton{position:absolute;top:0;left:0;right:0}.fc-basic-view .fc-day-number,.fc-basic-view .fc-week-number{padding:0 2px}.fc-basic-view td.fc-day-number,.fc-basic-view td.fc-week-number span{padding-top:2px;padding-bottom:2px}.fc-basic-view .fc-week-number span{display:inline-block;min-width:1.25em}.fc-ltr .fc-basic-view .fc-day-number{text-align:right}.fc-rtl .fc-basic-view .fc-day-number{text-align:left}.fc-day-number.fc-other-month{opacity:.3;filter:alpha(opacity=30)}.fc-agenda-view .fc-day-grid{position:relative;z-index:2}.fc-agenda-view .fc-day-grid .fc-row{min-height:3em}.fc-agenda-view .fc-day-grid .fc-row .fc-content-skeleton{padding-top:1px;padding-bottom:1em}.fc .fc-axis{vertical-align:middle;padding:0 4px}.fc-ltr .fc-axis{text-align:right}.fc-rtl .fc-axis{text-align:left}.ui-widget td.fc-axis{font-weight:400}.fc-time-grid,.fc-time-grid-container{position:relative;z-index:1}.fc-time-grid{min-height:100%}.fc-time-grid table{border:0 hidden transparent}.fc-time-grid>.fc-bg{z-index:1}.fc-time-grid .fc-slats,.fc-time-grid>hr{position:relative;z-index:2}.fc-time-grid .fc-content-col{position:relative}.fc-time-grid .fc-content-skeleton{position:absolute;z-index:3;top:0;left:0;right:0}.fc-time-grid .fc-business-container{position:relative;z-index:1}.fc-time-grid .fc-bgevent-container{position:relative;z-index:2}.fc-time-grid .fc-highlight-container{z-index:3;position:relative}.fc-time-grid .fc-event-container{position:relative;z-index:4}.fc-time-grid .fc-now-indicator-line{z-index:5}.fc-time-grid .fc-helper-container{position:relative;z-index:6}.fc-time-grid .fc-slats td{height:1.5em;border-bottom:0}.fc-time-grid .fc-slats .fc-minor td{border-top-style:dotted}.fc-time-grid .fc-slats .ui-widget-content{background:0 0}.fc-time-grid .fc-highlight{position:absolute;left:0;right:0}.fc-ltr .fc-time-grid .fc-event-container{margin:0 2.5% 0 2px}.fc-rtl .fc-time-grid .fc-event-container{margin:0 2px 0 2.5%}.fc-time-grid .fc-bgevent,.fc-time-grid .fc-event{position:absolute;z-index:1}.fc-time-grid .fc-bgevent{left:0;right:0}.fc-v-event.fc-not-start{border-top-width:0;padding-top:1px;border-top-left-radius:0;border-top-right-radius:0}.fc-v-event.fc-not-end{border-bottom-width:0;padding-bottom:1px;border-bottom-left-radius:0;border-bottom-right-radius:0}.fc-time-grid-event.fc-selected{overflow:visible}.fc-time-grid-event.fc-selected .fc-bg{display:none}.fc-time-grid-event .fc-content{overflow:hidden}.fc-time-grid-event .fc-time,.fc-time-grid-event .fc-title{padding:0 1px}.fc-time-grid-event .fc-time{font-size:.85em}.fc-time-grid-event.fc-short .fc-time,.fc-time-grid-event.fc-short .fc-title{display:inline-block;vertical-align:top}.fc-time-grid-event.fc-short .fc-time span{display:none}.fc-time-grid-event.fc-short .fc-time:before{content:attr(data-start)}.fc-time-grid-event.fc-short .fc-time:after{content:"\000A0-\000A0"}.fc-time-grid-event.fc-short .fc-title{font-size:.85em;padding:0}.fc-time-grid-event.fc-allow-mouse-resize .fc-resizer{left:0;right:0;bottom:0;height:8px;overflow:hidden;line-height:8px;font-size:11px;font-family:monospace;text-align:center;cursor:s-resize}.fc-time-grid-event.fc-allow-mouse-resize .fc-resizer:after{content:"="}.fc-time-grid-event.fc-selected .fc-resizer{border-radius:5px;border-width:1px;width:8px;height:8px;border-style:solid;border-color:inherit;background:#fff;left:50%;margin-left:-5px;bottom:-5px}.fc-time-grid .fc-now-indicator-line{border-top-width:1px;left:0;right:0}.fc-time-grid .fc-now-indicator-arrow{margin-top:-5px}.fc-ltr .fc-time-grid .fc-now-indicator-arrow{left:0;border-width:5px 0 5px 6px;border-top-color:transparent;border-bottom-color:transparent}.fc-rtl .fc-time-grid .fc-now-indicator-arrow{right:0;border-width:5px 6px 5px 0;border-top-color:transparent;border-bottom-color:transparent} \ No newline at end of file + */.fc-bgevent,.fc-highlight{opacity:.3;filter:alpha(opacity=30)}.fc-icon,body .fc{font-size:1em}.fc-button-group,.fc-icon{display:inline-block}.fc-bg,.fc-row .fc-bgevent-skeleton,.fc-row .fc-highlight-skeleton{bottom:0}.fc-icon,.fc-unselectable{-khtml-user-select:none;-webkit-touch-callout:none}.fc .fc-axis,.fc button,.fc-time-grid-event .fc-time,.fc-time-grid-event.fc-short .fc-content{white-space:nowrap}.fc{direction:ltr;text-align:left}.fc-rtl{text-align:right}.fc th,.fc-basic-view .fc-week-number,.fc-icon,.fc-toolbar{text-align:center}.fc-unthemed .fc-content,.fc-unthemed .fc-divider,.fc-unthemed .fc-popover,.fc-unthemed .fc-row,.fc-unthemed tbody,.fc-unthemed td,.fc-unthemed th,.fc-unthemed thead{border-color:#ddd}.fc-unthemed .fc-popover{background-color:#fff}.fc-unthemed .fc-divider,.fc-unthemed .fc-popover .fc-header{background:#eee}.fc-unthemed .fc-popover .fc-header .fc-close{color:#666}.fc-unthemed .fc-today{background:#fcf8e3}.fc-highlight{background:#bce8f1}.fc-bgevent{background:#8fdf82}.fc-nonbusiness{background:#d7d7d7}.fc-icon{height:1em;line-height:1em;overflow:hidden;font-family:"Courier New",Courier,monospace;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.fc-icon:after{position:relative}.fc-icon-left-single-arrow:after{content:"\02039";font-weight:700;font-size:200%;top:-7%}.fc-icon-right-single-arrow:after{content:"\0203A";font-weight:700;font-size:200%;top:-7%}.fc-icon-left-double-arrow:after{content:"\000AB";font-size:160%;top:-7%}.fc-icon-right-double-arrow:after{content:"\000BB";font-size:160%;top:-7%}.fc-icon-left-triangle:after{content:"\25C4";font-size:125%;top:3%}.fc-icon-right-triangle:after{content:"\25BA";font-size:125%;top:3%}.fc-icon-down-triangle:after{content:"\25BC";font-size:125%;top:2%}.fc-icon-x:after{content:"\000D7";font-size:200%;top:6%}.fc button{-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box;margin:0;height:2.1em;padding:0 .6em;font-size:1em;cursor:pointer}.fc button::-moz-focus-inner{margin:0;padding:0}.fc-state-default{border:1px solid;background-color:#f5f5f5;background-image:-moz-linear-gradient(top,#fff,#e6e6e6);background-image:-webkit-gradient(linear,0 0,0 100%,from(#fff),to(#e6e6e6));background-image:-webkit-linear-gradient(top,#fff,#e6e6e6);background-image:-o-linear-gradient(top,#fff,#e6e6e6);background-image:linear-gradient(to bottom,#fff,#e6e6e6);background-repeat:repeat-x;border-color:#e6e6e6 #e6e6e6 #bfbfbf;border-color:rgba(0,0,0,.1) rgba(0,0,0,.1) rgba(0,0,0,.25);color:#333;text-shadow:0 1px 1px rgba(255,255,255,.75);box-shadow:inset 0 1px 0 rgba(255,255,255,.2),0 1px 2px rgba(0,0,0,.05)}.fc-state-default.fc-corner-left{border-top-left-radius:4px;border-bottom-left-radius:4px}.fc-state-default.fc-corner-right{border-top-right-radius:4px;border-bottom-right-radius:4px}.fc button .fc-icon{position:relative;top:-.05em;margin:0 .2em;vertical-align:middle}.fc-state-active,.fc-state-disabled,.fc-state-down,.fc-state-hover{color:#333;background-color:#e6e6e6}.fc-state-hover{color:#333;text-decoration:none;background-position:0 -15px;-webkit-transition:background-position .1s linear;-moz-transition:background-position .1s linear;-o-transition:background-position .1s linear;transition:background-position .1s linear}.fc-state-active,.fc-state-down{background-color:#ccc;background-image:none;box-shadow:inset 0 2px 4px rgba(0,0,0,.15),0 1px 2px rgba(0,0,0,.05)}.fc-state-disabled{cursor:default;background-image:none;opacity:.65;filter:alpha(opacity=65);box-shadow:none}.fc-event.fc-draggable,.fc-event[href],.fc-popover .fc-header .fc-close{cursor:pointer}.fc .fc-button-group>*{float:left;margin:0 0 0 -1px}.fc .fc-button-group>:first-child{margin-left:0}.fc-popover{position:absolute;box-shadow:0 2px 6px rgba(0,0,0,.15)}.fc-popover .fc-header{padding:2px 4px}.fc-popover .fc-header .fc-title{margin:0 2px}.fc-ltr .fc-popover .fc-header .fc-title,.fc-rtl .fc-popover .fc-header .fc-close{float:left}.fc-ltr .fc-popover .fc-header .fc-close,.fc-rtl .fc-popover .fc-header .fc-title{float:right}.fc-unthemed .fc-popover{border-width:1px;border-style:solid}.fc-unthemed .fc-popover .fc-header .fc-close{font-size:.9em;margin-top:2px}.fc-popover>.ui-widget-header+.ui-widget-content{border-top:0}.fc-divider{border-style:solid;border-width:1px}hr.fc-divider{height:0;margin:0;padding:0 0 2px;border-width:1px 0}.fc-bg table,.fc-row .fc-bgevent-skeleton table,.fc-row .fc-highlight-skeleton table{height:100%}.fc-clear{clear:both}.fc-bg,.fc-bgevent-skeleton,.fc-helper-skeleton,.fc-highlight-skeleton{position:absolute;top:0;left:0;right:0}.fc table{width:100%;box-sizing:border-box;table-layout:fixed;border-collapse:collapse;border-spacing:0;font-size:1em}.fc td,.fc th{border-style:solid;border-width:1px;padding:0;vertical-align:top}.fc td.fc-today{border-style:double}.fc .fc-row{border-style:solid;border-width:0}.fc-row table{border-left:0 hidden transparent;border-right:0 hidden transparent;border-bottom:0 hidden transparent}.fc-row:first-child table{border-top:0 hidden transparent}.fc-row{position:relative}.fc-row .fc-bg{z-index:1}.fc-row .fc-bgevent-skeleton td,.fc-row .fc-highlight-skeleton td{border-color:transparent}.fc-row .fc-bgevent-skeleton{z-index:2}.fc-row .fc-highlight-skeleton{z-index:3}.fc-row .fc-content-skeleton{position:relative;z-index:4;padding-bottom:2px}.fc-row .fc-helper-skeleton{z-index:5}.fc-row .fc-content-skeleton td,.fc-row .fc-helper-skeleton td{background:0 0;border-color:transparent;border-bottom:0}.fc-row .fc-content-skeleton tbody td,.fc-row .fc-helper-skeleton tbody td{border-top:0}.fc-scroller{-webkit-overflow-scrolling:touch}.fc-row.fc-rigid,.fc-time-grid-event{overflow:hidden}.fc-scroller>.fc-day-grid,.fc-scroller>.fc-time-grid{position:relative;width:100%}.fc-event{position:relative;display:block;font-size:.85em;line-height:1.3;border-radius:3px;border:1px solid #3a87ad;background-color:#3a87ad;font-weight:400}.fc-event,.fc-event:hover,.ui-widget .fc-event{color:#fff;text-decoration:none}.fc-not-allowed,.fc-not-allowed .fc-event{cursor:not-allowed}.fc-event .fc-bg{z-index:1;background:#fff;opacity:.25;filter:alpha(opacity=25)}.fc-event .fc-content{position:relative;z-index:2}.fc-event .fc-resizer{position:absolute;z-index:4;display:none}.fc-event.fc-allow-mouse-resize .fc-resizer,.fc-event.fc-selected .fc-resizer{display:block}.fc-event.fc-selected .fc-resizer:before{content:"";position:absolute;z-index:9999;top:50%;left:50%;width:40px;height:40px;margin-left:-20px;margin-top:-20px}.fc-event.fc-selected{z-index:9999!important;box-shadow:0 2px 5px rgba(0,0,0,.2)}.fc-event.fc-selected.fc-dragging{box-shadow:0 2px 7px rgba(0,0,0,.3)}.fc-h-event.fc-selected:before{content:"";position:absolute;z-index:3;top:-10px;bottom:-10px;left:0;right:0}.fc-ltr .fc-h-event.fc-not-start,.fc-rtl .fc-h-event.fc-not-end{margin-left:0;border-left-width:0;padding-left:1px;border-top-left-radius:0;border-bottom-left-radius:0}.fc-ltr .fc-h-event.fc-not-end,.fc-rtl .fc-h-event.fc-not-start{margin-right:0;border-right-width:0;padding-right:1px;border-top-right-radius:0;border-bottom-right-radius:0}.fc-ltr .fc-h-event .fc-start-resizer,.fc-rtl .fc-h-event .fc-end-resizer{cursor:w-resize;left:-1px}.fc-ltr .fc-h-event .fc-end-resizer,.fc-rtl .fc-h-event .fc-start-resizer{cursor:e-resize;right:-1px}.fc-h-event.fc-allow-mouse-resize .fc-resizer{width:7px;top:-1px;bottom:-1px}.fc-h-event.fc-selected .fc-resizer{border-radius:4px;border-width:1px;width:6px;height:6px;border-style:solid;border-color:inherit;background:#fff;top:50%;margin-top:-4px}.fc-ltr .fc-h-event.fc-selected .fc-start-resizer,.fc-rtl .fc-h-event.fc-selected .fc-end-resizer{margin-left:-4px}.fc-ltr .fc-h-event.fc-selected .fc-end-resizer,.fc-rtl .fc-h-event.fc-selected .fc-start-resizer{margin-right:-4px}.fc-day-grid-event{margin:1px 2px 0;padding:0 1px}.fc-day-grid-event.fc-selected:after{content:"";position:absolute;z-index:1;top:-1px;right:-1px;bottom:-1px;left:-1px;background:#000;opacity:.25;filter:alpha(opacity=25)}.fc-day-grid-event .fc-content{white-space:nowrap;overflow:hidden}.fc-day-grid-event .fc-time{font-weight:700}.fc-ltr .fc-day-grid-event.fc-allow-mouse-resize .fc-start-resizer,.fc-rtl .fc-day-grid-event.fc-allow-mouse-resize .fc-end-resizer{margin-left:-2px}.fc-ltr .fc-day-grid-event.fc-allow-mouse-resize .fc-end-resizer,.fc-rtl .fc-day-grid-event.fc-allow-mouse-resize .fc-start-resizer{margin-right:-2px}a.fc-more{margin:1px 3px;font-size:.85em;cursor:pointer;text-decoration:none}a.fc-more:hover{text-decoration:underline}.fc-limited{display:none}.fc-day-grid .fc-row{z-index:1}.fc-more-popover{z-index:2;width:220px}.fc-more-popover .fc-event-container{padding:10px}.fc-now-indicator{position:absolute;border:0 solid red}.fc-unselectable{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-tap-highlight-color:transparent}.fc-toolbar{margin-bottom:1em}.fc-toolbar .fc-left{float:left}.fc-toolbar .fc-right{float:right}.fc-toolbar .fc-center{display:inline-block}.fc .fc-toolbar>*>*{float:left;margin-left:.75em}.fc .fc-toolbar>*>:first-child{margin-left:0}.fc-toolbar h2{margin:0}.fc-toolbar button{position:relative}.fc-toolbar .fc-state-hover,.fc-toolbar .ui-state-hover{z-index:2}.fc-toolbar .fc-state-down{z-index:3}.fc-toolbar .fc-state-active,.fc-toolbar .ui-state-active{z-index:4}.fc-toolbar button:focus{z-index:5}.fc-view-container *,.fc-view-container :after,.fc-view-container :before{-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box}.fc-view,.fc-view>table{position:relative;z-index:1}.fc-basicDay-view .fc-content-skeleton,.fc-basicWeek-view .fc-content-skeleton{padding-top:1px;padding-bottom:1em}.fc-basic-view .fc-body .fc-row{min-height:4em}.fc-row.fc-rigid .fc-content-skeleton{position:absolute;top:0;left:0;right:0}.fc-basic-view .fc-day-number,.fc-basic-view .fc-week-number{padding:0 2px}.fc-basic-view td.fc-day-number,.fc-basic-view td.fc-week-number span{padding-top:2px;padding-bottom:2px}.fc-basic-view .fc-week-number span{display:inline-block;min-width:1.25em}.fc-ltr .fc-basic-view .fc-day-number{text-align:right}.fc-rtl .fc-basic-view .fc-day-number{text-align:left}.fc-day-number.fc-other-month{opacity:.3;filter:alpha(opacity=30)}.fc-agenda-view .fc-day-grid{position:relative;z-index:2}.fc-agenda-view .fc-day-grid .fc-row{min-height:3em}.fc-agenda-view .fc-day-grid .fc-row .fc-content-skeleton{padding-top:1px;padding-bottom:1em}.fc .fc-axis{vertical-align:middle;padding:0 4px}.fc-ltr .fc-axis{text-align:right}.fc-rtl .fc-axis{text-align:left}.ui-widget td.fc-axis{font-weight:400}.fc-time-grid,.fc-time-grid-container{position:relative;z-index:1}.fc-time-grid{min-height:100%}.fc-time-grid table{border:0 hidden transparent}.fc-time-grid>.fc-bg{z-index:1}.fc-time-grid .fc-slats,.fc-time-grid>hr{position:relative;z-index:2}.fc-time-grid .fc-content-col{position:relative}.fc-time-grid .fc-content-skeleton{position:absolute;z-index:3;top:0;left:0;right:0}.fc-time-grid .fc-business-container{position:relative;z-index:1}.fc-time-grid .fc-bgevent-container{position:relative;z-index:2}.fc-time-grid .fc-highlight-container{z-index:3;position:relative}.fc-time-grid .fc-event-container{position:relative;z-index:4}.fc-time-grid .fc-now-indicator-line{z-index:5}.fc-time-grid .fc-helper-container{position:relative;z-index:6}.fc-time-grid .fc-slats td{height:1.5em;border-bottom:0}.fc-time-grid .fc-slats .fc-minor td{border-top-style:dotted}.fc-time-grid .fc-slats .ui-widget-content{background:0 0}.fc-time-grid .fc-highlight{position:absolute;left:0;right:0}.fc-ltr .fc-time-grid .fc-event-container{margin:0 2.5% 0 2px}.fc-rtl .fc-time-grid .fc-event-container{margin:0 2px 0 2.5%}.fc-time-grid .fc-bgevent,.fc-time-grid .fc-event{position:absolute;z-index:1}.fc-time-grid .fc-bgevent{left:0;right:0}.fc-v-event.fc-not-start{border-top-width:0;padding-top:1px;border-top-left-radius:0;border-top-right-radius:0}.fc-v-event.fc-not-end{border-bottom-width:0;padding-bottom:1px;border-bottom-left-radius:0;border-bottom-right-radius:0}.fc-time-grid-event.fc-selected{overflow:visible}.fc-time-grid-event.fc-selected .fc-bg{display:none}.fc-time-grid-event .fc-content{overflow:hidden}.fc-time-grid-event .fc-time,.fc-time-grid-event .fc-title{padding:0 1px}.fc-time-grid-event .fc-time{font-size:.85em}.fc-time-grid-event.fc-short .fc-time,.fc-time-grid-event.fc-short .fc-title{display:inline-block;vertical-align:top}.fc-time-grid-event.fc-short .fc-time span{display:none}.fc-time-grid-event.fc-short .fc-time:before{content:attr(data-start)}.fc-time-grid-event.fc-short .fc-time:after{content:"\000A0-\000A0"}.fc-time-grid-event.fc-short .fc-title{font-size:.85em;padding:0}.fc-time-grid-event.fc-allow-mouse-resize .fc-resizer{left:0;right:0;bottom:0;height:8px;overflow:hidden;line-height:8px;font-size:11px;font-family:monospace;text-align:center;cursor:s-resize}.fc-time-grid-event.fc-allow-mouse-resize .fc-resizer:after{content:"="}.fc-time-grid-event.fc-selected .fc-resizer{border-radius:5px;border-width:1px;width:8px;height:8px;border-style:solid;border-color:inherit;background:#fff;left:50%;margin-left:-5px;bottom:-5px}.fc-time-grid .fc-now-indicator-line{border-top-width:1px;left:0;right:0}.fc-time-grid .fc-now-indicator-arrow{margin-top:-5px}.fc-ltr .fc-time-grid .fc-now-indicator-arrow{left:0;border-width:5px 0 5px 6px;border-top-color:transparent;border-bottom-color:transparent}.fc-rtl .fc-time-grid .fc-now-indicator-arrow{right:0;border-width:5px 6px 5px 0;border-top-color:transparent;border-bottom-color:transparent} + +/*! + * FullCalendar Scheduler v1.3.2 + * Docs & License: http://fullcalendar.io/scheduler/ + * (c) 2016 Adam Shaw + */.fc-resource-area .fc-cell-content,.fc-timeline .fc-cell-text{padding-left:4px;padding-right:4px}.fc-resource-area th>div,.fc-scroller-canvas,.fc-scroller-canvas>.fc-content,.fc-scroller-clip{position:relative}.fc-scroller-clip,.fc-timeline .fc-cell-content,tr.fc-collapsed>td,tr.fc-transitioning>td{overflow:hidden}.fc-no-scrollbars{background:rgba(255,255,255,0)}.fc-timeline .fc-body .fc-divider.ui-widget-header,.fc-timeline .fc-body .ui-widget-content{background-image:none}.fc-no-scrollbars::-webkit-scrollbar{width:0;height:0}.fc-scroller-canvas{box-sizing:border-box;min-height:100%}.fc-scroller-canvas>.fc-bg{z-index:1}.fc-scroller-canvas>.fc-content{z-index:2;border-style:solid;border-width:0}.ui-widget .fc-scroller-canvas>.fc-content{border-color:transparent}.fc-scroller-canvas.fc-gutter-left>.fc-content{border-left-width:1px;margin-left:-1px}.fc-scroller-canvas.fc-gutter-right>.fc-content{border-right-width:1px;margin-right:-1px}.fc-scroller-canvas.fc-gutter-top>.fc-content{border-top-width:1px;margin-top:-1px}.fc-scroller-canvas.fc-gutter-bottom>.fc-content{border-bottom-width:1px;margin-bottom:-1px}.fc-rtl .fc-timeline{direction:rtl}.fc-timeline .fc-divider{width:3px;border-style:double}.fc-timeline .fc-head>tr>.fc-divider{border-bottom:0}.fc-timeline .fc-body>tr>.fc-divider{border-top:0}.fc-scrolled .fc-head .fc-scroller{z-index:2}.fc-timeline.fc-scrolled .fc-head .fc-scroller{box-shadow:0 3px 4px rgba(0,0,0,.075)}.fc-timeline .fc-body .fc-scroller{z-index:1}.fc-timeline .fc-scroller-canvas>div>div>table,.fc-timeline .fc-scroller-canvas>div>table{border-style:hidden}.fc-timeline td,.fc-timeline th{white-space:nowrap}.fc-timeline .fc-col-resizer{cursor:col-resize}.fc-timeline th{vertical-align:middle}.fc-timeline .fc-head .fc-cell-content{padding-top:3px;padding-bottom:3px}.fc-resource-area{width:30%}.fc-resource-area col{width:40%;min-width:70px}.fc-resource-area col.fc-main-col{width:60%}.fc-flat .fc-expander-space{display:none}.fc-ltr .fc-resource-area tr>*{text-align:left}.fc-rtl .fc-resource-area tr>*{text-align:right}.fc-resource-area .fc-super th{text-align:center}.fc-resource-area th .fc-cell-content{position:relative;z-index:1}.fc-resource-area th .fc-col-resizer,.fc-time-area .fc-bgevent,.fc-time-area .fc-highlight,.fc-time-area .fc-slats{position:absolute;top:0;bottom:0}.fc-resource-area th .fc-col-resizer{z-index:2;width:5px}.fc-ltr .fc-resource-area th .fc-col-resizer{right:-3px}.fc-rtl .fc-resource-area th .fc-col-resizer{left:-3px}tr.fc-transitioning>td>div{transition:margin-top .2s}tr.fc-collapsed>td>div{margin-top:-10px}.fc-body .fc-resource-area .fc-cell-content{padding-top:8px;padding-bottom:8px}.fc-no-overlap .fc-body .fc-resource-area .fc-cell-content{padding-top:5px;padding-bottom:5px}.fc-resource-area .fc-icon{width:1em;font-size:.9em;vertical-align:middle;margin-top:-1%}.fc-resource-area .fc-expander{cursor:pointer;color:#666}.fc-time-area col{min-width:2.2em}.fc-ltr .fc-time-area .fc-chrono th{text-align:left}.fc-rtl .fc-time-area .fc-chrono th{text-align:right}.fc-time-area .fc-slats{z-index:1;left:0;right:0}.fc-time-area .fc-slats table{height:100%}.fc-time-area .fc-slats .fc-minor{border-style:dotted}.fc-time-area .fc-slats td{border-width:0 1px}.fc-ltr .fc-time-area .fc-slats td{border-right-width:0}.fc-rtl .fc-time-area .fc-slats td{border-left-width:0}.fc-time-area .fc-bgevent-container,.fc-time-area .fc-highlight-container{position:absolute;z-index:2;top:0;bottom:0;width:0}.fc-ltr .fc-time-area .fc-bgevent-container,.fc-ltr .fc-time-area .fc-helper-container,.fc-ltr .fc-time-area .fc-highlight-container{left:0}.fc-rtl .fc-time-area .fc-bgevent-container,.fc-rtl .fc-time-area .fc-helper-container,.fc-rtl .fc-time-area .fc-highlight-container{right:0}.fc-time-area .fc-rows{position:relative;z-index:3}.fc-time-area .fc-rows .ui-widget-content{background:0 0}.fc-time-area .fc-rows td>div{position:relative}.fc-time-area .fc-rows .fc-bgevent-container,.fc-time-area .fc-rows .fc-highlight-container{z-index:1}.fc-time-area .fc-event-container{position:relative;z-index:2;width:0}.fc-time-area .fc-helper-container{position:absolute;z-index:3;top:0}.fc-time-area .fc-event-container{padding-bottom:8px;top:-1px}.fc-time-area tr:first-child .fc-event-container{top:0}.fc-no-overlap .fc-time-area .fc-event-container{padding-bottom:0;top:0}.fc-timeline .fc-now-indicator{z-index:3;top:0}.fc-time-area .fc-now-indicator-arrow{margin:0 -6px;border-width:6px 5px 0;border-left-color:transparent;border-right-color:transparent}.fc-time-area .fc-now-indicator-line{margin:0 -1px;bottom:0;border-left-width:1px}.fc-timeline-event{position:absolute;border-radius:0;padding:2px 0;margin-bottom:1px}.fc-no-overlap .fc-timeline-event{padding:5px 0;margin-bottom:0}.fc-ltr .fc-timeline-event{margin-right:1px}.fc-rtl .fc-timeline-event{margin-left:1px}.fc-timeline-event .fc-content{padding:0 1px;white-space:nowrap;overflow:hidden}.fc-timeline-event .fc-time{font-weight:700;padding:0 1px}.fc-rtl .fc-timeline-event .fc-time{display:inline-block}.fc-timeline-event .fc-title{padding:0 1px}.fc-timeline-event.fc-selected .fc-bg{display:none}.fc-ltr .fc-timeline-event .fc-title{padding-left:10px;margin-left:-8px}.fc-rtl .fc-timeline-event .fc-title{padding-right:10px;margin-right:-8px}.fc-ltr .fc-timeline-event.fc-not-start .fc-title{margin-left:-2px}.fc-rtl .fc-timeline-event.fc-not-start .fc-title{margin-right:-2px}.fc-body .fc-time-area .fc-following,.fc-timeline-event.fc-not-start .fc-title{position:relative}.fc-body .fc-time-area .fc-following:before,.fc-timeline-event.fc-not-start .fc-title:before{content:"";position:absolute;top:50%;margin-top:-5px;border:5px solid #000;border-top-color:transparent;border-bottom-color:transparent;opacity:.5}.fc-ltr .fc-body .fc-time-area .fc-following:before,.fc-ltr .fc-timeline-event.fc-not-start .fc-title:before{border-left:0;left:2px}.fc-rtl .fc-body .fc-time-area .fc-following:before,.fc-rtl .fc-timeline-event.fc-not-start .fc-title:before{border-right:0;right:2px}.fc-license-message{position:absolute;z-index:99999;bottom:1px;left:1px;background:#eee;border-color:#ddd;border-style:solid;border-width:1px 1px 0 0;padding:2px 4px;font-size:12px;border-top-right-radius:3px} \ No newline at end of file diff --git a/test/Widgets/Calendar.mpk b/test/Widgets/Calendar.mpk index fae7c4c9753b76641c87411f8e3f270127346d85..7deb96b82c5b6435c22d0e37dcf560483d30bd12 100644 GIT binary patch delta 64397 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

U}6DC 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 delta 134964 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

KApZ19f4?=k$BWpi2Seai2Gbku&aL7E6UHQ} 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 z zlE~3BDy2dUw})N^jaTH+d%Pq4R)`P+UY`ge+yE&K_2`ORCulq@xt&51Njm=`ddHJ3 z`VM=8v}|?fKwFSc!b3^Xnct+BFVT~5OlKxZWj^|__D@pu51q&xeKiDUj!HU{HIhhZ z1vV;)$OfvB)I$M=4Gg9lkx@hdV*n)wn(<+IZxVO|$94-^nR-EEg=8D-E_0y`BXWEM zgade0!?YE~7b3zUXqF%63+1A3YycH95y#xf%=W}*?G%1#eXEA$h;xNfwK>lZd~Vu+%a3u z=8Xl$0Nx?TRx7T-9r06L&NgR?TIY1#%Z7rYEDN-5jYW;sl2kHlh;XRG6Dk;Mh;#_V z=F~NFPF_IiLVi{4hM1LWo|+7sQx2V`;tkv~$I6GNrMJ1VuH$oRzhThr&sA$(V(pj6 zwB8I@riQL^iJn%svvH;zbU=l9A>{2xD{te1B&!1)qk-44 zWwAq)onP8W0mwkpyZZOpX4aYQsuYEj7eC{VJ=csD{c`iLV^Z4oi}4lOECC$UA~4y1 z4m37ODzk6-9e8oKE0v%9JbP-=E2!tW8IBUvCk9!xQ~RllB-7zQn|R==08c~Q_6spj zuz2eln(UNCpS<}>fP@ZSO3mZ&SH4GGToWfoq^RGPYaFT^N29I02t4jEQxv&he$CbI;2^D;!W7JYoPHk zq63KuBZZMjkr37-V$_5-sUGI^A>)Xo{X~k7FufmQEQNL{6+10l7c>?iMP%(GQap!| zg@^&rAF@yhI&zvpV;-VKmO3JYUm$PBFNa%FxQ4NGzOGk@+3~^2CBv-wt67n;B+An9 z#Ke7Y0Vp++3+>2w4OQr|z)fgLF&N52tUDcamt>)Li+uG?0pm)#y2uQu?k_}Z z5j18aODGz~WQ!bfZZCIA99K)bls7ZOm1NE~{@mtTX@ZI-V^vLMA_B*kdC`T5;P>pa`f-KB2uOg+b{{4!D0X{?=ca_ zyTF(s^9&%i96vbZMhYI0l75g&V~Y?oWN1hI8+nM7*n=ZT6Ybc0Kq>=K6||bSxx&Ev+ zDrQT8Yt84>*Bhd~-ycD;VH47>psNPnnm{==Y(lOUguY}<1-bi0l#wm!@As^G8Q~}p zsng?*p+P@alxcJ=ZuX~(9vaqhB`XqFPny3QXBzdNpr01#ez!S!p>N-d@CbN+HysH@ zX70*Mx)K!O6m#e1l%xqKg8^h3Ey73_6k4JX{Id~~E>^O_&uuXqVp>G*oeVtu*yHUC z{pL+{cb;RkUU$NJzwK*%W-RAh*cq>0<>|P|#c!_Ztj+5-I&N5NvBG21@~J>$IG2K^ zN_dyS|J%F3^|fqEYMC0&fpJh9&f2h0!#OawRB;Z>`B69rX6mTnzZ&AeXjYCJj(kXC zYg_pF4ZqtOWrDTU61HPCclJgPLto=n*6v&`Z(hKBX9wPP?-{F%1C6~M?435vS?$GJ z?c}+9YO>}~ThZlC~{tauVu ziHM$}4_KiSsuOq_2|FPq%ypN584BEegeL-va^^XN5L{2k3nT>NFng?}CLU)(vURC@Esj0uAPn`Nzs-T2ZN7Yv6v6X-9p`1?dNw zJY)`c_=s+2gEt4622i$(_H={aW`AqHZJ>TJT>*9ST>OUijeo+JoQ_N@?+<7Q`R!MOSzJlU2+`gMtzJ4sSSI6?V`a(NGoQ~xNpgRR zCCGg*DUMs(MD1q&&Ee`zFmuS^DvP0AI+!=sp{)JUwO1$p0Rbz7ha9e4rEUbjR>*fP z?@t*2vnUd@T@Wz>Ru)ukWX6x$Np0I3xrgg|(+0+yqzp3(`mz%*&lByhw?OJ4lt64Tt1!E>%PrlwyUO6mr;o{b(1SVW7KP2$Rrr{tqidht6Se48pUPR>EJ$Y4 z7wxZWa_wt;b_!*f?^-v^ENEXKUJ~YOWd-i(#gAS zqzB5Asam+>)yz%Izc^lbQEBf4p%yKR+dgXNIaK?q- zE>}qV>l4bmI!8GsU5!6)aB;94RGd%ru z*GmoB6`VY5{Nuy{WqkZbQ>Rq?qn%}&yyeT)YH8#=9H1Cb)B{4*sLI34+TQ8VqhH#; zvq=w-%=&&yGm0>h{nz~($qs(ZQ((t2aZ$3@mC7pSFt01{{^}*O^Q-N%f{u?1<&_2! zysmCEEMqm~opKCumKd*8^vWIgy1H`rq5qlW+g9Nom3GAnU7TTFS3g%VC&Oi@7j&hF zYyWn-+OmcjmAn)N9X&JXQb4^|#tC=3y0$DP)=r?pKY0FAb$3WjDDHOk=-ez9eRT!f zeQ{<SY_KWO zcM45$930qI_jcGwmRvb(BoDK_a`j@4u)Wf&D~>wuDeV*@G^fLPU3t@Q+bedMQqXkVe@-l^YyG{J40&JOUxt5c zh5&kBjX`a%niZMD6)&}v;FS5zDos8+I1019f(S?#T{vwng&`1@Wqzko>2SKw5RO2` zE-PH&Z2&dn?UYS|@6$hl&|+3I5^-d^T+h#mR#6EXwkls2gKppVp-Zu&H+w6x{8gj0 z++{82!{+l#UoDyd(I}J&JJUP;{XYyXt2DI)@3)Bs6#~^GEIkUczbvrkDc_NQ%DpIL zQ@Cj%O5%t{=TASVm?yj&>7|{#=petvF8PSRx)1%t2M}}!mLAL;=vy;*$oWj&)%`Yc zH5fZG3fZ~kj^((_$u=qCU4B{o@NB`A)$GRPl{cIM+eh=@mT4HyO%Mc+EzW5)|Rs+2d{C+Z7pkoJn4CvKiI3xSozo|NU zK6B2B2=Sc0O{)sys&HD*X`iiKX>MCv`OsmTiE6yHRyBBQ8lZ2Qh)X#NZ-oFR*FxcD@Q_wy<(Q+jeokGV>5+c zw9CvJi#P3+<`KUiWpTCw^>IBlzE4Nv^p*5&>{>)P_sl}S_q$x81z{7eZPC%h=@G}m zY|9oOoXIC0YN+1mm!xt4kl*=5e{$%?D5FgBLK|W2m>Zs37v9GM7fo#@WeY|z2Hp)r7 zgd$qeiw;=s*eF5=%w6m%Dh=jEJ%#5W@dg@!KQ^g2g!+gVY|GDhgws@H!VY|PrcUPV z-y6B3Puo~1@~l>IrJs#h1sYd*R2a8j!f0>xBUpN?t#DEciQst zjcN_+gW$ff4RvDrFm{f)_(>B(;9;|G@5D4g=4dalKAsgwr44{kRfZ1CCW*6vMg+?b zc{!;gb;fur$B@pYBBR{rJwV$vL{o|6tW%J$2)2%Tue-3cBY6ezh=fz`=5ej2$j?*V zc5_!R-1jjw5v8frAyQ)Qd8;-ucx7EzErs0eTEX`yR`V2&Tvp<%jf-qb`?r{Ec`oiT zjJ6AB%D3T+#K8ydUazlFozmyGGP{oMHo!mPMM*86y&ELC^#KZDVhZWY!GUmCg_R{& zTo?3%pyLT>#?8NJg@mB-_^T2iVV#neqm+ITCAGiShy{u+-$+9H{Z^XB`rglE6r~AFLy*9b4h-lMmt`+87kzVgqY~o@QF-UTia@h zDC@;r-Yy_&+mMMhoK=khKbGcj6E43IOJW{|7$JO*G9tmo+1V=#^xI8(?IOa@X`lCr zM6Ev{&(?(T7;W57fmAK$#b3m2bT+$9dY$%^cSh~ol3bbRL*h1T-`N^pTcBeV)^^uW z$XQDt=hI}XEhqDGk_wVc-r@|fl zLo*ozwV8-K9^*C5_ceC9@UrFiC#WR(-TfPnCyWxW{w0ZGm-IclHL!vP*AKGo8Sw~$ zL5Z6G#^d>@1DnSHlzh%l@LLTB-XI=HUAePsxA_$XE!$AafO}@;0O?%wXf9I_Iq{O?+!5^z03y6M?U^_r{8$1 z?rXC}P7ZOpi*$4IBp0K}4%}ho4}B$)M9kq8=FOP=bGh@WEh;q+9$jz7x}Uvi@xfM~ zOBuGgkHpS>tcGrjkJ(d!`vpccoH8PSk_=n>S4A9!k7FO~l{oE~b>&sVqO2}MT)^T) zeLCy5PN`jffb-~oisyeu6>$u(Mlt~R)=lnTYM0Ix1lU(`CIlI^$8Y2t46G9=O#|Ia#PK6PVkGQosJfTyCkH) zV5`TG3EpXO_Quw6(Y?I&3pFJHq|!h^c~L-#hVAknE%UFOmHZXOe50BF*yq%oe|5w; z3)-AP^EiyNGJbLQ=S0Cz$MB%Qu8iOTj9~|0s{bL#tzk??zo{6Y?BnE-*(-!&9;(`5 zjvJSej)mylX2(Y9wC;|{w%L8S@lj9L05D!4Y6i+5vkei88CM6olZ0(5w+GKFjqz2& zr?z>rdA3g67XIG1bMyW8UOa$LZA5?fLxpX&+?ri-J(nL(=iyVkby`#ZY|oSS+0Q>s zN;&ifDn7xfJtohfj5g|9t5Z=n({8?d(#D~EWh|W1&?RD%A8edBpzKD+1uA}{IQVJ0 zjpJ^|#Ai}WdCp}`d=V8((A-nS{$Q6J;i~gFs9zoZeq$)8_>C2|lu7`~8~JBQwT41@ ztj$cfWOH@f4bxK1@P|YCWEZV<-s)5~s8o4-;TcE#VceKZG=6;J)#$bSh#KXNj$%PJ z{)9{8*RRXoJhzMQ$bFNc+f|3E-=L8LT~a{lfquXLCVxXd`l8Gf8tIt)o0&pOz1Abw zGS8tp#3I2VktNoTI$A!?@Ylc`g zzr}G#1Qw5JUu6>PzFLL&+`Jih`+Xn24Ad7#=P86~J68S^mKo9-wE}&OKK9`eK=~&B z^IwE)1qL9bS)W<_UE_2s}5>vU~61AcwOka> z!yB5t+_wE@;{|T!=hUu*CZK|5AGgEJL>5rQIl62@oB|q8Gq}L&9{tweC2~k{CYJ3d z#-!*5I1g*H9DwIDxHSEZvO)@+Fv+Y$QwNG@fBEvvyePA~+=O9X_$k0JktJ_`LIDnV{MwBIk@g3G~fFGT}lzQV6F@OnTwuC+GMH8*{j~PHux2$WSVD^B!^Tq5a2sRi@YG z$>(!D&=(Gg;E?D#B$NYN$}yiZ0yL6`(o+ChnNgr`7BUvojX_9w1bp6>3}E~cv-uyg zI0S$O=PF|y84{@RiwEiqXFT*d4wLBpJ8OjmuV4+sSSv(42DL3af=zA};I$KpCF$Jo zD_>3As(I3_a!kgh%+&|sMIp$cVPDO(4uv*Fn*iGndy$1=Cd_7(LT5V_`y(iI9*l1 zorDqO{^nXn!YeQm3lZD+BYML{->3$>tQZpjst~dqrN%lc&Nf@LUaDkX=sK2jn7g}ZSN9RNOsK(YdEgE`@lk6 zybKe=;f@pgrZHxQb#}{{!|`UPP(s?!Y9aq_!OR@tFK!8yGGn?YWKO|ZJWvdWjdqQu zKq^h7ktl|;K@J=z88<(G4^1$k}#K#x9n}W56iQyn42|V=C zKx)4T59x||&?EhHg-wwK&onXpV=%6QbM`=CZG1f6Hv8bg_)a;6P@J1mMibYb*s|TG z@S4G$^lF;ItE7|%2gHl%Ye@4L*%UH81RJt}ey_{_eT0g>zOhjk{NAO56h)TuZ z@OyZNH-&`F2o6-T?65^(90>jhwJ~ljVe5j{UZy8PgoyCM2$0ezK$!{a)-4#sFLMDR;+YzA9`0&gzSb@f5x3UO=D{ER6DrZ%vG z|7#CVcK!e8VG|+}1A!xP=fciNx%zbMyUDiU#!D)`P(T^=}sVTwfIz| z;;O`;ftjOQ+C#^;1_gR|v5FzjvX*d}=f^r7IdibMzTQR@rXm&5-hxRKdx|>yX~(Aa zrv@(bLa)DE<g&`U&Ru}N-B9K_IaP)KXU*U>3H6ft3Lh+Blok9$8u zVBYo|{pxbUO&qeb>!6ZXmyNr!HjPj1n^%<-L9h>?VU*oyVFIaCE9#)*QTdh7=jHX(3Djmj+17aIW&0iBN!BHqoo#0fBDuLcI4EKh_Om=7)c zBLjJN0cAWJTD8;@qi=K#lp{v!C_-Qi_)l5K!ChVUxHMhLXrMiYy&WOK4|rKbs6ya8 zmVF=Fqf7w*C5uZ!Q}D-#_=I3uh+H46A^|hOe@wzxP$NC?HcV~>+!iLl>CquKO;Rc~R+ycR)?hN| zQ)QTu(!8MSH8Yw`%m|}Q-&AyR5wp4Y>?dY^1xNExe@{aC0TVvLw(2QBs)inb5E2(^ zpfz942)M~JG(k>1%=Vief?Ys}kJ&(DkmUx}|3jAm@6L$x5mHpWwg7epDHeuL9Y#oT zGsg6NH^?$ad&ClOrwPk}$v+{-fE0XI$SFj#iE(OZF)WIh82ruo-GPuYiP%|v^wy{| zs!Luv#%kqO-e&zAi#q9<0bL)laVW{x?E?!V`KEnf{e|TF>I2IN%J0#q4x{*bd+$6{ zA}eiOow_YJY$0>~Fp95s#>cE$*F?vZPnTWEt?YedM9_ypF(2ze!V2q0XfHXYe3n| zRL3d4Yp%(x#%j+4?JY6}pj4osC{Sya!709nZ$KvCu?86VP;NqZ)ZPY)JiDdSe_=<~ zfK}1YCd0%%E3;io@7_G^ZlYBNS<9xuLYC|Ik)v-l1BBQ*Hr2VFsc@(ivwIf4YwsI2(Q$JJ2whst6;AvB2=5 z%n-%*;^2dxm-Ia@$D)E)%u7jW{zdU+v2}yAigI=KIu_~o%pIMoi4~gc{+JFLwlfux z?1k!=TLsciu_|#lKUsNh8^(~_^AIm{i0gazu?&&xyRc1L;X}tx`=WY%o0`Q%H-~Y3 zXLQQ^jq8hkX?x%?ifJjR?~=JmK`Fl}Pi07y-w4rD;(Jb{*zA#rn;ImQZj2r9*M4Cr zBZFt_?YFefw?A_GR9;AWe)Av7FY?sXa8}`dA-h6#Z^tl%wF6MTGMt9feOEk}LB+@D z4#5AZxROBlh0FlFg#Cg#1$35(sDQ<5nSLne_j>oQ0X_EBuK|5MAjPM`{318AMOEwn zRQKiaRBiqL&T)=oIGimq6d6K^L==j0497eb4Vny5sSHVlGM5UOEhUA_WT-flF^xAF zn&)U%3e9uBwfEMIy}S46`~04JpZomr>801}?6uZjdkvrA{ds?aXKsLn+#taqwxG+E z6uf9OK3jA{O!b7imHTBMBI(D^RF*DFloQw!;VTb%p|et6vT+Xn7^I zmPI-IV~k4MlgB*Ly>WXeNQjkZha9L4U0mijRQ)p8ddE%)j-LS+;tE zWVqZ}e0nQ^kPPB+zG$x~P0(WhYTJStQT}BqU4yd$hWeem?tJ@6aMv;mj?w1xVNIXS z&$+)JE<>o_YcAs0DMkkn^((@yUMvnH;1@vK67k{CU!|que+d0$)VPXMX;hlsudq!a zu5aC5_h~d3<*$63d&T{!A+EZN-DlldGX9ozS?@KMjgKFBV02TgsqtsTc&+*@cjv0C ze0R4P)~1mh(zY?k-s^AixA-Nlakd6dqgd5En?FQ31rt^<&aG4IT1rxofc2ggJG&m* z+dRiPx6GRz?E)@3nKZN>m>`vxd=lr}GT1Q5-`Y>uYS(Sr@e=js6X>Xhz>MAevcl2S zBzC3XOwlOOHz#n;t$Fz=3UZSxt-?!edYs2wpZLzX1&hC9#AE#TB411RtTIj1jz|3a zw$Xl0JoeF$x9$3PL5n8kNy_zsajrP=*!*>CRzH1R%SjBi2-FHsT7eUfX&28n>C-eb z+B0|5I{lSS z83y$9D|_e@rQTy&$-C^~BF~7|I1Sqan}hz&?-NXqHB3CLJ1u7wj&FVL;BnXa-bc$k z+hvYLdg`!X%}JP?h0?Gg<F=Lsv4+R>@Q@U1H$KOJoj!RxLASvokprKYZP@sd({EFj_hZ+FVpiQQ0}l zGdMKd?%4Rvx=W_!%HU7LR-DQxQBN~ZlbmgPaI9W0k;6}6E|{%;f2>h-cV=Sw)d?B+ zQ+vXW-EQAIXmVK9dT^b)Ma3`^8T4`(Nw!7#a&J>XS3(XM(X=c9m00Rx9aS4HLbEar_c%DXEue_Sz;BJp3aqDo?7~SH$AoDnD9rm1R|Clh$fJzIh(c zJ}|^ONt;h(+)Q+7-uf#2s%??3+2r|`Ukt4e&9AppcHQAxZr^ihub+!YHNY4*gI@?~ z2fW&1R=LFf-Xfl`qTd-`Hz9Wx9~dWnv(Th=#vJ1@&u2w~h#UN)S*Gm|Hv3Mn$xchC zx!!w!1;7b6X$yu?iIOH7qnRYlF-|4=(>WHecnCkz5{)z-CLDWGs$Cnq-X4RuOi!cw`vn zr_+v*mi93A-d~(!l)d+-E7%Nb%}a33V$$RiIg5XBhB40KKb&C=*x^#(e_)i&uT3y! z9k0_hruZFdw2zG9iD4;xyMyn&j)BZ_u7aaY>dvaNisKVb3^6u8C{3fCIDW+@T~KJ* zc3oI113QTGxO)wj&v3S=@lvsk)+ng?&e#l3tDjLv}*aDw|FD0 zvllcsPe?N<^AYaaXxwA>$3rUZR?dB-GEaE4T%P1Hxcr2=&=(VPD5M$xJl$N7kgs0^p& zwt6n|@TppW>2AZZ9(%f_F)vRz#A4Ije$a_0g|8^i-JxNXGO$7DPTHyU!|23WZ{!u#=m%xGqJYe|q~2vSty42Lo86u)dtq4a1xA@p^T0Xe3$_GK zc~?+lly>f5!esxB`$P`;eNOtaSzo5GcR6~_h&&@>kKcmhzBZgxX$Z90X}?0g$4RhhzHSv>)o8d~e&&7L=UeB|w&u*&$kPeD^8v|j8Xrg^9_?N9_^eY8FxRO==y8ujQ`H4PxHiz z4QvZpG09gt)Uxqto_(vqYq4R)2Byr&FmB5$G)nc#9I%-GsA-t{x1j5q=$7Mj+x(sT zuhcLC9^u6X1Pr`RMK1L;Zz#AutNz-q^kM#9-?U_}GxOH4a~t$$Y_v-i8BuJ2<^@`g z&=irY9tO;ccB)mG>E-y~RTedPrG=ZjRs9Q>FSgGr%<6Bd$(c>6w4hc|uV(0U-ZnNo zGwjKQAS|J0Cql^%(RjFLn`PC@))NhVMtet8TA;1?gOU>Zo*f}`cX4tz{USLL z>WS~74{x&hUQvR!5+`{u+p^*+e@m-%`ktgNb-%9&?gKt(Xm;?oofB<$ew;U3-9yo7 z7|FvLj*d*hVINLe|EVBeuatWHf%Ze4!J+G8jWR+#)z>{(5jl+HVa<8QBDJ;YW)Y4z z0>l|wHTY&56uQ2kD*v=~ZRakZ-FIcqgCUX!+A5snVfLQm-k(~0tqV2f)jF2CTjNj7 zuK<&E@`6p{R=hgfbBL-2Fp`IRE%C02{^>?#tHZRS-@doQe;XMUQhBec*R+wdREe^| zs2cnrd0?Cni8CnwU{tm;>iFYj6Gx*D7@?P_H|XjXv1aj2ZlkXXv8$>I`?Pc4%Va>{ zc$hrbT04H8s?m5+Xk4-I%`{4^RsF-69vdTf z1mJI#xTAi+tae$jdb^52JNS1=9%yU-nIsQ1pMOd6K=b`Gk_VdKuaG>@ z{QowR2im%ykUY=={t}W0+WLPQ$pbC$pG@*V+wea}@<7}8UnY5=LErXYMe;xk`d=k^ zpauWKNgik+{}Ut+w9S7p$-_t9bQubrPF3fjsvj1mDN;qYHm}heVi}7KR{`t+QB@6& z?dsK*8}&_{SLg=oul6_DU=y%l?s9z}+d$uWj{aJ6rcBje=xs4&t;5RIhQh8OV?fk^ zTDk;W84xu=%$5x24|_QVs1Ay9sJq4h|3T4ID(}sj*P?V+1~ra{`iU9`Iny$k)Okbw zC%sq)WSvH-YS?MpxUii#ZeA{?p5|t&e02j&Z5C__m;(vKI3_;sbIrXrth0CWTsg&l zqv7G1V7=2Q1L_rhaL8$t3F4S1`59rRLIMgqCz}9(`F|~*elAK4` zfc_G3X_4)p1&zLU{nj1pT5sxxg>$vntz2um*4;eVi(_uS!OeY+_ri6{H?lpnIKC_9 zdM;e+5ai>jgug(vO z7nBuHRzg_?#U9FPC~Kgsh2jHcBa{tLAOjZ-rrOd1psa)955*hG94NL>?4Uq`3z{QO z7!PeZ{KEr^I}|r4u24|i+EOS>pe%;62#O1og-{kinGaP|HKq-Y%1_jn*p_N0afKmyi z3d$iUhoKySQVpdB3KvQ(lsYI!p&Wx!52XQ0Ba|j6%}`pP9EZ{h(gx)`ly)c`P&%P>LAe0sB9u!|E49<&%6%vgczBFysN3%ml*dq>KyIDN(hwAaGAo!d6S{c znsKj|Z(P4m`zmlr#3yX8J>_6uq?40_K7 zD=NjMkt%~dE9Y>pFWK)h_T@dXjyN<@Zv;9k#m7T>3|IwXppPmBCe}-hq0)APh`Ex| z$X|mxx5MxUuxy|`ED9R-P@s}PCrQGoVd(`#VB0VxJxshFNrg!OuKkPj0aY5D;!MzU z68f0`xT-D*p@t=?{CkN6v*h4sj--)P5zs0@nKG@D6W<1Xde- z3zIYm2)8ygeS(dSB?}~l&?h5*K}HFrb$yNYu#X#Ih4@oQ1h4?8 zJIMXc+o1JdPh-0c!n_(TzgDo`9snZ1ao}$K+p~!K(|5AP4^+<|t#yBd|8^c%%hrerDc;37?BbjPKX8 zm3t}5Q>VezRLm1JqJ_UVHycf(7s9Z@C4fB^U0>WBYCw*3%a!1sz60_a9A18gy*0xtSpBVLw>>i?Gn1Ta;5 zWOWcCz#ngcNUeZg!xmK9L2i!`Q;hN_H9|-!09ZK;V!FW48-A~UvYbjQ2W%l^!GE7( z;(JOk1Mcezz-FM!tcb2gt`YOMGI5~wa{RERUkTW}$eh27iv(T5SOsBP6<~j3<@}!+ zQ!Y}bqQ(%vWq|1qawTo3`_YH%e*bu48H7kIgK|dYq8srrV83HErF+tue^xV2M{wk?r5!@|rWSgwRReZE3od_H5DcC>M@O7H#H0%R)F38cpoB`6)L-X{ zk|1VPP?g~O)^J4!7>uabCibUQ0f~8~ zcvV1BMrs$Y=u}D_a5&AUiu?m;-hLE&vw*AlC~!Q%+WsG+!y{*r!cCKf9uLR3j?Juf z6jDk!o^4M|3`LJy8daH?Tse#c2xGBY3mb+73}@4INZFa_Ze0R-ns-R;BIi&3lwuH7 zTcM2s>vYbA)6&3otYta<1&oPD(Aj9@Iv!yqL1w&vpWBfOxgGtnZQBG|wCRd}Gjk<5 z*9mF}d(d}l<~o)^YE7!pCY)n411oQP1tF4VprPbVR9XwD+Qb;m`fu=p8iUSi$eHz> zJ9RM?RR(7E-0>5>I9CP+gggcO#bLo;vTlpk z2mcERmZLGUY4I4;d42kq38&Yn;Dpnkm2tvpUgdv}aC#-s$QH3h=l%@W(T}C|tArOg zr8fC4Kp`sP1V#ba_}PDh1Dtf;W55*g9~TB}_qV@`-aG{%DFP?~3xEVH*zBDHU5|w( zb3q`1zho9O~S}n#J`iV!1rqV&QXqoaR?Lo68s+tS=?YZ%g}BH`0b?8 z7zzTFFP^`hkL737@enh-4qbjQflG!iPnzZbGYiYW@8m19;T7Kj+&mZtKVPO~n)?4E z3k&1|o6;;|3%ltAjy9~>KVPt9F8+Uueuc!v|8H?Ybp2Ia5EuTdTo4!k6I>9N{vIxf z%l`~6h%49;@DJjGxcX1zg1Gj#b3t7H?{Gof_-}GS-2AU|LEQQ;azWhwM{+^j`5)qf zxckrLf`H}!{v{Vg&!2KZ-1|i?2nb;LtGOT^{EQ3Y;a|rE@#r7N1@ZVF$_4S{f1C@V z_rJ~s@$~QDf_U~n%mvZ+kLQAT{y)G4@#3%Mf}lhJwm97hv0eFQ@!&Hjt9s`PU*d$~ zc<^*J$u=QKVdYr;ZhV)nMRG@N-+QgSqQjEhmcB7+o~dqVp3Oglr}C&lDu_HU)PXGf z&3GGg(g(9-XMZ=N&#_-{KC=&z;_=_8Mw}+$_vu1YjP%kwg!ZDAd_T~Vl@?=dy>{j4 z>2C8z4dL7QYV2>gBZG6I)<;;@)-2ueblyceD*!C+gzcNXe-XPNRLvxTcID8WI9QJl zIt9dmeV0%u;_53bH%8`@?Vibb0TkPb9^BhqLXcSNY;>kejgz2t^m~W2cNauwqpj;v zX#=22fv${nDn7P!?y9$l=Gj)WV#atw&~+1*jmxs+(*n~j3Hc)0xzlfK%-m^nIBmTB zeqF;2_ykNz5DP)R*}h$9%{8-5&|}CMxqOSjlNY@%!)X&RKfhr6M;q(ZWjz}%P!=WQ z$%{IpRxK}Sd&1etso!}B41NH2uLw1u(=do9%Js_Y*?in?&(6|bHYTTI1(w9M4%{jj zWsgXVwyaN%k+n$uOr(5_#B!Q~7UaQvCj zY!EI@6$GpYLcz#Pp{6JA7EiP;4VvI$J^encP>Qlfd|N7Pn%fj&k{K@0In_X*kE{I< zeqxrx5i3f@>o898e%|dFlc9g@g-|SVlX2o@sLG&e=JR7gxtXdhpk=F=7+CdKNE_|- zHDH&DX@a(Xp=m&~mNo-<#-p_d(dxF^WBtgpG3fqgyu-5s%UV|67q*Rw3fO=Dwa8>F zPnrAqiI5isxo~T$>)wt97P}3W4OV9D$;O{pztO+mdfY^tBMOc}mkeb~uzX}7_e^LD z+U*-S3cj(xHJ_;fuDueP2oQ6M0#NRQZ>+v{ThY=whD6Fu)W`*d5Q z{Xyr2g3}gc*>NqOql;Q~+mnG?TfUkmJaH9Pc_-n8|M=CU?tUMgBCFidlNU$yXg$T# zu*3R=uxz`xU@({!g6K~TtFq7uu!sna8b@)-dJfbE;L0cv=~s1C`(k-ip?PWKo=HRO zg&5t$x{Kz_ne#gA_pohcT9cJGgW^H>fcdh0uUiFn*%yX~Z2MLd6O4}_rp#xcb^05N zri0?;d#{)`0>xKCA!B%G?}n(UPqu046~A+|ETrGgdtbYK0XY0g$QESp{W&J4c}ineC%-j zYy0egK7rV~>#@%@RNs&@C)nV+6V-0_3(4+#Q7&|x>_t~i1lDN&_#B9?Wf+1R+M+5T zT!+sRnNx8}(lzO(ZDa3R%eXV<@i-Zd!R7mWi6VYB`?XhPvc1};fsd|`rMjZHj{7mY zlD+M9duVy8PRiwwZYg7i#R_Ur|&_R*%l4Ib%K{QzP$McWaN zSNr`m61bMTBG+yTe^OP3FVGfw$#d(&R$A?nmW_M5L2NSMoeFh_8Y{rP#* zYjKw9nL46dkoBLqr6=Z|F-myvS^90eA4J1k994iAT6_(8yrs{q;tIQe%hiRcAaok+ z+`)M(f4)beNzQ}~r=+T~hPWu_@^d2x`##&%-ibI3=?-s#x6?%nq5t>`pxl()C9k7T zsH7qMak`uC({Q77FXf`>mEj;~j<6mW*oBfJiwN*HoX@pCmZDjmze%8_0A-g4Pb~`^; z(Os)oPpEu2XDn>?n<*Yd_z3jOjz&vZ)j9<_f1G3=0x&4M7F)w3|Gt{>)+H+b@Bs>-aM5{D<_|@b)0Wcq_N#NKg5OABc}cAYVl11KB57 z`YeWdsI>e=Z{zf`?A$xE=YX8!%%N&T=CgI}6e}|=t6cBCX?f#y;YS%nakLj2XbGSz zk5dqXe=AuIeQWadK(5!9_*8N$=gCQnOuM^b@^=DHVfFg{6k+qy?%DMt<6oM@ZixIc z+Zo7X2pg6?W4Xwvq%g}}I-8b`Y7_un^#X=K^Ab}Anc*0*^!eOPHmRm<{+1Te$gnDk z3sS!pXorMZ)h+wtJ~imHFJ5X*_-YaDNua6uHu=x}HjzoE@ltD7?cHl{a;LH5OBX!a zSWmOTORc@)+&pVlC}UnPds}|<)m`(^Qfo7)bUK$EC?!cDA)dw_I~2Og$iSjd_HlrA z)#zt<;h5!TXJ0A|Xg7(hjT~EYui0;Sr9^pBr9{H@3LI~+#L}h2#X-0?T?#KrNYvPe z8r0k_AweO*xCnYVsQNTi*^ouh<3WqC*j6Avi;k*nbOx8bR%!xT&nR~Us4HHR6FW~q z*gomxk=4a9yyquA6D7WhKN`rnimAH4;%&m?~9FO zz~nrjb3{h!{gCEQB!a8iiEN~dBf|7}uiXEvH7njOp@bsEl!xVGnfiDgt{#`wkx@%E zOwwNO`7&+g#2x6iR-#bp0$jGIR49d9`H*OXV3iM91fzxP=p%xrFTlcw%Di87EoEpo@&o*zC=H#xL<*hMpsl$&wJgnTIg0?Q9L{({p zbVgK_hJBgIqr{AXSQt5lRZ0<0z32AQCu2BAw;ZkL4RhE7;A^3!_2@!e_7bUs@V$sg zRFV#emM&!xlt#SHq-LOmENk@%vq+?K|hLMa(U;%=Az z)%Wjg_GhOoSGFvggCB%>fjbUvDfM9Ito2{G(f-qX6gQ>>5s{Z@ssQOh{8{lA`=_@Y z5ancDQg6Eybr)297^MdRKLR2MEo5TPvIAVx#D+Q3*SYe49(oiOH$?Rhx-d{Er;kID zZn`QRKO15kQTlfCf=XE{6mWc;f+#oDz2G=+x8%-`n-*UZc?lm)?qJA4d-Xw+lvP{n z4xjE*8fsGh3ky~H=pumaD8+%t#Ox7!h@>H7`Ds|8Ka&3V9fiFd`1uROk-^tw#ThMw zNYJsTV5L;S+FNuHsDVx=C-;Vi>T>&oaN%qpl5It z+>j1Zq9|;QjsUi$)O`}}o@B*g3z%T=O+okN!eMxOxv4zcN6ae0W(7G@V2Mtw)E>#k zg<1ltJ{CLC?V6eH53?mNKCz zkWws2<|mdyNHkT^h4tqN6(pk+enHeGq>F)wlLE2|Q>PP>a)@Rp_6971i3&@tOB!;K zSyE3aWm(I9c3=moe)M<$mNtu4Hw6qYMQutm7Acs4w*JF^7t$Pu%H2&N`z*+R!_ z1G5OGDX3x#*rCIb01=mI8lZ9>Q-owpp~G*YV3iKx5+0c+MKGK2dfM6F7$PJy>&FF) zS39KAC4tszSXs2vNkSBKzu{XaM=WJXFm(XiQ$Pw*co*93yx)}wCqc05H^WoHeKUJa<8Bj1LwlZ-n`;8 z;Cg*jAi35d$&|xt2NKLaz&;K;Fp}jTgJh-mZdO{>Xq>-r{@P`{tO;l}ut4;SNP~zS zbn8FJBqZ5kST6*d4K1%e)XRzEYuD6O9=18uKYdky(~d^G@}VQC@*&Y^9X3}ca7<&S z5pMFUM3(|~FJM&zNiGQVUf??TGbdBzrV|R8b~B%;`5ewPiDWg|x?S%0v5Htry1ub3 zRv6d-;kV}xj6ROnKTZ@CK)r{=Hz-~X7>53OPg!@~2#F0;O*I=!XTsv@7 zW6|-*0;GX96&~e>N3=3;f3&8~{#f(u==OQ9F3}-hKUzKTi%?k)Lw>haREVIv<*k_m zXvIHhoubLZFpa}#L<*Z9G@NwuTYG%F z$<}`V5Y6U($dERd;f2h|cz0d5^p$zSrz2nPZrTAOkQoT%&$J1$`BZ({dXMw$y?S4> z#{gI?v9cyroVSls4McY%k|iDlP&h)=8aU!0|4h%99HE z>!eJ<)il`kU&KE0k-9@0C^bmU;B}uu1$#5Zr9p6m)HLuk0}iF3K?<#_L-$N^beaJM zM$y$l-;qSg0rh*}FE%wv?d0+`OTkDT{GAtf)^Vxh6oyY!f9q0tb8c4)l?~PX zQpPw?pDo@x8dkQD8F9YBXI6k&r=+G)R&v*$k{S)I?HQCz;Chs*%AIjW>IF>Pqpt)l zy(02l^WUV7QGomdnjjZBA|(k6nefm-OAbW}%&L*90IDb8Xg<}zk*`7jn#Gkm4ve7t z6i8LVqAbnz;+f!i9z_kg_8ervg7N#T0b3i^JvyXd+zsBB`6u+pq?>8B!FuV@jkR z!PXwo)&hrA{)yb(c~Y*}v9uPrES0=Y{VWSE6-cqE7P3IHP|AX^iJM19&bcaUZ=SFI zP@?dYkKrF~;>XDN_ygOWIs5#A7!D~Dpr7|1P5<{zoG@kQt0tamvt0cL&vqrJPryhoj!`_ZXFr?%QB`BziTziR1Qn-;)ULFsi)W zXWbcfP!HS0ist3Ln>N^X*=0~Wo!3@)oE_4MlwoKFCV0WQgN%t~lImc9R{{YQ6--@3 zz_V@^&$dC+y_GlA3=SM!gjPe9<3$g`Man#MU$nBL#)yTXvpI6_y|QbjQEoiTO4rz4 z#7*_$D#uxG(~lU{H7vY8wN2^FpOMnsHSFK{aHFRoXtNJB>W;Yv|?&m$z-^Bu;Y~yM2-XEI8v$ z*Ts+f15XYKT#!%aB=e1CYwocN!5!m)3YzUK=1WU(+#^u0IOz%DijyO<(5%sHOi()a z*<$w>pT~OI%K>|>@OX4f`2&TEwDCyr>>cmtzdK~HKdbx2GcDQWglfN}JNvhFvb(|q zSKG(m-B(uPc|r#F;U|w#$r=+TWnD8fvGLq01x#FE>M_)})dlUSv3?1qV zwC{DmEk<-T2p1C%2M!I)EhP2C=2pPnjky;sW0y%}&N=@U=K7%ONkd(}JaVVVqDnL8 zAV)hd5LHj)u=61RC~QVJBt>P+Azzz-WFgC_H=Xw)?Z?RgR8e7VKA2(@ntp{{Gi8mw zc0Z&@DwGHV$eU3ofqW>^PExwod6amvsg731Zgq8zwl0O+fe%-@ytU` zkZ9dj0HD%!41K-zz&})Y&ySMS(ApZQR3_h9nk{DRVG*9p)Z4 zEi#Wg7PxlYp@8rodL?Ec2Z9`FL{46dsA7H`r%n4%oNQZVGL^NeZU^cX9#S!L(`o5z z1I#V6lFavo%{S;m>uz@p(bKGD>h4TA`N%Hr$XoH~fKXm^>6sz#wnn?qOOq`sY)|)` zm+!fUDy0~A3kQ9*4Z!Uo!va;<7m*ZhgJSuvpiers)e{!+1lZeRZX#GVcr%-Bo5^n* zZ(JAhYA^3qygjJ4KP1@^{&gScT*%*SaZIjA!Kp%&iF?Q|-Cc0gM^@1^=a{O())W~@ z^xi#)j%6cg(W9>dnj4wFk!q|<`ExZ>Yv zIjA*pTvnL|P&meP=DKDf&9KzHE>F{lwk|$r&r{9tx6Wo=lnHC>wgjjli9CI~UU*rQ zh+S^@yNYGf29NNa<6eCJ;k#{zEcf^pNovF@#{y^!pGEr(;`U@Ce6V#rLilgGy~%;~ zwL6U>u5R^?Dac{qt#6;c;L^S`@9eYA@6CL7soDf@{XpuN#I?d}O(G_Cym}-0pq=~GG?QJj&3(<%uUWFgd@UqSn$pK!OP(c-H;ex?Hmq!mX)zwixP53QW9@nq z^91MVS07x7-ixk8MRXQ6!>A`hr;=Pu88bGV&)*wov9nqM#E1N; zyW-wDEi!SjuRQTwS#sH&Z``DZd@59B68{VjJ&b42yXDLbUv19OgVyKu#G;FFKj|CW z!y0AYC6>O>a@jR}syxJ~hiN@gZhpQ$I#Qaq9;Pd{?43(Yz8(AY&r#x5+?tL*R%G@e_pGg61t z8aTfZ+@3a;1eN6V4$l+k>$|3Ekvv%2pI|MQg1cX1%Ex#3^F*7~TULl`4vZV-ite_P zjfIX3azrZlOun_$+a`+7PbVnNXYtU+;6we54U^ewk)LcMN2#kBu8ipV z{r>r*AcxIUsxIY2hRLCpahqlsP0B*s!mQ$G(9OiF-NbJXyKN#3PH9SQw@2hh&YvU2ooT!qi9iMTJ7 zi+IwH{3O7)PpmQHLyU(-f#4n^W^*CTa7F`sOTM}9Tqyt1ILZCa@fTO%SKa}y1z|Nf+4?*yN8EGL(^5sJBPP~|$||Qnag$fV2f?rW zNPo2Q7~4A6$^-Kfln1z?FIfF(-sn$=Wl}84B3Ukt<~5U)#I2vju&@@ydFVTNJkylM zpGn?oovR;Ot}UA7fRoFRLiKzV;R|G6CR&EmZH+~~TpPOKsES!LW_Q)I3qS1Bcd&ci zhF&9Rq?*fz(xlO2xjlKpGM|>uU=tyH zso1OPeZp`g0=z2sjF^&5&#BRij!T&5NhoPAril8XyI2Pre)Kp$PacoqAUGbC>H5aE zR$MesZSg!hsVY|nZTBY(Grfy0%s&}eZ(awk_7|Pp%ZCrD^X%4W4fppZ`z}uoNmth6 z;DZ7vmkj!b@r6Bmh2eQMjYm`*{`Yqmm`mHy!#8#2aLOkd3@p|ii)rix#0$Oo?Uwa# zXIX%$4vnwwG9ZeXjCkSs;2ttJA=NZJUGMei<$A@KZT+W+7s1~&rgya%veRX(5-%Rl zlfgModBdQp3n-lCTYxzEkF9(EWfUhpoE{|fILZavlYmvqr-pn0 z?b=?~=W%wNq{aj<3qFi(MRDK68-cxkx+d{QwJTlUYrq%YHFjt_GR3?vojqf{Pr<2m z)JJPOd^`5Gde1$lu!OyhHBrs6X_Yd*9mTvZML3CST9n$Xa}(nc(D|_)hrx@G>QxEz zE`T8WMjzjM%#cq*8!r^x`?|T%&n_yYE6}88p*nhI8Bys8+=x2*Sh(;6m`9Kg(>nUZ zr)gX6n0Qd16GZuf@0KUoyNdg(t8KS$dEu*=Z%#!)NoTNoJ`reLg{8h-=Lo1H)3=|y zlE+tOm$re|{DPdm4j4>DI4m>MotdM)SnuW_zPetL$I$0W3TnGJ zxeZkArgK>D1G*mG5fC(s*>Y6&LibZJSS0)eT_{N)Nsxa7MkvE-Yjm0Vddgh8n1bhY zmr;TE&6;QrQ3cAv?QcSt>e{5Po<$4FcpHxDoDviiVzvbvYBKO=)AsFV=>d?YMvv#zh|TLMqu;aJKG!BKcuwl8k8!m)G_Wj9Vwe9S zGn?eX=eJeAKJ!O!@)UG5sURnT&z0*ineGM~BLW#?kF0BzQQ??yYZMG6?VV%s#?0($ zHJ-*lH`>)L|5D?SWd({eJc-R=8h2nKeLRJly9F4fLZ+E1TR>te>k2}0NBt-}L~>$D zr?c7-q7w)OfhxdbJRL;n@kb&g&rva8%?IIQ>HL71$nqt5e;h9gIs#-IeFj4C7?lI% zB-kCvy@Mg#N&cX$WL7XbX#lXD_?$@o8a%Ur;N*D&)Z<_eB(DtY!2!6$v)mAp8|Pd+ ze1PB?(M4y#2kkrqxK-0+5RyN|B!Sfc9FEaM5u&33eRLXdv4Gro1n)#65VC}Qk^BtU z1O1!$HXQ*1+4fa$@^ezD$;?FoChdAoJDXnfbNL`;^2ZA zgh`W}18`J9=ry#*DTq)bljLI1GZ#4nj860Ovxqi5Y-A@wvj3}%-~dS$I`&(VHLqbT z(lL%`VE+KH!vSW3!8Vw-L9)~vO+<`Ar6nH%Iwwnu07ZTgUy?`Vk#I zKs0z!;Qt(Sjbs6KHO&AanaLgu5g3QMD5%XM8oMar5<)bLt9wLXng!9A#c|;T;};g9 zIX_wq?Ry`P;fwjlB1B^qZ-ijnzTuwBW5O3Bnxy!TN#^T|0_G(6RkOihpr9_WD`Xx5rsfnQ z;AhW20U?;9L-{X6)0I0q2knqxV`3n8Y-8n+HWtB9eGBvsFwcPQIvRs)9AdkLWKCA@ zWp|=I}BbYg2BQ{npxTPbw6CoK$Rr{ItTv`S*gMyIMF|33rNp-W| z!#sm7lLIMLFQ)_BOlB}b(tofQBI-)qz*OcY3PMzQ@Q+4Pk3c#z9PK6#v@GVcCn`Jm zLqxrZE0)NNq#y)s=L-H~f?`w#W+yY-#ee8Fu&;bvzZq7Km7o;8#W`q53h?a|=6Eo5 z5*?=7#WAmuXA+h>6$g)W1j7;HbaGqbne#9Wpa3tZ_tUwYN}NkrP>)A$g!bYh!&CQ2 z=d?{@Nx-FTb`xAc&MF~8E@wMa`j@9%U?&saXauzqojgtSL%`a-ntU!~T{I$=83r7z z_$LDOiGsI&b@C6X3bvCJ%ikwHKpJ*fgb}v<;ummG6RZSsef+{eR7ud6`~|Q|t)$7H zsw@asAp2)iy$Sin8EzUUxBy)TrNG9E zB?YF)3D%RR8PiUuFW?U&FZ5igKbq^Eq7Wr~0Wl zeBqz1{aU!Brq2StNrSRkH||`cd#=lpuPCm4lvn zeDDqvgKM1Ru=$ZhO!V+@1DJyF`Xc&f@Pm=$$8r0OAqI*?1Tm$#0=UW2?GU0HWLOF{ z$!{XXFW7+){Tp}+HPJ!BO&5Rz6aVh+fghssyUPbujh2dKkvv3GM8!axkf07g=JH7c zSsI)OlH-=WSug=1IeBN&;joClA@n^G5RxA$XSERQhELFzO0NQv3_*W{5F|T~KS&C# zwPcPKOS6MpgJj`icOuCeK0<+mBABX!=y%yF%|kzgXPlAj+sVA}A(CN=bwDy=v0|PL zp9Sg>qVb7;eUhO%{;R+nxY7;-$!`K%Nj^pVA(H=*q9QE@mb{0(kmAYMun6I21hjq- z=s<{pVzlv%RQeH|u#^yAK8jcHwErYf1vJ&@LZm=CJ~UF$9V_G6_8Jb2=rzOFFf8L4 zf{@&7qD<-0EFy-){)IrbP*p!%rAn6YA2%S>FJQp?K8C4Kvk$2YIgS|vrJRR zyt8q!HG_faKfs&KPUuvZK{i^)O>Lf^zev<~1XP8!HA}l>P;rY*om&3qz3rNyOA*F( zFr><1=SO-@7E^7D&VcB|B%Ad(QYGlkw;3KRn0`A^GnAXyYJekE9=fE8dY61KtJ3sj zB)Tf+;Bd2Jg~xYoK4;4=J2uJKaN`>(9B#Izdu3Vf^X2TiJL75TVu5xj+-xaa5j8-I zF81K(xWTatXATzlp0f|nyS`hq7FMA_^EOd938M09%)I$00_|cZUJtyN(=UVi#=?I9 z2T4#8nDw&pvGR0I(M|ikgO=+ZQ5Px}p5y{8a|Wz$VJEdLGept6FivGgy_0Du?m1dC zFsq!tOxrYa&BNqn-tsV5dV#SY{0^BU;Yr><%TLo+8n7ygnruruAyOO*c2rAQ zEWG0|fm4=HP*pa4VJCo~LM%{U%k9yVoJk>JNunpY&D}g}zFpDm=#5`9BYwjjT$5f1 zoI6n5ZJpJBW}RZw;0b(~W4u#l=7`4`<&0Th!Pvjk26b??W7=OG=+TkfE=NST=B!)w zF^wW;SudD0Z_-U85V0TPF}ovRgz2Kk!+B-9SnQZ{!4m`P)aCvFuA( zz+vfPvlt9Kf>>oo>cl82*zBziXg~JAr{(t`%TaEU4bn%ECt`LtEvdD&biZJob)M(B z!uWL;Z~*bq$b!|r-OZf+jyFRl2s)2LfgYLI>l_0SXKCX=r312p1V)}{)^S#mf50-~ zoe|F&e*IBcTP&Vc=_PMPoY;FSvscv|Y6Fh*84=v@+l=FAWPBtR`IK|@u7V9RRvFjW96sq4fj&GeWd&Bl651kAJ9kAAK=v^nR}gl-2a)p8~Zfk3Fz2VWER* zgqv{v%_sKP(dNt$w`qwdth?@6#cL?!%Dam4{f_wf1EBU`dX%iI#2$8Z4d2Rjoh<06 zA4*PX09_rlF%X&uvCP&_uymjbK@$z+4iFq&eiONwV)mqa6#H z({#PJY{sVxLy^3ip;9+pB-|uoi*>%&!)}=T`8(#Ggd*uSTprZ<>7{w;qzL7zlq+!T zo8UD0ugp$f`fj^zUFxg@S)$BPbiy%(s)^f@g)D;~kBA^?5cgl5n=#*l+nZ~78(hMZ zG%)Ce+{Mqzru`~bQ7R7^C$^My<9o()#e&AmmvXH08c)3uTNASmgw&}91#^V zii8@$K{gi~vybfCFM7LZvIvGEVa;H^b5E8_x5_KfWIN7&58PDvhmsu@uBy7x8TZUS zOUn4bZ(14VL&gdMr{<#vkv8gt9|ySHLO&NCljJ44)RquuNsqfXj2!BUg-6J;w}N2}GK zqw0l$J|cc(f#$vQhg!Q#tF~TqyKlQ0UxHXF(>UbA>UW9IE}=6sEECHV zo$8aI=OY2bL3K3ahU zEUA)ydttA}H|u!y>n&EdB8%{Wb!P5*(4_UzKCXX7e1C5<*EN~$Liv+q!sW^Qaq(L= znH*7MdOqInxEr6G!FAgGG9UQNtG;+qirRcc&=lUs=wQxpTh6nlqep+(2rtJ6v98_v zFT~BZFHK6_$18?M(O4f}-wx0XnPL<_L0r=~-XC=J(1)@cze7qYV6=B+E@g7u0Sm+1 zG8|wR`Xu+18w}8R(=kZtSs+?RS7d$W=bs_6I^Mc&o{`QnH7;HC^R?WT_Z*M26;xg}HB-NCS1g*#G^NhO6GI$W{FNa4 z0g{ZoOP6?%ELvq+^5n|O>E0#n_=4=%Tc5AxnPGn9akikKsC#d(udM<=FFd!`bd|^wSFa${ubHz_u z8{F<(_ShyWROn0LwVT`UkoEmML&ufwg7o}^(oGLLenb?&0;Ssuo``xHmqn-&m~aO`e2q(&IFSTk#A`zkV+pN zTL-tLO1KLGLG*amjo6gFh5ILu$y;JkYUz^aH}~sC98c0Bc$yp5EXB!qbR@AQd`>0$ ziO~#(K2|o`S|?~ZC~Qqem5Ajmk)3*jYrB1^_@=Q2x1#~&1|Nsj==Lx;?5y#AO}m;c zhYj@p3{*l%NLe#jU1c0udtIl0`^G8wNyAl@lW(}U%5wKR?zm%-4HM9lrUM;E7q_KY zI2b)?MzTQgUDs%T?`~+8idjO}HusS2U!4TD2Vey~7z zqRn0aE&0MqB#g-?r?-ob+|ID8WQowFmBa4gN5v>rr}NHdZdjJ*G~JZy@+$dLj7j7+ zi-JX?r&>oxicPxEn$mfKdlyIzz8A-iEdsKndXf8L@wR!Kr0F%Ot@LF*KSP#WjV@5NXsm?EM0vXt z15euhYh=kNYK_)0-(zOAm0dX!-q#}VZK}4iYn+TDgWWXOezJPWOm%#l{#KDCw)nw$ zn*-ajk1mQ4VGP@*61zI@xj)i1tGV$gf0Ljiyh1K9eUK%IYo?ncIaYB7hc%kBXWhb3 zC9JP`#q&2*J~iI4WOVDDrNN*lLs%C$bkWtv@z5_1L)$ElpsGESylq_Q*H-OuJhukl zuJ4P--`8o>bm=HyHz)y!F4R6hF<>rVdGK+x8^W0N(@a4xUF&o%m{% zQeuD8(RjY?5FO8|NlPMAZq8yCa^f?{JiY5+=NIv46uv4PaZhW)A|ur>@gCF zt6aAv0cn^!y^oK}lGq_6;Iy&VwALMYr+w-wP#6o-LS3zyEY>Tz*dBux+jQHrH@dpN z&Ot$^c_`=d`Uy0kQDaZUE6Uu;z~6RmsFZ;Gk;oRacXdR5B`5*I%7kKDG_VhImuz zEmXe<+hu->(kcp&d^n7Q3hE0tVc?tIL&ljnO|d_B*}|U_rT<><%dE%dSX-<`n=dQh zNL_7Hd9y7%kn0PQwuoAC{VoYEg?VB0TcA^wZbF@J57tF9?5GdyP^8Hia4VWokC1#y zKj0<=M^q%R-o|K0Ncn`&g*U{NNJ>Dw8N*NprV@0t#5Mgkm>kXsC%cC*cOk)@qy^?j zz`jVXAMCdzhfzl){4L3i1An_&5%zn>)4_L@&w9@xDnEiFhzhJX!>38!8>}air>Aub z{4L3sg8i1{cbOT+I0>3{_ym-QK8hc4+Ienk0zF}x82v7wOcuyMNRE!nn_!0|&jjpn zhy;)1%J2Kwfi8|7kmSuUMhLEgW)S8FpCTCY2DsmsWc0uH zhrcD6yGwAuw$dqC$Mwk(a3XxXa#ev7r>MNgk->C>x*dYa(!IT9}~>fCum<&(RX?b+-xE8 zm1x{@)A*&~V+2d|5dKmm`?Xe3x`Rb95&`9%WUTmiqZ0P?B-YFA%M!twBgiV=)4sBAN}usF8_w26xgZ zbbe+Nj01Fjf+$aczlzjo7SWn;6o-8f^=&*5q^Sr4K_mseV>En#q+PqU3nd^VP25&e zx*G6FNn^B9&p<>YWjt_@k`6{l)(5ss$d(Ek+>DWyu1AQ@1Av7zNsfk>W8mP3HVOJR zE>wCSP}nc1$0C|BSY$Is2KGU6-D06olA9NeXaf2;_y9?h!rp?Ub*+|@PD9y Date: Fri, 24 Jun 2016 17:25:20 +0200 Subject: [PATCH 2/2] Added the license key to the options --- src/calendar/widget/calendar.js | 1 + test/Widgets/Calendar.mpk | Bin 364340 -> 364364 bytes 2 files changed, 1 insertion(+) diff --git a/src/calendar/widget/calendar.js b/src/calendar/widget/calendar.js index 254fb4d..a43010d 100644 --- a/src/calendar/widget/calendar.js +++ b/src/calendar/widget/calendar.js @@ -107,6 +107,7 @@ define([ }; options.resources = []; options.resourceLabelText = this.resourceLabelText; + options.schedulerLicenseKey = this.schedulerLicenseKey; return options; }, diff --git a/test/Widgets/Calendar.mpk b/test/Widgets/Calendar.mpk index 7deb96b82c5b6435c22d0e37dcf560483d30bd12..6cfbe2c2341510c3bf8eaee200f8eecaccbab806 100644 GIT binary patch delta 8011 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 Nj|CnE)QbfG005G9nB@Qf delta 7918 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 Y0o0exiv<7x0MaK=&;S4c