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 '