active_frontend 13.3.0 → 14.0.0

data/vendor/assets/javascripts/extensions/_calendar.js

@@ -0,0 +1,4709 @@
+(function($, undefined) {
+
+  var defaults = {
+    defaultView: 'month',
+    aspectRatio: 1.35,
+    header: {
+      left: 'prev,title,next',
+      center: '',
+      right: 'month,agendaWeek,agendaDay'
+    },
+    weekends: true,
+    weekNumbers: false,
+    weekNumberCalculation: 'iso',
+    weekNumberTitle: 'W',
+    // editable: false,
+    // disableDragging: false,
+    // disableResizing: false,
+    allDayDefault: true,
+    ignoreTimezone: true,
+    lazyFetching: true,
+    startParam: 'start',
+    endParam: 'end',
+    titleFormat: {
+      month: 'MMMM yyyy',
+      week: "MMM d[ yyyy]{ '—'[ MMM] d yyyy}",
+      day: 'dddd, MMM d, yyyy'
+    },
+    columnFormat: {
+      month: 'ddd',
+      week: 'ddd M/d',
+      day: 'dddd M/d'
+    },
+    timeFormat: {
+      '': 'h(:mm)t'
+    },
+    firstDay: 0,
+    monthNames: ['January','February','March','April','May','June','July','August','September','October','November','December'],
+    monthNamesShort: ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'],
+    dayNames: ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'],
+    dayNamesShort: ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'],
+    buttonText: {
+      prev: '<i class="icon-chevron-left"></i>',
+      next: '<i class="icon-chevron-right"></i>',
+      today: 'Today',
+      month: 'Month',
+      week: 'Week',
+      day: 'Day'
+    },
+    buttonIcons: {
+      prev: 'circle-triangle-w',
+      next: 'circle-triangle-e'
+    },
+    // selectable: false,
+    unselectAuto: true,
+    dropAccept: '*',
+    handleWindowResize: false
+  };
+
+  var fc = $.calendar = { version: '1.0.0' };
+  var fcViews = fc.views = {};
+
+  $.fn.calendar = function (options) {
+    if (typeof options === 'string') {
+      var args = Array.prototype.slice.call(arguments, 1);
+      var res;
+
+      this.each(function () {
+        var calendar = $.data(this, 'calendar');
+
+        if (calendar && $.isFunction(calendar[options])) {
+          var r = calendar[options].apply(calendar, args);
+
+          if (res === undefined) {
+            res = r;
+          }
+          if (options === 'destroy') $.removeData(this, 'calendar');
+        }
+      });
+
+      if (res !== undefined) return res;
+      return this;
+    }
+
+    options = options || {};
+
+    var eventSources = options.eventSources || [];
+    delete options.eventSources;
+
+    if (options.events) {
+      eventSources.push(options.events);
+      delete options.events;
+    }
+
+    options = $.extend(true, {},
+      defaults,
+      {},
+      options
+    );
+
+    this.each(function (i, _element) {
+      var element = $(_element);
+      var calendar = new Calendar(element, options, eventSources);
+
+      element.data('calendar', calendar);
+      calendar.render();
+    });
+
+    return this;
+  };
+
+  function setDefaults(d) {
+    $.extend(true, defaults, d);
+  }
+
+  function Calendar(element, options, eventSources) {
+    var t = this;
+
+    t.options = options;
+    t.render = render;
+    t.destroy = destroy;
+    t.refetchEvents = refetchEvents;
+    t.reportEvents = reportEvents;
+    t.reportEventChange = reportEventChange;
+    t.rerenderEvents = rerenderEvents;
+    t.changeView = changeView;
+    t.select = select;
+    t.unselect = unselect;
+    t.prev = prev;
+    t.next = next;
+    t.today = today;
+    t.gotoDate = gotoDate;
+    t.incrementDate = incrementDate;
+    t.formatDate = function (format, date) { return formatDate(format, date, options); };
+    t.formatDates = function (format, date1, date2) { return formatDates(format, date1, date2, options); };
+    t.getDate = getDate;
+    t.getView = getView;
+    t.option = option;
+    t.trigger = trigger;
+
+    EventManager.call(t, options, eventSources);
+    var isFetchNeeded = t.isFetchNeeded;
+    var fetchEvents = t.fetchEvents;
+    var _element = element[0];
+    var resizeUID = 0;
+    var ignoreWindowResize = 0;
+    var date = new Date();
+    var events = [];
+    var _dragElement, header, headerElement, content, currentView, elementOuterWidth, suggestedViewHeight;
+
+    setYMD(date, options.year, options.month, options.date);
+
+    function render(inc) {
+      if (!content) {
+        initialRender();
+      } else if (elementVisible()) {
+        calcSize();
+        _renderView(inc);
+      }
+    }
+
+    function initialRender() {
+      element.addClass('calendar');
+
+      content = $('<div class="calendar-content" style="position: relative;"/>').prependTo(element);
+      header = new Header(t, options);
+      headerElement = header.render();
+
+      if (headerElement) element.prepend(headerElement);
+
+      changeView(options.defaultView);
+
+      if (options.handleWindowResize) $(window).resize(windowResize);
+      if (!bodyVisible()) lateRender();
+    }
+
+    function lateRender() {
+      setTimeout(function () {
+        if (!currentView.start && bodyVisible()) renderView();
+      }, 0);
+    }
+
+    function destroy() {
+      if (currentView) {
+        trigger('viewDestroy', currentView, currentView, currentView.element);
+        currentView.triggerEventDestroy();
+      }
+
+      $(window).unbind('resize', windowResize);
+
+      header.destroy();
+      content.remove();
+      element.removeClass('calendar');
+    }
+
+    function elementVisible() {
+      return element.is(':visible');
+    }
+
+    function bodyVisible() {
+      return $('body').is(':visible');
+    }
+
+    function changeView(newViewName) {
+      if (!currentView || newViewName !== currentView.name) _changeView(newViewName);
+    }
+
+    function _changeView(newViewName) {
+      ignoreWindowResize++;
+
+      if (currentView) {
+        trigger('viewDestroy', currentView, currentView, currentView.element);
+        unselect();
+        currentView.triggerEventDestroy();
+        freezeContentHeight();
+        currentView.element.remove();
+        header.deactivateButton(currentView.name);
+      }
+
+      header.activateButton(newViewName);
+
+      currentView = new fcViews[newViewName](
+        $('<div class="calendar-view calendar-view-' + newViewName + '" style="position: relative;"/>').appendTo(content), t
+      );
+
+      renderView();
+      unfreezeContentHeight();
+
+      ignoreWindowResize--;
+    }
+
+    function renderView(inc) {
+      if (!currentView.start || inc || date < currentView.start || date >= currentView.end) {
+        if (elementVisible()) _renderView(inc);
+      }
+    }
+
+    function _renderView(inc) {
+      ignoreWindowResize++;
+
+      if (currentView.start) {
+        trigger('viewDestroy', currentView, currentView, currentView.element);
+        unselect();
+        clearEvents();
+      }
+
+      freezeContentHeight();
+
+      currentView.render(date, inc || 0);
+
+      setSize();
+      unfreezeContentHeight();
+
+      (currentView.afterRender || noop)();
+
+      updateTitle();
+      updateTodayButton();
+      trigger('viewRender', currentView, currentView, currentView.element);
+
+      currentView.trigger('viewDisplay', _element);
+
+      ignoreWindowResize--;
+
+      getAndRenderEvents();
+    }
+
+    function updateSize() {
+      if (elementVisible()) {
+        unselect();
+        clearEvents();
+        calcSize();
+        setSize();
+        renderEvents();
+      }
+    }
+
+    function calcSize() {
+      if (options.contentHeight) {
+        suggestedViewHeight = options.contentHeight;
+      } else if (options.height) {
+        suggestedViewHeight = options.height - (headerElement ? headerElement.height() : 0) - vsides(content);
+      } else {
+        suggestedViewHeight = Math.round(content.width() / Math.max(options.aspectRatio, 0.5));
+      }
+    }
+
+    function setSize() {
+      if (suggestedViewHeight === undefined) calcSize();
+
+      ignoreWindowResize++;
+
+      currentView.setHeight(suggestedViewHeight);
+      currentView.setWidth(content.width());
+
+      ignoreWindowResize--;
+
+      elementOuterWidth = element.outerWidth();
+    }
+
+    function windowResize() {
+      if (!ignoreWindowResize) {
+        if (currentView.start) {
+          var uid = ++resizeUID;
+
+          setTimeout(function () {
+            if (uid === resizeUID && !ignoreWindowResize && elementVisible()) {
+              if (elementOuterWidth !== (elementOuterWidth = element.outerWidth())) {
+                ignoreWindowResize++;
+
+                updateSize();
+                currentView.trigger('windowResize', _element);
+
+                ignoreWindowResize--;
+              }
+            }
+          }, 200);
+        } else {
+          lateRender();
+        }
+      }
+    }
+
+    function refetchEvents() {
+      clearEvents();
+      fetchAndRenderEvents();
+    }
+
+    function rerenderEvents(modifiedEventID) {
+      clearEvents();
+      renderEvents(modifiedEventID);
+    }
+
+    function renderEvents(modifiedEventID) {
+      if (elementVisible()) {
+        currentView.setEventData(events);
+        currentView.renderEvents(events, modifiedEventID);
+        currentView.trigger('eventAfterAllRender');
+      }
+    }
+
+    function clearEvents() {
+      currentView.triggerEventDestroy();
+      currentView.clearEvents();
+      currentView.clearEventData();
+    }
+
+    function getAndRenderEvents() {
+      if (!options.lazyFetching || isFetchNeeded(currentView.visStart, currentView.visEnd)) {
+        fetchAndRenderEvents();
+      } else {
+        renderEvents();
+      }
+    }
+
+    function fetchAndRenderEvents() {
+      fetchEvents(currentView.visStart, currentView.visEnd);
+    }
+
+    function reportEvents(_events) {
+      events = _events;
+      renderEvents();
+    }
+
+    function reportEventChange(eventID) {
+      rerenderEvents(eventID);
+    }
+
+    function updateTitle() {
+      header.updateTitle(currentView.title);
+    }
+
+    function updateTodayButton() {
+      var today = new Date();
+
+      if (today >= currentView.start && today < currentView.end) {
+        header.disableButton('today');
+      } else {
+        header.enableButton('today');
+      }
+    }
+
+    function select(start, end, allDay) {
+      currentView.select(start, end, allDay === undefined ? true : allDay);
+    }
+
+    function unselect() {
+      if (currentView) currentView.unselect();
+    }
+
+    function prev() {
+      renderView(-1);
+    }
+
+    function next() {
+      renderView(1);
+    }
+
+    function prevYear() {
+      addYears(date, -1);
+      renderView();
+    }
+
+    function nextYear() {
+      addYears(date, 1);
+      renderView();
+    }
+
+    function today() {
+      date = new Date();
+      renderView();
+    }
+
+    function gotoDate(year, month, dateOfMonth) {
+      if (year instanceof Date) {
+        date = cloneDate(year);
+      } else {
+        setYMD(date, year, month, dateOfMonth);
+      }
+
+      renderView();
+    }
+
+    function incrementDate(years, months, days) {
+      if (years !== undefined) addYears(date, years);
+      if (months !== undefined) addMonths(date, months);
+      if (days !== undefined) addDays(date, days);
+
+      renderView();
+    }
+
+    function getDate() {
+      return cloneDate(date);
+    }
+
+    function freezeContentHeight() {
+      content.css({
+        width: '100%',
+        height: content.height(),
+        overflow: 'hidden'
+      });
+    }
+
+    function unfreezeContentHeight() {
+      content.css({
+        width: '',
+        height: '',
+        overflow: ''
+      });
+    }
+
+    function getView() {
+      return currentView;
+    }
+
+    function option(name, value) {
+      if (value === undefined) return options[name];
+
+      if (name === 'height' || name === 'contentHeight' || name === 'aspectRatio') {
+        options[name] = value;
+        updateSize();
+      }
+    }
+
+    function trigger(name, thisObj) {
+      if (options[name]) {
+        return options[name].apply(
+          thisObj || _element,
+          Array.prototype.slice.call(arguments, 2)
+        );
+      }
+    }
+
+    if (options.droppable) {
+      $(document)
+        .bind('dragstart', function (ev, ui) {
+          var _e = ev.target;
+          var e = $(_e);
+
+          if (!e.parents('.calendar').length) {
+            var accept = options.dropAccept;
+
+            if ($.isFunction(accept) ? accept.call(_e, e) : e.is(accept)) {
+              _dragElement = _e;
+              currentView.dragStart(_dragElement, ev, ui);
+            }
+          }
+        })
+        .bind('dragstop', function (ev, ui) {
+          if (_dragElement) {
+            currentView.dragStop(_dragElement, ev, ui);
+            _dragElement = null;
+          }
+        });
+    }
+  }
+
+  function Header(calendar, options) {
+    var t = this;
+
+    t.render = render;
+    t.destroy = destroy;
+    t.updateTitle = updateTitle;
+    t.activateButton = activateButton;
+    t.deactivateButton = deactivateButton;
+    t.disableButton = disableButton;
+    t.enableButton = enableButton;
+
+    var element = $([]);
+
+    function render() {
+      var sections = options.header;
+
+      if (sections) {
+        element = $('<table class="calendar-header" style="width: 100%;"/>')
+          .append(
+            $('<tr/>')
+              .append(renderSection('left'))
+              .append(renderSection('center'))
+              .append(renderSection('right'))
+          );
+        return element;
+      }
+    }
+
+    function destroy() {
+      element.remove();
+    }
+
+    function renderSection(position) {
+      var e = $('<td class="calendar-header-' + position + '"/>');
+      var bg = $('<span class="btn-group"/>');
+      var buttonStr = options.header[position];
+
+      if (buttonStr) {
+        $.each(buttonStr.split(' '), function (i) {
+          if (i > 0) e.append("<span class='calendar-header-space'/>");
+
+          var prevButton;
+
+          $.each(this.split(','), function (j, buttonName) {
+            if (buttonName === 'title') {
+              e.append('<span class="calendar-header-title"><h6>&nbsp;</h6></span>');
+
+              prevButton = null;
+            } else {
+              var buttonClick;
+
+              if (calendar[buttonName]) {
+                buttonClick = calendar[buttonName];
+              } else if (fcViews[buttonName]) {
+                buttonClick = function () {
+                  calendar.changeView(buttonName);
+                };
+              }
+
+              if (buttonClick) {
+                var buttonKlass = 'btn btn-size-s btn-outline';
+
+                if (buttonName === 'prev' || buttonName === 'next') {
+                  buttonKlass = '';
+                }
+
+                var text = smartProperty(options.buttonText, buttonName);
+                var button = $(
+                                '<span class="' + buttonKlass + ' btn-' + buttonName + '">' +
+                                  text +
+                                '</span>'
+                              )
+                              .click(function () {
+                                if (!button.hasClass('disabled')) buttonClick();
+                              });
+
+
+                if (position === 'left') {
+                  button.appendTo(e);
+                } else {
+                  button.appendTo(bg);
+                }
+
+                disableTextSelection(button);
+
+                prevButton = button;
+              }
+            }
+          });
+
+          if (position !== 'center') bg.appendTo(e);
+        });
+      }
+
+      return e;
+    }
+
+    function updateTitle(html) {
+      element.find('h6')
+        .html(html);
+    }
+
+    function activateButton(buttonName) {
+      element.find('span.btn-' + buttonName)
+        .addClass('active');
+    }
+
+    function deactivateButton(buttonName) {
+      element.find('span.btn-' + buttonName)
+        .removeClass('active');
+    }
+
+    function disableButton(buttonName) {
+      element.find('span.btn-' + buttonName)
+        .addClass('disabled');
+    }
+
+    function enableButton(buttonName) {
+      element.find('span.btn-' + buttonName)
+        .removeClass('disabled');
+    }
+  }
+
+  fc.sourceNormalizers = [];
+  fc.sourceFetchers = [];
+
+  var eventGUID = 1;
+  var ajaxDefaults = {
+    dataType: 'json',
+    cache: false
+  };
+
+  function EventManager(options, _sources) {
+    var t = this;
+
+    t.isFetchNeeded = isFetchNeeded;
+    t.fetchEvents = fetchEvents;
+    t.addEventSource = addEventSource;
+    t.removeEventSource = removeEventSource;
+    t.updateEvent = updateEvent;
+    t.renderEvent = renderEvent;
+    t.removeEvents = removeEvents;
+    t.clientEvents = clientEvents;
+    t.normalizeEvent = normalizeEvent;
+
+    var trigger = t.trigger;
+    var getView = t.getView;
+    var reportEvents = t.reportEvents;
+    var stickySource = { events: [] };
+    var sources = [ stickySource ];
+    var currentFetchID = 0;
+    var pendingSourceCnt = 0;
+    var loadingLevel = 0;
+    var cache = [];
+    var rangeStart, rangeEnd;
+
+    for (var i = 0; i < _sources.length; i++) {
+      _addEventSource(_sources[i]);
+    }
+
+    function isFetchNeeded(start, end) {
+      return !rangeStart || start < rangeStart || end > rangeEnd;
+    }
+
+    function fetchEvents(start, end) {
+      rangeStart = start;
+      rangeEnd = end;
+      cache = [];
+
+      var fetchID = ++currentFetchID;
+      var len = sources.length;
+
+      pendingSourceCnt = len;
+
+      for (var i = 0; i < len; i++) {
+        fetchEventSource(sources[i], fetchID);
+      }
+    }
+
+    function fetchEventSource(source, fetchID) {
+      _fetchEventSource(source, function (events) {
+        if (fetchID === currentFetchID) {
+          if (events) {
+
+            if (options.eventDataTransform) {
+              events = $.map(events, options.eventDataTransform);
+            }
+            if (source.eventDataTransform) {
+              events = $.map(events, source.eventDataTransform);
+            }
+
+            for (var i = 0; i < events.length; i++) {
+              events[i].source = source;
+              normalizeEvent(events[i]);
+            }
+
+            cache = cache.concat(events);
+          }
+
+          pendingSourceCnt--;
+
+          if (!pendingSourceCnt) reportEvents(cache);
+        }
+      });
+    }
+
+    function _fetchEventSource(source, callback) {
+      var fetchers = fc.sourceFetchers;
+      var res;
+
+      for (var i = 0; i < fetchers.length; i++) {
+        res = fetchers[i](source, rangeStart, rangeEnd, callback);
+
+        if (res === true) {
+          return;
+        } else if (typeof res === 'object') {
+          _fetchEventSource(res, callback);
+          return;
+        }
+      }
+
+      var events = source.events;
+
+      if (events) {
+        if ($.isFunction(events)) {
+          pushLoading();
+          events(cloneDate(rangeStart), cloneDate(rangeEnd), function (events) {
+            callback(events);
+            popLoading();
+          });
+        } else if ($.isArray(events)) {
+          callback(events);
+        } else {
+          callback();
+        }
+      } else {
+        var url = source.url;
+
+        if (url) {
+          var success = source.success;
+          var error = source.error;
+          var complete = source.complete;
+          var customData;
+
+          if ($.isFunction(source.data)) {
+            customData = source.data();
+          } else {
+            customData = source.data;
+          }
+
+          var data = $.extend({}, customData || {});
+          var startParam = firstDefined(source.startParam, options.startParam);
+          var endParam = firstDefined(source.endParam, options.endParam);
+
+          if (startParam) {
+            data[startParam] = Math.round(+rangeStart / 1000);
+          }
+          if (endParam) {
+            data[endParam] = Math.round(+rangeEnd / 1000);
+          }
+
+          pushLoading();
+
+          $.ajax($.extend({}, ajaxDefaults, source, {
+            data: data,
+            success: function (events) {
+              events = events || [];
+              var res = applyAll(success, this, arguments);
+
+              if ($.isArray(res)) {
+                events = res;
+              }
+
+              callback(events);
+            },
+            error: function () {
+              applyAll(error, this, arguments);
+              callback();
+            },
+            complete: function () {
+              applyAll(complete, this, arguments);
+              popLoading();
+            }
+          }));
+        } else {
+          callback();
+        }
+      }
+    }
+
+    function addEventSource(source) {
+      source = _addEventSource(source);
+
+      if (source) {
+        pendingSourceCnt++;
+
+        fetchEventSource(source, currentFetchID);
+      }
+    }
+
+    function _addEventSource(source) {
+      if ($.isFunction(source) || $.isArray(source)) {
+        source = { events: source };
+      } else if (typeof source === 'string') {
+        source = { url: source };
+      }
+
+      if (typeof source === 'object') {
+        normalizeSource(source);
+        sources.push(source);
+        return source;
+      }
+    }
+
+    function removeEventSource(source) {
+      sources = $.grep(sources, function (src) {
+        return !isSourcesEqual(src, source);
+      });
+      cache = $.grep(cache, function (e) {
+        return !isSourcesEqual(e.source, source);
+      });
+
+      reportEvents(cache);
+    }
+
+    function updateEvent(event) {
+      var len = cache.length;
+      var defaultEventEnd = getView().defaultEventEnd;
+      var startDelta = event.start - event._start;
+      var endDelta = event.end ? (event.end - (event._end || defaultEventEnd(event))) : 0;
+
+      for (var i = 0; i < len; i++) {
+        var e = cache[i];
+
+        if (e._id === event._id && e !== event) {
+          e.start = new Date(+e.start + startDelta);
+
+          if (event.end) {
+            if (e.end) {
+              e.end = new Date(+e.end + endDelta);
+            } else {
+              e.end = new Date(+defaultEventEnd(e) + endDelta);
+            }
+          } else {
+            e.end = null;
+          }
+
+          e.title = event.title;
+          e.url = event.url;
+          e.allDay = event.allDay;
+          e.className = event.className;
+          e.editable = event.editable;
+          e.color = event.color;
+          e.backgroundColor = event.backgroundColor;
+          e.borderColor = event.borderColor;
+          e.textColor = event.textColor;
+
+          normalizeEvent(e);
+        }
+      }
+
+      normalizeEvent(event);
+      reportEvents(cache);
+    }
+
+    function renderEvent(event, stick) {
+      normalizeEvent(event);
+
+      if (!event.source) {
+        if (stick) {
+          stickySource.events.push(event);
+          event.source = stickySource;
+        }
+
+        cache.push(event);
+      }
+
+      reportEvents(cache);
+    }
+
+    function removeEvents(filter) {
+      var i;
+
+      if (!filter) {
+        cache = [];
+
+        for (i = 0; i < sources.length; i++) {
+          if ($.isArray(sources[i].events)) {
+            sources[i].events = [];
+          }
+        }
+      } else {
+        if (!$.isFunction(filter)) {
+          var id = filter + '';
+
+          filter = function (e) {
+            return e._id === id;
+          };
+        }
+
+        cache = $.grep(cache, filter, true);
+
+        for (i = 0; i < sources.length; i++) {
+          if ($.isArray(sources[i].events)) {
+            sources[i].events = $.grep(sources[i].events, filter, true);
+          }
+        }
+      }
+
+      reportEvents(cache);
+    }
+
+    function clientEvents(filter) {
+      if ($.isFunction(filter)) {
+        return $.grep(cache, filter);
+      } else if (filter) {
+        filter += '';
+
+        return $.grep(cache, function (e) {
+          return e._id === filter;
+        });
+      }
+
+      return cache;
+    }
+
+    function pushLoading() {
+      if (!++loadingLevel) trigger('loading', null, true, getView());
+    }
+
+    function popLoading() {
+      if (!--loadingLevel) trigger('loading', null, false, getView());
+    }
+
+    function normalizeEvent(event) {
+      var source = event.source || {};
+      var ignoreTimezone = firstDefined(source.ignoreTimezone, options.ignoreTimezone);
+
+      event._id = event._id || (event.id === undefined ? '_fc' + eventGUID++ : event.id + '');
+
+      if (event.date) {
+        if (!event.start) {
+          event.start = event.date;
+        }
+
+        delete event.date;
+      }
+
+      event._start = cloneDate(event.start = parseDate(event.start, ignoreTimezone));
+      event.end = parseDate(event.end, ignoreTimezone);
+
+      if (event.end && event.end <= event.start) {
+        event.end = null;
+      }
+
+      event._end = event.end ? cloneDate(event.end) : null;
+
+      if (event.allDay === undefined) {
+        event.allDay = firstDefined(source.allDayDefault, options.allDayDefault);
+      }
+
+      if (event.className) {
+        if (typeof event.className === 'string') {
+          event.className = event.className.split(/\s+/);
+        }
+      } else {
+        event.className = [];
+      }
+    }
+
+    function normalizeSource(source) {
+      if (source.className) {
+        if (typeof source.className === 'string') {
+          source.className = source.className.split(/\s+/);
+        }
+      } else {
+        source.className = [];
+      }
+
+      var normalizers = fc.sourceNormalizers;
+
+      for (var i = 0; i < normalizers.length; i++) {
+        normalizers[i](source);
+      }
+    }
+
+    function isSourcesEqual(source1, source2) {
+      return source1 && source2 && getSourcePrimitive(source1) === getSourcePrimitive(source2);
+    }
+
+    function getSourcePrimitive(source) {
+      return ((typeof source === 'object') ? (source.googleCalendarId || source.events || source.url) : '') || source;
+    }
+  }
+
+  fc.addDays = addDays;
+  fc.cloneDate = cloneDate;
+  fc.parseDate = parseDate;
+  fc.parseISO8601 = parseISO8601;
+  fc.parseTime = parseTime;
+  fc.formatDate = formatDate;
+  fc.formatDates = formatDates;
+
+  var dayIDs = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+  var DAY_MS = 86400000;
+  var HOUR_MS = 3600000;
+  var MINUTE_MS = 60000;
+
+  function addYears(d, n, keepTime) {
+    d.setFullYear(d.getFullYear() + n);
+
+    if (!keepTime) clearTime(d);
+
+    return d;
+  }
+
+  function addMonths(d, n, keepTime) {
+    if (+d) {
+      var m = d.getMonth() + n;
+      var check = cloneDate(d);
+
+      check.setDate(1);
+      check.setMonth(m);
+      d.setMonth(m);
+
+      if (!keepTime) clearTime(d);
+
+      while (d.getMonth() !== check.getMonth()) {
+        d.setDate(d.getDate() + (d < check ? 1 : -1));
+      }
+    }
+
+    return d;
+  }
+
+  function addDays(d, n, keepTime) {
+    if (+d) {
+      var dd = d.getDate() + n;
+      var check = cloneDate(d);
+
+      check.setHours(9);
+      check.setDate(dd);
+      d.setDate(dd);
+
+      if (!keepTime) clearTime(d);
+
+      fixDate(d, check);
+    }
+
+    return d;
+  }
+
+  function fixDate(d, check) {
+    if (+d) {
+      while (d.getDate() !== check.getDate()) {
+        d.setTime(+d + (d < check ? 1 : -1) * HOUR_MS);
+      }
+    }
+  }
+
+  function addMinutes(d, n) {
+    d.setMinutes(d.getMinutes() + n);
+    return d;
+  }
+
+  function clearTime(d) {
+    d.setHours(0);
+    d.setMinutes(0);
+    d.setSeconds(0);
+    d.setMilliseconds(0);
+    return d;
+  }
+
+  function cloneDate(d, dontKeepTime) {
+    if (dontKeepTime) return clearTime(new Date(+d));
+    return new Date(+d);
+  }
+
+  function zeroDate() {
+    var i = 0, d;
+
+    do {
+      d = new Date(1970, i++, 1);
+    } while (d.getHours());
+
+    return d;
+  }
+
+  function dayDiff(d1, d2) {
+    return Math.round((cloneDate(d1, true) - cloneDate(d2, true)) / DAY_MS);
+  }
+
+  function setYMD(date, y, m, d) {
+    if (y !== undefined && y !== date.getFullYear()) {
+      date.setDate(1);
+      date.setMonth(0);
+      date.setFullYear(y);
+    }
+
+    if (m !== undefined && m !== date.getMonth()) {
+      date.setDate(1);
+      date.setMonth(m);
+    }
+
+    if (d !== undefined) date.setDate(d);
+  }
+
+  function parseDate(s, ignoreTimezone) {
+    if (typeof s === 'object') return s;
+    if (typeof s === 'number') return new Date(s * 1000);
+
+    if (typeof s === 'string') {
+      if (s.match(/^\d+(\.\d+)?$/)) return new Date(parseFloat(s) * 1000);
+
+      if (ignoreTimezone === undefined) {
+        ignoreTimezone = true;
+      }
+
+      return parseISO8601(s, ignoreTimezone) || (s ? new Date(s) : null);
+    }
+
+    return null;
+  }
+
+  function parseISO8601(s, ignoreTimezone) {
+    var m = s.match(/^([0-9]{4})(-([0-9]{2})(-([0-9]{2})([T ]([0-9]{2}):([0-9]{2})(:([0-9]{2})(\.([0-9]+))?)?(Z|(([-+])([0-9]{2})(:?([0-9]{2}))?))?)?)?)?$/);
+
+    if (!m) return null;
+
+    var date = new Date(m[1], 0, 1);
+
+    if (ignoreTimezone || !m[13]) {
+      var check = new Date(m[1], 0, 1, 9, 0);
+
+      if (m[3]) {
+        date.setMonth(m[3] - 1);
+        check.setMonth(m[3] - 1);
+      }
+      if (m[5]) {
+        date.setDate(m[5]);
+        check.setDate(m[5]);
+      }
+
+      fixDate(date, check);
+
+      if (m[7]) date.setHours(m[7]);
+      if (m[8]) date.setMinutes(m[8]);
+      if (m[10]) date.setSeconds(m[10]);
+      if (m[12]) date.setMilliseconds(Number('0.' + m[12]) * 1000);
+
+      fixDate(date, check);
+    } else {
+      date.setUTCFullYear(
+        m[1],
+        m[3] ? m[3] - 1 : 0,
+        m[5] || 1
+      );
+      date.setUTCHours(
+        m[7] || 0,
+        m[8] || 0,
+        m[10] || 0,
+        m[12] ? Number('0.' + m[12]) * 1000 : 0
+      );
+
+      if (m[14]) {
+        var offset = Number(m[16]) * 60 + (m[18] ? Number(m[18]) : 0);
+
+        offset *= m[15] === '-' ? 1 : -1;
+        date = new Date(+date + (offset * 60 * 1000));
+      }
+    }
+    return date;
+  }
+
+  function parseTime(s) {
+    if (typeof s === 'number') return s * 60;
+    if (typeof s === 'object') return s.getHours() * 60 + s.getMinutes();
+
+    var m = s.match(/(\d+)(?::(\d+))?\s*(\w+)?/);
+
+    if (m) {
+      var h = parseInt(m[1], 10);
+
+      if (m[3]) {
+        h %= 12;
+
+        if (m[3].toLowerCase().charAt(0) === 'p') h += 12;
+      }
+
+      return h * 60 + (m[2] ? parseInt(m[2], 10) : 0);
+    }
+  }
+
+  function formatDate(date, format, options) {
+    return formatDates(date, null, format, options);
+  }
+
+  function formatDates(date1, date2, format, options) {
+    options = options || defaults;
+
+    var c, i, i2, formatter, subres;
+    var date = date1;
+    var otherDate = date2;
+    var len = format.length;
+    var res = '';
+
+    for (i = 0; i < len; i++) {
+      c = format.charAt(i);
+
+      if (c === "'") {
+        for (i2 = i + 1; i2 < len; i2++) {
+          if (format.charAt(i2) === "'") {
+            if (date) {
+              if (i2 === i+1) {
+                res += "'";
+              } else {
+                res += format.substring(i+1, i2);
+              }
+
+              i = i2;
+            }
+
+            break;
+          }
+        }
+      } else if (c === '(') {
+        for (i2 = i + 1; i2 < len; i2++) {
+          if (format.charAt(i2) === ')') {
+            subres = formatDate(date, format.substring(i + 1, i2), options);
+
+            if (parseInt(subres.replace(/\D/, ''), 10)) res += subres;
+
+            i = i2;
+            break;
+          }
+        }
+      } else if (c === '[') {
+        for (i2 = i + 1; i2 < len; i2++) {
+          if (format.charAt(i2) === ']') {
+            var subformat = format.substring(i + 1, i2);
+            subres = formatDate(date, subformat, options);
+
+            if (subres !== formatDate(otherDate, subformat, options)) res += subres;
+
+            i = i2;
+            break;
+          }
+        }
+      } else if (c === '{') {
+        date = date2;
+        otherDate = date1;
+      } else if (c === '}') {
+        date = date1;
+        otherDate = date2;
+      } else {
+        for (i2 = len; i2 > i; i2--) {
+          if (formatter = dateFormatters[format.substring(i, i2)]) {
+            if (date) res += formatter(date, options);
+
+            i = i2 - 1;
+            break;
+          }
+        }
+
+        if (i2 === i) {
+          if (date) res += c;
+        }
+      }
+    }
+
+    return res;
+  }
+
+  var dateFormatters = {
+    s: function (d)	{ return d.getSeconds(); },
+    ss: function (d)	{ return zeroPad(d.getSeconds()); },
+    m: function (d)	{ return d.getMinutes(); },
+    mm: function (d)	{ return zeroPad(d.getMinutes()); },
+    h: function (d)	{ return d.getHours() % 12 || 12; },
+    hh: function (d)	{ return zeroPad(d.getHours() % 12 || 12); },
+    H: function (d)	{ return d.getHours(); },
+    HH: function (d)	{ return zeroPad(d.getHours()); },
+    d: function (d)	{ return d.getDate(); },
+    dd: function (d)	{ return zeroPad(d.getDate()); },
+    ddd: function (d,o)	{ return o.dayNamesShort[d.getDay()]; },
+    dddd: function (d,o)	{ return o.dayNames[d.getDay()]; },
+    M: function (d)	{ return d.getMonth() + 1; },
+    MM: function (d)	{ return zeroPad(d.getMonth() + 1); },
+    MMM: function (d,o)	{ return o.monthNamesShort[d.getMonth()]; },
+    MMMM: function (d,o)	{ return o.monthNames[d.getMonth()]; },
+    yy: function (d)	{ return (d.getFullYear()+'').substring(2); },
+    yyyy: function (d)	{ return d.getFullYear(); },
+    t: function (d)	{ return d.getHours() < 12 ? 'a' : 'p'; },
+    tt: function (d)	{ return d.getHours() < 12 ? 'am' : 'pm'; },
+    T: function (d)	{ return d.getHours() < 12 ? 'A' : 'P'; },
+    TT: function (d)	{ return d.getHours() < 12 ? 'AM' : 'PM'; },
+    u: function (d)	{ return formatDate(d, "yyyy-MM-dd'T'HH:mm:ss'Z'"); },
+    S: function (d)	{
+      var date = d.getDate();
+
+      if (date > 10 && date < 20) return 'th';
+
+      return ['st', 'nd', 'rd'][date%10-1] || 'th';
+    },
+    w: function (d, o) { return o.weekNumberCalculation(d); },
+    W: function (d) { return iso8601Week(d); }
+  };
+
+  fc.dateFormatters = dateFormatters;
+
+  function iso8601Week(date) {
+    var checkDate = new Date(date.getTime());
+
+    checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
+
+    var time = checkDate.getTime();
+
+    checkDate.setMonth(0);
+    checkDate.setDate(1);
+
+    return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
+  }
+
+  fc.applyAll = applyAll;
+
+  function exclEndDay(event) {
+    if (event.end) {
+      return _exclEndDay(event.end, event.allDay);
+    } else {
+      return addDays(cloneDate(event.start), 1);
+    }
+  }
+
+  function _exclEndDay(end, allDay) {
+    end = cloneDate(end);
+    return allDay || end.getHours() || end.getMinutes() ? addDays(end, 1) : clearTime(end);
+  }
+
+  function lazySegBind(container, segs, bindHandlers) {
+    container
+      .unbind('mouseover')
+      .mouseover(function (ev) {
+        var e, i, seg;
+        var parent = ev.target;
+
+        while (parent !== this) {
+          e = parent;
+          parent = parent.parentNode;
+        }
+
+        if ((i = e._fci) !== undefined) {
+          e._fci = undefined;
+          seg = segs[i];
+          bindHandlers(seg.event, seg.element, seg);
+          $(ev.target).trigger(ev);
+        }
+
+        ev.stopPropagation();
+      });
+  }
+
+  function setOuterWidth(element, width, includeMargins) {
+    for (var i = 0, e; i < element.length; i++) {
+      e = $(element[i]);
+      e.width(Math.max(0, width - hsides(e, includeMargins)));
+    }
+  }
+
+  function setOuterHeight(element, height, includeMargins) {
+    for (var i = 0, e; i < element.length; i++) {
+      e = $(element[i]);
+      e.height(Math.max(0, height - vsides(e, includeMargins)));
+    }
+  }
+
+  function hsides(element, includeMargins) {
+    return hpadding(element) + hborders(element) + (includeMargins ? hmargins(element) : 0);
+  }
+
+  function hpadding(element) {
+    return (parseFloat($.css(element[0], 'paddingLeft', true)) || 0) +
+           (parseFloat($.css(element[0], 'paddingRight', true)) || 0);
+  }
+
+  function hmargins(element) {
+    return (parseFloat($.css(element[0], 'marginLeft', true)) || 0) +
+           (parseFloat($.css(element[0], 'marginRight', true)) || 0);
+  }
+
+  function hborders(element) {
+    return (parseFloat($.css(element[0], 'borderLeftWidth', true)) || 0) +
+           (parseFloat($.css(element[0], 'borderRightWidth', true)) || 0);
+  }
+
+  function vsides(element, includeMargins) {
+    return vpadding(element) +  vborders(element) + (includeMargins ? vmargins(element) : 0);
+  }
+
+  function vpadding(element) {
+    return (parseFloat($.css(element[0], 'paddingTop', true)) || 0) +
+           (parseFloat($.css(element[0], 'paddingBottom', true)) || 0);
+  }
+
+  function vmargins(element) {
+    return (parseFloat($.css(element[0], 'marginTop', true)) || 0) +
+           (parseFloat($.css(element[0], 'marginBottom', true)) || 0);
+  }
+
+  function vborders(element) {
+    return (parseFloat($.css(element[0], 'borderTopWidth', true)) || 0) +
+           (parseFloat($.css(element[0], 'borderBottomWidth', true)) || 0);
+  }
+
+  function noop() {}
+
+  function dateCompare(a, b) {
+    return a - b;
+  }
+
+  function arrayMax(a) {
+    return Math.max.apply(Math, a);
+  }
+
+  function zeroPad(n) {
+    return (n < 10 ? '0' : '') + n;
+  }
+
+  function smartProperty(obj, name) {
+    if (obj[name] !== undefined) return obj[name];
+
+    var res;
+    var parts = name.split(/(?=[A-Z])/);
+
+    for (var i = parts.length - 1; i >= 0; i--) {
+      res = obj[parts[i].toLowerCase()];
+      if (res !== undefined) return res;
+    }
+
+    return obj[''];
+  }
+
+  function htmlEscape(s) {
+    return s.replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/'/g, '&#039;')
+      .replace(/"/g, '&quot;')
+      .replace(/\n/g, '<br />');
+  }
+
+  function disableTextSelection(element) {
+    element
+      .attr('unselectable', 'on')
+      .css('MozUserSelect', 'none')
+      .bind('selectstart.ui', function () { return false; });
+  }
+
+  function markFirstLast(e) {
+    e.children()
+      .removeClass('calendar-first calendar-last')
+      .filter(':first-child')
+      .addClass('calendar-first')
+      .end()
+      .filter(':last-child')
+      .addClass('calendar-last');
+  }
+
+  function setDayID(cell, date) {
+    cell.each(function (i, _cell) {
+      _cell.className = _cell.className.replace(/^calendar-\w*/, 'calendar-' + dayIDs[date.getDay()]);
+    });
+  }
+
+  function getSkinCss(event, opt) {
+    var source = event.source || {};
+    var eventColor = event.color;
+    var sourceColor = source.color;
+    var optionColor = opt('eventColor');
+    var statements = [];
+    var backgroundColor =
+      event.backgroundColor ||
+      eventColor ||
+      source.backgroundColor ||
+      sourceColor ||
+      opt('eventBackgroundColor') ||
+      optionColor;
+    var borderColor =
+      event.borderColor ||
+      eventColor ||
+      source.borderColor ||
+      sourceColor ||
+      opt('eventBorderColor') ||
+      optionColor;
+    var textColor =
+      event.textColor ||
+      source.textColor ||
+      opt('eventTextColor');
+
+    if (backgroundColor) statements.push('background-color:' + backgroundColor);
+    if (borderColor) statements.push('border-color:' + borderColor);
+    if (textColor) statements.push('color:' + textColor);
+
+    return statements.join(';');
+  }
+
+  function applyAll(functions, thisObj, args) {
+    if ($.isFunction(functions)) {
+      functions = [ functions ];
+    }
+
+    if (functions) {
+      var ret;
+
+      for (var i = 0; i < functions.length; i++) {
+        ret = functions[i].apply(thisObj, args) || ret;
+      }
+
+      return ret;
+    }
+  }
+
+  function firstDefined() {
+    for (var i = 0; i < arguments.length; i++) {
+      if (arguments[i] !== undefined) return arguments[i];
+    }
+  }
+
+  fcViews.month = MonthView;
+
+  function MonthView(element, calendar) {
+    var t = this;
+
+    t.render = render;
+
+    BasicView.call(t, element, calendar, 'month');
+
+    var opt = t.opt;
+    var renderBasic = t.renderBasic;
+    var skipHiddenDays = t.skipHiddenDays;
+    var getCellsPerWeek = t.getCellsPerWeek;
+    var formatDate = calendar.formatDate;
+
+    function render(date, delta) {
+      if (delta) {
+        addMonths(date, delta);
+        date.setDate(1);
+      }
+
+      var firstDay = opt('firstDay');
+      var start = cloneDate(date, true);
+
+      start.setDate(1);
+
+      var end = addMonths(cloneDate(start), 1);
+      var visStart = cloneDate(start);
+
+      addDays(visStart, -((visStart.getDay() - firstDay + 7) % 7));
+      skipHiddenDays(visStart);
+
+      var visEnd = cloneDate(end);
+
+      addDays(visEnd, (7 - visEnd.getDay() + firstDay) % 7);
+      skipHiddenDays(visEnd, -1, true);
+
+      var colCnt = getCellsPerWeek();
+      var rowCnt = Math.round(dayDiff(visEnd, visStart) / 7);
+
+      if (opt('weekMode') === 'fixed') {
+        addDays(visEnd, (6 - rowCnt) * 7);
+        rowCnt = 6;
+      }
+
+      t.title = formatDate(start, opt('titleFormat'));
+      t.start = start;
+      t.end = end;
+      t.visStart = visStart;
+      t.visEnd = visEnd;
+
+      renderBasic(rowCnt, colCnt, true);
+    }
+  }
+
+  fcViews.basicWeek = BasicWeekView;
+
+  function BasicWeekView(element, calendar) {
+    var t = this;
+
+    t.render = render;
+
+    BasicView.call(t, element, calendar, 'basicWeek');
+
+    var opt = t.opt;
+    var renderBasic = t.renderBasic;
+    var skipHiddenDays = t.skipHiddenDays;
+    var getCellsPerWeek = t.getCellsPerWeek;
+    var formatDates = calendar.formatDates;
+
+    function render(date, delta) {
+      if (delta) addDays(date, delta * 7);
+
+      var start = addDays(cloneDate(date), -((date.getDay() - opt('firstDay') + 7) % 7));
+      var end = addDays(cloneDate(start), 7);
+      var visStart = cloneDate(start);
+
+      skipHiddenDays(visStart);
+
+      var visEnd = cloneDate(end);
+
+      skipHiddenDays(visEnd, -1, true);
+
+      var colCnt = getCellsPerWeek();
+
+      t.start = start;
+      t.end = end;
+      t.visStart = visStart;
+      t.visEnd = visEnd;
+      t.title = formatDates(
+        visStart,
+        addDays(cloneDate(visEnd), -1),
+        opt('titleFormat')
+      );
+
+      renderBasic(1, colCnt, false);
+    }
+  }
+
+  fcViews.basicDay = BasicDayView;
+
+  function BasicDayView(element, calendar) {
+    var t = this;
+
+    t.render = render;
+
+    BasicView.call(t, element, calendar, 'basicDay');
+
+    var opt = t.opt;
+    var renderBasic = t.renderBasic;
+    var skipHiddenDays = t.skipHiddenDays;
+    var formatDate = calendar.formatDate;
+
+    function render(date, delta) {
+      if (delta) addDays(date, delta);
+
+      skipHiddenDays(date, delta < 0 ? -1 : 1);
+
+      var start = cloneDate(date, true);
+      var end = addDays(cloneDate(start), 1);
+
+      t.title = formatDate(date, opt('titleFormat'));
+      t.start = t.visStart = start;
+      t.end = t.visEnd = end;
+
+      renderBasic(1, 1, false);
+    }
+  }
+
+  setDefaults({ weekMode: 'fixed' });
+
+  function BasicView(element, calendar, viewName) {
+    var t = this;
+
+    t.renderBasic = renderBasic;
+    t.setHeight = setHeight;
+    t.setWidth = setWidth;
+    t.renderDayOverlay = renderDayOverlay;
+    t.defaultSelectionEnd = defaultSelectionEnd;
+    t.renderSelection = renderSelection;
+    t.clearSelection = clearSelection;
+    t.reportDayClick = reportDayClick;
+    t.dragStart = dragStart;
+    t.dragStop = dragStop;
+    t.defaultEventEnd = defaultEventEnd;
+    t.getHoverListener = function () { return hoverListener; };
+    t.colLeft = colLeft;
+    t.colRight = colRight;
+    t.colContentLeft = colContentLeft;
+    t.colContentRight = colContentRight;
+    t.getIsCellAllDay = function () { return true; };
+    t.allDayRow = allDayRow;
+    t.getRowCnt = function () { return rowCnt; };
+    t.getColCnt = function () { return colCnt; };
+    t.getColWidth = function () { return colWidth; };
+    t.getDaySegmentContainer = function () { return daySegmentContainer; };
+
+    View.call(t, element, calendar, viewName);
+    OverlayManager.call(t);
+    SelectionManager.call(t);
+    BasicEventRenderer.call(t);
+
+    var opt = t.opt;
+    var trigger = t.trigger;
+    var renderOverlay = t.renderOverlay;
+    var clearOverlays = t.clearOverlays;
+    var daySelectionMousedown = t.daySelectionMousedown;
+    var cellToDate = t.cellToDate;
+    var dateToCell = t.dateToCell;
+    var rangeToSegments = t.rangeToSegments;
+    var formatDate = calendar.formatDate;
+    var table, head, headCells, body, bodyRows, bodyCells, bodyFirstCells, firstRowCellInners,
+      firstRowCellContentInners, daySegmentContainer, viewWidth, viewHeight, colWidth, weekNumberWidth, rowCnt, colCnt,
+      showNumbers, coordinateGrid, hoverListener, colPositions, colContentPositions, colFormat, showWeekNumbers,
+      weekNumberTitle, weekNumberFormat;
+
+    disableTextSelection(element.addClass('calendar-grid'));
+
+    function renderBasic(_rowCnt, _colCnt, _showNumbers) {
+      rowCnt = _rowCnt;
+      colCnt = _colCnt;
+      showNumbers = _showNumbers;
+
+      updateOptions();
+
+      if (!body) buildEventContainer();
+
+      buildTable();
+    }
+
+    function updateOptions() {
+      colFormat = opt('columnFormat');
+      showWeekNumbers = opt('weekNumbers');
+      weekNumberTitle = opt('weekNumberTitle');
+
+      if (opt('weekNumberCalculation') !== 'iso') {
+        weekNumberFormat = 'w';
+      } else {
+        weekNumberFormat = 'W';
+      }
+    }
+
+    function buildEventContainer() {
+      daySegmentContainer =
+        $('<div class="calendar-event-container" style="position: absolute; z-index: 8; top: 0; left: 0;"/>')
+          .appendTo(element);
+    }
+
+    function buildTable() {
+      var html = buildTableHTML();
+
+      if (table) table.remove();
+
+      table = $(html).appendTo(element);
+      head = table.find('thead');
+      headCells = head.find('.calendar-day-header');
+      body = table.find('tbody');
+      bodyRows = body.find('tr');
+      bodyCells = body.find('.calendar-day');
+      bodyFirstCells = bodyRows.find('td:first-child');
+      firstRowCellInners = bodyRows.eq(0).find('.calendar-day > div');
+      firstRowCellContentInners = bodyRows.eq(0).find('.calendar-day-content > div');
+
+      markFirstLast(head.add(head.find('tr')));
+      markFirstLast(bodyRows);
+
+      bodyRows.eq(0).addClass('calendar-first');
+      bodyRows.filter(':last').addClass('calendar-last');
+      bodyCells.each(function (i, _cell) {
+        var date = cellToDate(
+          Math.floor(i / colCnt),
+          i % colCnt
+        );
+
+        trigger('dayRender', t, date, $(_cell));
+      });
+
+      dayBind(bodyCells);
+    }
+
+    function buildTableHTML() {
+      var html =
+        '<table class="calendar-border-separate" style="width: 100%;" cellspacing="0">' +
+          buildHeadHTML() +
+          buildBodyHTML() +
+        '</table>';
+
+      return html;
+    }
+
+    function buildHeadHTML() {
+      var col, date;
+      var headerClass = 'calendar-widget-header';
+      var html = '';
+
+      html += '<thead><tr>';
+
+      if (showWeekNumbers) {
+        html +=
+          '<th class="calendar-week-number ' + headerClass + '">' +
+            htmlEscape(weekNumberTitle) +
+          '</th>';
+      }
+
+      for (col = 0; col < colCnt; col++) {
+        date = cellToDate(0, col);
+        html +=
+          '<th class="calendar-day-header calendar-' + dayIDs[date.getDay()] + ' ' + headerClass + '">' +
+            htmlEscape(formatDate(date, colFormat)) +
+          '</th>';
+      }
+
+      html += '</tr></thead>';
+
+      return html;
+    }
+
+    function buildBodyHTML() {
+      var row, col, date;
+      var contentClass = 'calendar-widget-content';
+      var html = '';
+
+      html += '<tbody>';
+
+      for (row = 0; row < rowCnt; row++) {
+        html += '<tr class="calendar-week">';
+
+        if (showWeekNumbers) {
+          date = cellToDate(row, 0);
+          html +=
+            '<td class="calendar-week-number ' + contentClass + '">' +
+              '<div>' +
+                htmlEscape(formatDate(date, weekNumberFormat)) +
+              '</div>' +
+            '</td>';
+        }
+
+        for (col = 0; col < colCnt; col++) {
+          date = cellToDate(row, col);
+          html += buildCellHTML(date);
+        }
+
+        html += '</tr>';
+      }
+
+      html += '</tbody>';
+
+      return html;
+    }
+
+    function buildCellHTML(date) {
+      var html = '';
+      var contentClass = 'calendar-widget-content';
+      var month = t.start.getMonth();
+      var today = clearTime(new Date());
+      var classNames = [
+        'calendar-day',
+        'calendar-' + dayIDs[date.getDay()],
+        contentClass
+      ];
+
+      if (date.getMonth() !== month) classNames.push('calendar-other-month');
+
+      if (+date === +today) {
+        classNames.push('calendar-today', 'calendar-state-highlight');
+      } else if (date < today) {
+        classNames.push('calendar-past');
+      } else {
+        classNames.push('calendar-future');
+      }
+
+      html +=
+        '<td class="' + classNames.join(' ') + '" data-date="' + formatDate(date, 'yyyy-MM-dd') + '"><div>';
+
+      if (showNumbers) html += '<div class="calendar-day-number">' + date.getDate() + '</div>';
+
+      html += '<div class="calendar-day-content">' +
+                '<div style="position: relative;">&nbsp;</div>' +
+              '</div>' +
+            '</div>' +
+          '</td>';
+
+      return html;
+    }
+
+    function setHeight(height) {
+      viewHeight = height;
+
+      var bodyHeight = viewHeight - head.height();
+      var cell, rowHeight, rowHeightLast;
+
+      if (opt('weekMode') === 'variable') {
+        rowHeight = rowHeightLast = Math.floor(bodyHeight / (rowCnt==1 ? 2 : 6));
+      } else {
+        rowHeight = Math.floor(bodyHeight / rowCnt);
+        rowHeightLast = bodyHeight - rowHeight * (rowCnt-1);
+      }
+
+      bodyFirstCells.each(function (i, _cell) {
+        if (i < rowCnt) {
+          cell = $(_cell);
+          cell.find('> div')
+            .css('min-height', (i==rowCnt-1 ? rowHeightLast : rowHeight) - vsides(cell));
+        }
+      });
+    }
+
+    function setWidth(width) {
+      viewWidth = width;
+
+      colPositions.clear();
+      colContentPositions.clear();
+
+      weekNumberWidth = 0;
+
+      if (showWeekNumbers) {
+        weekNumberWidth = head.find('th.calendar-week-number').outerWidth();
+      }
+
+      colWidth = Math.floor((viewWidth - weekNumberWidth) / colCnt);
+
+      setOuterWidth(headCells.slice(0, -1), colWidth);
+    }
+
+    function dayBind(days) {
+      days.click(dayClick)
+        .mousedown(daySelectionMousedown);
+    }
+
+    function dayClick(ev) {
+      if (!opt('selectable')) {
+        var date = parseISO8601($(this).data('date'));
+        trigger('dayClick', this, date, true, ev);
+      }
+    }
+
+    function renderDayOverlay(overlayStart, overlayEnd, refreshCoordinateGrid) {
+      if (refreshCoordinateGrid) coordinateGrid.build();
+
+      var segments = rangeToSegments(overlayStart, overlayEnd);
+
+      for (var i = 0; i < segments.length; i++) {
+        var segment = segments[i];
+
+        dayBind(renderCellOverlay(segment.row, segment.leftCol, segment.row, segment.rightCol));
+      }
+    }
+
+    function renderCellOverlay(row0, col0, row1, col1) {
+      var rect = coordinateGrid.rect(row0, col0, row1, col1, element);
+      return renderOverlay(rect, element);
+    }
+
+    function defaultSelectionEnd(startDate, allDay) {
+      return cloneDate(startDate);
+    }
+
+    function renderSelection(startDate, endDate, allDay) {
+      renderDayOverlay(startDate, addDays(cloneDate(endDate), 1), true);
+    }
+
+    function clearSelection() {
+      clearOverlays();
+    }
+
+    function reportDayClick(date, allDay, ev) {
+      var cell = dateToCell(date);
+      var _element = bodyCells[cell.row*colCnt + cell.col];
+
+      trigger('dayClick', _element, date, allDay, ev);
+    }
+
+    function dragStart(_dragElement, ev, ui) {
+      hoverListener.start(function (cell) {
+        clearOverlays();
+
+        if (cell) renderCellOverlay(cell.row, cell.col, cell.row, cell.col);
+      }, ev);
+    }
+
+    function dragStop(_dragElement, ev, ui) {
+      var cell = hoverListener.stop();
+
+      clearOverlays();
+
+      if (cell) {
+        var d = cellToDate(cell);
+
+        trigger('drop', _dragElement, d, true, ev, ui);
+      }
+    }
+
+    function defaultEventEnd(event) {
+      return cloneDate(event.start);
+    }
+
+    coordinateGrid = new CoordinateGrid(function (rows, cols) {
+      var e, n, p;
+
+      headCells.each(function (i, _e) {
+        e = $(_e);
+        n = e.offset().left;
+
+        if (i) {
+          p[1] = n;
+        }
+
+        p = [n];
+        cols[i] = p;
+      });
+
+      p[1] = n + e.outerWidth();
+
+      bodyRows.each(function (i, _e) {
+        if (i < rowCnt) {
+          e = $(_e);
+          n = e.offset().top;
+
+          if (i) {
+            p[1] = n;
+          }
+
+          p = [n];
+          rows[i] = p;
+        }
+      });
+
+      p[1] = n + e.outerHeight();
+    });
+
+    hoverListener = new HoverListener(coordinateGrid);
+    colPositions = new HorizontalPositionCache(function (col) {
+      return firstRowCellInners.eq(col);
+    });
+    colContentPositions = new HorizontalPositionCache(function (col) {
+      return firstRowCellContentInners.eq(col);
+    });
+
+    function colLeft(col) {
+      return colPositions.left(col);
+    }
+
+    function colRight(col) {
+      return colPositions.right(col);
+    }
+
+    function colContentLeft(col) {
+      return colContentPositions.left(col);
+    }
+
+    function colContentRight(col) {
+      return colContentPositions.right(col);
+    }
+
+    function allDayRow(i) {
+      return bodyRows.eq(i);
+    }
+  }
+
+  function BasicEventRenderer() {
+    var t = this;
+
+    t.renderEvents = renderEvents;
+    t.clearEvents = clearEvents;
+
+    DayEventRenderer.call(t);
+
+    function renderEvents(events, modifiedEventId) {
+      t.renderDayEvents(events, modifiedEventId);
+    }
+
+    function clearEvents() {
+      t.getDaySegmentContainer()
+        .empty();
+    }
+  }
+
+  fcViews.agendaWeek = AgendaWeekView;
+
+  function AgendaWeekView(element, calendar) {
+    var t = this;
+
+    t.render = render;
+
+    AgendaView.call(t, element, calendar, 'agendaWeek');
+
+    var opt = t.opt;
+    var renderAgenda = t.renderAgenda;
+    var skipHiddenDays = t.skipHiddenDays;
+    var getCellsPerWeek = t.getCellsPerWeek;
+    var formatDates = calendar.formatDates;
+
+    function render(date, delta) {
+      if (delta) addDays(date, delta * 7);
+
+      var start = addDays(cloneDate(date), -((date.getDay() - opt('firstDay') + 7) % 7));
+      var end = addDays(cloneDate(start), 7);
+      var visStart = cloneDate(start);
+
+      skipHiddenDays(visStart);
+
+      var visEnd = cloneDate(end);
+
+      skipHiddenDays(visEnd, -1, true);
+
+      var colCnt = getCellsPerWeek();
+
+      t.title = formatDates(visStart, addDays(cloneDate(visEnd), -1), opt('titleFormat'));
+      t.start = start;
+      t.end = end;
+      t.visStart = visStart;
+      t.visEnd = visEnd;
+
+      renderAgenda(colCnt);
+    }
+  }
+
+  fcViews.agendaDay = AgendaDayView;
+
+  function AgendaDayView(element, calendar) {
+    var t = this;
+
+    t.render = render;
+
+    AgendaView.call(t, element, calendar, 'agendaDay');
+
+    var opt = t.opt;
+    var renderAgenda = t.renderAgenda;
+    var skipHiddenDays = t.skipHiddenDays;
+    var formatDate = calendar.formatDate;
+
+    function render(date, delta) {
+      if (delta) addDays(date, delta);
+
+      skipHiddenDays(date, delta < 0 ? -1 : 1);
+
+      var start = cloneDate(date, true);
+      var end = addDays(cloneDate(start), 1);
+
+      t.title = formatDate(date, opt('titleFormat'));
+      t.start = t.visStart = start;
+      t.end = t.visEnd = end;
+
+      renderAgenda(1);
+    }
+  }
+
+  setDefaults({
+    allDaySlot: true,
+    allDayText: 'All-Day',
+    firstHour: 8,
+    slotMinutes: 30,
+    defaultEventMinutes: 120,
+    axisFormat: 'h(:mm)tt',
+    timeFormat: {
+      agenda: 'h:mm{ - h:mm}'
+    },
+    dragOpacity: {
+      agenda: 0.5
+    },
+    minTime: 0,
+    maxTime: 24,
+    slotEventOverlap: true
+  });
+
+  function AgendaView(element, calendar, viewName) {
+    var t = this;
+
+    t.renderAgenda = renderAgenda;
+    t.setWidth = setWidth;
+    t.setHeight = setHeight;
+    t.afterRender = afterRender;
+    t.defaultEventEnd = defaultEventEnd;
+    t.timePosition = timePosition;
+    t.getIsCellAllDay = getIsCellAllDay;
+    t.allDayRow = getAllDayRow;
+    t.getCoordinateGrid = function () { return coordinateGrid; };
+    t.getHoverListener = function () { return hoverListener; };
+    t.colLeft = colLeft;
+    t.colRight = colRight;
+    t.colContentLeft = colContentLeft;
+    t.colContentRight = colContentRight;
+    t.getDaySegmentContainer = function () { return daySegmentContainer; };
+    t.getSlotSegmentContainer = function () { return slotSegmentContainer; };
+    t.getMinMinute = function () { return minMinute; };
+    t.getMaxMinute = function () { return maxMinute; };
+    t.getSlotContainer = function () { return slotContainer; };
+    t.getRowCnt = function () { return 1; };
+    t.getColCnt = function () { return colCnt; };
+    t.getColWidth = function () { return colWidth; };
+    t.getSnapHeight = function () { return snapHeight; };
+    t.getSnapMinutes = function () { return snapMinutes; };
+    t.defaultSelectionEnd = defaultSelectionEnd;
+    t.renderDayOverlay = renderDayOverlay;
+    t.renderSelection = renderSelection;
+    t.clearSelection = clearSelection;
+    t.reportDayClick = reportDayClick;
+    t.dragStart = dragStart;
+    t.dragStop = dragStop;
+
+    View.call(t, element, calendar, viewName);
+    OverlayManager.call(t);
+    SelectionManager.call(t);
+    AgendaEventRenderer.call(t);
+
+    var opt = t.opt;
+    var trigger = t.trigger;
+    var renderOverlay = t.renderOverlay;
+    var clearOverlays = t.clearOverlays;
+    var reportSelection = t.reportSelection;
+    var unselect = t.unselect;
+    var daySelectionMousedown = t.daySelectionMousedown;
+    var slotSegHtml = t.slotSegHtml;
+    var cellToDate = t.cellToDate;
+    var dateToCell = t.dateToCell;
+    var rangeToSegments = t.rangeToSegments;
+    var formatDate = calendar.formatDate;
+    var slotTopCache = {};
+
+    var dayTable, dayHead, dayHeadCells, dayBody, dayBodyCells, dayBodyCellInners, dayBodyCellContentInners,
+      dayBodyFirstCell, dayBodyFirstCellStretcher, slotLayer, daySegmentContainer, allDayTable, allDayRow, slotScroller,
+      slotContainer, slotSegmentContainer, slotTable, selectionHelper, viewWidth, viewHeight, axisWidth, colWidth,
+      gutterWidth, slotHeight, snapMinutes, snapRatio, snapHeight, colCnt, slotCnt, coordinateGrid, hoverListener,
+      colPositions, colContentPositions, minMinute, maxMinute, colFormat, showWeekNumbers, weekNumberTitle,
+      weekNumberFormat;
+
+    disableTextSelection(element.addClass('calendar-agenda'));
+
+    function renderAgenda(c) {
+      colCnt = c;
+
+      updateOptions();
+
+      if (!dayTable) {
+        buildSkeleton();
+      } else {
+        buildDayTable();
+      }
+    }
+
+    function updateOptions() {
+      minMinute = parseTime(opt('minTime'));
+      maxMinute = parseTime(opt('maxTime'));
+      colFormat = opt('columnFormat');
+      showWeekNumbers = opt('weekNumbers');
+      weekNumberTitle = opt('weekNumberTitle');
+
+      if (opt('weekNumberCalculation') !== 'iso') {
+        weekNumberFormat = 'w';
+      } else {
+        weekNumberFormat = 'W';
+      }
+
+      snapMinutes = opt('snapMinutes') || opt('slotMinutes');
+    }
+
+    function buildSkeleton() {
+      var s, d, i, maxd, minutes;
+
+      var headerClass = 'calendar-widget-header';
+      var contentClass = 'calendar-widget-content';
+      var slotNormal = opt('slotMinutes') % 15 === 0;
+
+      buildDayTable();
+
+      slotLayer =
+        $('<div style="position: absolute; z-index: 2; left: 0; width: 100%;"/>')
+          .appendTo(element);
+
+      if (opt('allDaySlot')) {
+        daySegmentContainer =
+          $('<div class="calendar-event-container" style="position: absolute; z-index: 8; top: 0; left: 0;"/>')
+            .appendTo(slotLayer);
+
+        s = '<table style="width: 100%;" class="calendar-agenda-allday" cellspacing="0">' +
+              '<tr>' +
+                "<th class='" + headerClass + " calendar-agenda-axis'>" + opt('allDayText') + "</th>" +
+                '<td>' +
+                  '<div class="calendar-day-content"><div style="position: relative"/></div>' +
+                '</td>' +
+                '<th class="' + headerClass + ' calendar-agenda-gutter">&nbsp;</th>' +
+              '</tr>' +
+            '</table>';
+        allDayTable = $(s).appendTo(slotLayer);
+        allDayRow = allDayTable.find('tr');
+
+        dayBind(allDayRow.find('td'));
+
+        slotLayer.append(
+          '<div class="calendar-agenda-divider ' + headerClass + '">' +
+            '<div class="calendar-agenda-divider-inner"></div>' +
+          '</div>'
+        );
+      } else {
+        daySegmentContainer = $([]);
+      }
+
+      slotScroller =
+        $('<div style="position: absolute; width: 100%; overflow-x: hidden; overflow-y: auto;"/>')
+          .appendTo(slotLayer);
+      slotContainer =
+        $('<div style="position: relative; width: 100%; overflow: hidden;"/>')
+          .appendTo(slotScroller);
+      slotSegmentContainer =
+        $('<div class="calendar-event-container" style="position: absolute; z-index: 8; top: 0; left: 0;"/>')
+          .appendTo(slotContainer);
+
+      s = '<table class="calendar-agenda-slots" style="width: 100%;" cellspacing="0"> <tbody>';
+      d = zeroDate();
+      maxd = addMinutes(cloneDate(d), maxMinute);
+      slotCnt = 0;
+
+      addMinutes(d, minMinute);
+
+      for (i = 0; d < maxd; i++) {
+        minutes = d.getMinutes();
+
+        s += '<tr class="calendar-slot' + i + ' ' + (!minutes ? '' : 'calendar-minor') + '">' +
+                '<th class="calendar-agenda-axis ' + headerClass + '">' +
+                  ((!slotNormal || !minutes) ? formatDate(d, opt('axisFormat')) : '&nbsp;') +
+                '</th>' +
+                '<td class="' + contentClass + '">' +
+                  '<div style="position: relative;">&nbsp;</div>' +
+                '</td>' +
+              '</tr>';
+
+        addMinutes(d, opt('slotMinutes'));
+
+        slotCnt++;
+      }
+
+      s += '</tbody></table>';
+      slotTable = $(s).appendTo(slotContainer);
+
+      slotBind(slotTable.find('td'));
+    }
+
+    function buildDayTable() {
+      var html = buildDayTableHTML();
+
+      if (dayTable) dayTable.remove();
+
+      dayTable = $(html).appendTo(element);
+      dayHead = dayTable.find('thead');
+      dayHeadCells = dayHead.find('th').slice(1, -1);
+      dayBody = dayTable.find('tbody');
+      dayBodyCells = dayBody.find('td').slice(0, -1);
+      dayBodyCellInners = dayBodyCells.find('> div');
+      dayBodyCellContentInners = dayBodyCells.find('.calendar-day-content > div');
+      dayBodyFirstCell = dayBodyCells.eq(0);
+      dayBodyFirstCellStretcher = dayBodyCellInners.eq(0);
+
+      markFirstLast(dayHead.add(dayHead.find('tr')));
+      markFirstLast(dayBody.add(dayBody.find('tr')));
+    }
+
+    function buildDayTableHTML() {
+      var html = '<table style="width: 100%;" class="calendar-agenda-days calendar-border-separate" cellspacing="0">' +
+                    buildDayTableHeadHTML() +
+                    buildDayTableBodyHTML() +
+                  '</table>';
+
+      return html;
+    }
+
+    function buildDayTableHeadHTML() {
+      var headerClass = 'calendar-widget-header';
+      var html = '';
+      var col, date, weekText;
+
+      html += '<thead><tr>';
+
+      if (showWeekNumbers) {
+        date = cellToDate(0, 0);
+        weekText = formatDate(date, weekNumberFormat);
+        weekText = weekNumberTitle + weekText;
+
+        html += '<th class="calendar-agenda-axis calendar-week-number ' + headerClass + '">' +
+                  htmlEscape(weekText) +
+                '</th>';
+      }
+      else {
+        html += '<th class="calendar-agenda-axis ' + headerClass + '">&nbsp;</th>';
+      }
+
+      for (col = 0; col < colCnt; col++) {
+        date = cellToDate(0, col);
+        html += '<th class="calendar-' + dayIDs[date.getDay()] + ' calendar-col' + col + ' ' + headerClass + '">' +
+                  htmlEscape(formatDate(date, colFormat)) +
+                '</th>';
+      }
+
+      html += '<th class="calendar-agenda-gutter ' + headerClass + '">&nbsp;</th></tr></thead>';
+
+      return html;
+    }
+
+    function buildDayTableBodyHTML() {
+      var headerClass = 'calendar-widget-header';
+      var contentClass = 'calendar-widget-content';
+      var today = clearTime(new Date());
+      var html = '';
+      var cellsHTML = '';
+      var date, col, cellHTML, classNames;
+
+      html += '<tbody><tr><th class="calendar-agenda-axis ' + headerClass + '">&nbsp;</th>';
+
+      for (col = 0; col < colCnt; col++) {
+        date = cellToDate(0, col);
+        classNames = [
+          'calendar-col' + col,
+          'calendar-' + dayIDs[date.getDay()],
+          contentClass
+        ];
+
+        if (+date === +today) {
+          classNames.push('calendar-state-highlight', 'calendar-today');
+        } else if (date < today) {
+          classNames.push('calendar-past');
+        } else {
+          classNames.push('calendar-future');
+        }
+
+        cellHTML = '<td class="' + classNames.join(' ') + '"><div>' +
+                      '<div class="calendar-day-content">' +
+                        '<div style="position: relative;">&nbsp;</div>' +
+                      '</div>' +
+                    '</div></td>';
+
+        cellsHTML += cellHTML;
+      }
+
+      html += cellsHTML;
+      html += '<td class="calendar-agenda-gutter ' + contentClass + '">&nbsp;</td></tr></tbody>';
+
+      return html;
+    }
+
+    function setHeight(height) {
+      if (height === undefined) {
+        height = viewHeight;
+      }
+
+      viewHeight = height;
+      slotTopCache = {};
+
+      var headHeight = dayBody.position().top;
+      var allDayHeight = slotScroller.position().top;
+      var bodyHeight = Math.min(height - headHeight, slotTable.height() + allDayHeight + 1);
+
+      dayBodyFirstCellStretcher.height(bodyHeight - vsides(dayBodyFirstCell));
+      slotLayer.css('top', headHeight);
+      slotScroller.height(bodyHeight - allDayHeight - 1);
+
+      slotHeight = slotTable.find('tr:first').height() + 1;
+      snapRatio = opt('slotMinutes') / snapMinutes;
+      snapHeight = slotHeight / snapRatio;
+    }
+
+    function setWidth(width) {
+      viewWidth = width;
+
+      colPositions.clear();
+      colContentPositions.clear();
+
+      var axisFirstCells = dayHead.find('th:first');
+
+      if (allDayTable) {
+        axisFirstCells = axisFirstCells.add(allDayTable.find('th:first'));
+      }
+
+      axisFirstCells = axisFirstCells.add(slotTable.find('th:first'));
+      axisWidth = 0;
+
+      setOuterWidth(
+        axisFirstCells
+          .width('')
+          .each(function (i, _cell) {
+            axisWidth = Math.max(axisWidth, $(_cell).outerWidth());
+          }),
+        axisWidth
+      );
+
+      var gutterCells = dayTable.find('.calendar-agenda-gutter');
+
+      if (allDayTable) {
+        gutterCells = gutterCells.add(allDayTable.find('th.calendar-agenda-gutter'));
+      }
+
+      var slotTableWidth = slotScroller[0].clientWidth;
+
+      gutterWidth = slotScroller.width() - slotTableWidth;
+
+      if (gutterWidth) {
+        setOuterWidth(gutterCells, gutterWidth);
+
+        gutterCells
+          .show()
+          .prev()
+          .removeClass('calendar-last');
+      } else {
+        gutterCells
+          .hide()
+          .prev()
+          .addClass('calendar-last');
+      }
+
+      colWidth = Math.floor((slotTableWidth - axisWidth) / colCnt);
+      setOuterWidth(dayHeadCells.slice(0, -1), colWidth);
+    }
+
+    function resetScroll() {
+      var d0 = zeroDate();
+      var scrollDate = cloneDate(d0);
+
+      scrollDate.setHours(opt('firstHour'));
+
+      var top = timePosition(d0, scrollDate) + 1;
+
+      function scroll() {
+        slotScroller.scrollTop(top);
+      }
+
+      scroll();
+      setTimeout(scroll, 0);
+    }
+
+    function afterRender() {
+      resetScroll();
+    }
+
+    function dayBind(cells) {
+      cells.click(slotClick)
+        .mousedown(daySelectionMousedown);
+    }
+
+    function slotBind(cells) {
+      cells.click(slotClick)
+        .mousedown(slotSelectionMousedown);
+    }
+
+    function slotClick(ev) {
+      if (!opt('selectable')) {
+        var col = Math.min(colCnt-1, Math.floor((ev.pageX - dayTable.offset().left - axisWidth) / colWidth));
+        var date = cellToDate(0, col);
+        var rowMatch = this.parentNode.className.match(/calendar-slot(\d+)/);
+
+        if (rowMatch) {
+          var mins = parseInt(rowMatch[1]) * opt('slotMinutes');
+          var hours = Math.floor(mins / 60);
+
+          date.setHours(hours);
+          date.setMinutes(mins % 60 + minMinute);
+
+          trigger('dayClick', dayBodyCells[col], date, false, ev);
+        } else {
+          trigger('dayClick', dayBodyCells[col], date, true, ev);
+        }
+      }
+    }
+
+    function renderDayOverlay(overlayStart, overlayEnd, refreshCoordinateGrid) {
+      if (refreshCoordinateGrid) coordinateGrid.build();
+
+      var segments = rangeToSegments(overlayStart, overlayEnd);
+
+      for (var i = 0; i < segments.length; i++) {
+        var segment = segments[i];
+
+        dayBind(renderCellOverlay(segment.row, segment.leftCol, segment.row, segment.rightCol));
+      }
+    }
+
+    function renderCellOverlay(row0, col0, row1, col1) {
+      var rect = coordinateGrid.rect(row0, col0, row1, col1, slotLayer);
+      return renderOverlay(rect, slotLayer);
+    }
+
+    function renderSlotOverlay(overlayStart, overlayEnd) {
+      for (var i = 0; i < colCnt; i++) {
+        var dayStart = cellToDate(0, i);
+        var dayEnd = addDays(cloneDate(dayStart), 1);
+        var stretchStart = new Date(Math.max(dayStart, overlayStart));
+        var stretchEnd = new Date(Math.min(dayEnd, overlayEnd));
+
+        if (stretchStart < stretchEnd) {
+          var rect = coordinateGrid.rect(0, i, 0, i, slotContainer);
+          var top = timePosition(dayStart, stretchStart);
+          var bottom = timePosition(dayStart, stretchEnd);
+
+          rect.top = top;
+          rect.height = bottom - top;
+
+          slotBind(renderOverlay(rect, slotContainer));
+        }
+      }
+    }
+
+    coordinateGrid = new CoordinateGrid(function (rows, cols) {
+      var e, n, p;
+
+      dayHeadCells.each(function (i, _e) {
+        e = $(_e);
+        n = e.offset().left;
+
+        if (i) {
+          p[1] = n;
+        }
+
+        p = [n];
+        cols[i] = p;
+      });
+
+      p[1] = n + e.outerWidth();
+
+      if (opt('allDaySlot')) {
+        e = allDayRow;
+        n = e.offset().top;
+        rows[0] = [n, n+e.outerHeight()];
+      }
+
+      var slotTableTop = slotContainer.offset().top;
+      var slotScrollerTop = slotScroller.offset().top;
+      var slotScrollerBottom = slotScrollerTop + slotScroller.outerHeight();
+
+      function constrain(n) {
+        return Math.max(slotScrollerTop, Math.min(slotScrollerBottom, n));
+      }
+
+      for (var i = 0; i < slotCnt * snapRatio; i++) {
+        rows.push([
+          constrain(slotTableTop + snapHeight * i),
+          constrain(slotTableTop + snapHeight * (i + 1))
+        ]);
+      }
+    });
+
+    hoverListener = new HoverListener(coordinateGrid);
+    colPositions = new HorizontalPositionCache(function (col) {
+      return dayBodyCellInners.eq(col);
+    });
+    colContentPositions = new HorizontalPositionCache(function (col) {
+      return dayBodyCellContentInners.eq(col);
+    });
+
+    function colLeft(col) {
+      return colPositions.left(col);
+    }
+
+    function colContentLeft(col) {
+      return colContentPositions.left(col);
+    }
+
+    function colRight(col) {
+      return colPositions.right(col);
+    }
+
+    function colContentRight(col) {
+      return colContentPositions.right(col);
+    }
+
+    function getIsCellAllDay(cell) {
+      return opt('allDaySlot') && !cell.row;
+    }
+
+    function realCellToDate(cell) {
+      var d = cellToDate(0, cell.col);
+      var slotIndex = cell.row;
+
+      if (opt('allDaySlot')) slotIndex--;
+      if (slotIndex >= 0) addMinutes(d, minMinute + slotIndex * snapMinutes);
+
+      return d;
+    }
+
+    function timePosition(day, time) {
+      day = cloneDate(day, true);
+
+      if (time < addMinutes(cloneDate(day), minMinute)) return 0;
+      if (time >= addMinutes(cloneDate(day), maxMinute)) return slotTable.height();
+
+      var slotMinutes = opt('slotMinutes');
+      var minutes = time.getHours()*60 + time.getMinutes() - minMinute;
+      var slotI = Math.floor(minutes / slotMinutes);
+      var slotTop = slotTopCache[slotI];
+
+      if (slotTop === undefined) {
+        slotTop = slotTopCache[slotI] = slotTable.find('tr').eq(slotI).find('td div')[0].offsetTop;
+      }
+
+      return Math.max(0, Math.round(
+        slotTop - 1 + slotHeight * ((minutes % slotMinutes) / slotMinutes)
+      ));
+    }
+
+    function getAllDayRow(index) {
+      return allDayRow;
+    }
+
+    function defaultEventEnd(event) {
+      var start = cloneDate(event.start);
+
+      if (event.allDay) return start;
+
+      return addMinutes(start, opt('defaultEventMinutes'));
+    }
+
+    function defaultSelectionEnd(startDate, allDay) {
+      if (allDay) return cloneDate(startDate);
+
+      return addMinutes(cloneDate(startDate), opt('slotMinutes'));
+    }
+
+    function renderSelection(startDate, endDate, allDay) {
+      if (allDay) {
+        if (opt('allDaySlot')) renderDayOverlay(startDate, addDays(cloneDate(endDate), 1), true);
+      } else {
+        renderSlotSelection(startDate, endDate);
+      }
+    }
+
+    function renderSlotSelection(startDate, endDate) {
+      var helperOption = opt('selectHelper');
+
+      coordinateGrid.build();
+
+      if (helperOption) {
+        var col = dateToCell(startDate).col;
+
+        if (col >= 0 && col < colCnt) {
+          var rect = coordinateGrid.rect(0, col, 0, col, slotContainer);
+          var top = timePosition(startDate, startDate);
+          var bottom = timePosition(startDate, endDate);
+
+          if (bottom > top) {
+            rect.top = top;
+            rect.height = bottom - top;
+            rect.left += 2;
+            rect.width -= 5;
+
+            if ($.isFunction(helperOption)) {
+              var helperRes = helperOption(startDate, endDate);
+
+              if (helperRes) {
+                rect.position = 'absolute';
+                selectionHelper = $(helperRes)
+                  .css(rect)
+                  .appendTo(slotContainer);
+              }
+            } else {
+              rect.isStart = true;
+              rect.isEnd = true;
+
+              selectionHelper = $(slotSegHtml(
+                {
+                  title: '',
+                  start: startDate,
+                  end: endDate,
+                  className: ['calendar-select-helper'],
+                  editable: false
+                },
+                rect
+              ));
+              selectionHelper.css('opacity', opt('dragOpacity'));
+            }
+
+            if (selectionHelper) {
+              slotBind(selectionHelper);
+              slotContainer.append(selectionHelper);
+              setOuterWidth(selectionHelper, rect.width, true);
+              setOuterHeight(selectionHelper, rect.height, true);
+            }
+          }
+        }
+      } else {
+        renderSlotOverlay(startDate, endDate);
+      }
+    }
+
+    function clearSelection() {
+      clearOverlays();
+
+      if (selectionHelper) {
+        selectionHelper.remove();
+        selectionHelper = null;
+      }
+    }
+
+    function slotSelectionMousedown(ev) {
+      if (ev.which === 1 && opt('selectable')) {
+        var dates;
+
+        unselect(ev);
+
+        hoverListener.start(function (cell, origCell) {
+          clearSelection();
+
+          if (cell && cell.col === origCell.col && !getIsCellAllDay(cell)) {
+            var d1 = realCellToDate(origCell);
+            var d2 = realCellToDate(cell);
+
+            dates = [
+              d1,
+              addMinutes(cloneDate(d1), snapMinutes),
+              d2,
+              addMinutes(cloneDate(d2), snapMinutes)
+            ].sort(dateCompare);
+
+            renderSlotSelection(dates[0], dates[3]);
+          } else {
+            dates = null;
+          }
+        }, ev);
+
+        $(document).one('mouseup', function (ev) {
+          hoverListener.stop();
+
+          if (dates) {
+            if (+dates[0] === +dates[1]) reportDayClick(dates[0], false, ev);
+
+            reportSelection(dates[0], dates[3], false, ev);
+          }
+        });
+      }
+    }
+
+    function reportDayClick(date, allDay, ev) {
+      trigger('dayClick', dayBodyCells[dateToCell(date).col], date, allDay, ev);
+    }
+
+    function dragStart(_dragElement, ev, ui) {
+      hoverListener.start(function (cell) {
+        clearOverlays();
+
+        if (cell) {
+          if (getIsCellAllDay(cell)) {
+            renderCellOverlay(cell.row, cell.col, cell.row, cell.col);
+          } else {
+            var d1 = realCellToDate(cell);
+            var d2 = addMinutes(cloneDate(d1), opt('defaultEventMinutes'));
+
+            renderSlotOverlay(d1, d2);
+          }
+        }
+      }, ev);
+    }
+
+    function dragStop(_dragElement, ev, ui) {
+      var cell = hoverListener.stop();
+
+      clearOverlays();
+
+      if (cell) trigger('drop', _dragElement, realCellToDate(cell), getIsCellAllDay(cell), ev, ui);
+    }
+  }
+
+  function AgendaEventRenderer() {
+    var t = this;
+
+    t.renderEvents = renderEvents;
+    t.clearEvents = clearEvents;
+    t.slotSegHtml = slotSegHtml;
+
+    DayEventRenderer.call(t);
+
+    var opt = t.opt;
+    var trigger = t.trigger;
+    var isEventDraggable = t.isEventDraggable;
+    var isEventResizable = t.isEventResizable;
+    var eventEnd = t.eventEnd;
+    var eventElementHandlers = t.eventElementHandlers;
+    var setHeight = t.setHeight;
+    var getDaySegmentContainer = t.getDaySegmentContainer;
+    var getSlotSegmentContainer = t.getSlotSegmentContainer;
+    var getHoverListener = t.getHoverListener;
+    var getMaxMinute = t.getMaxMinute;
+    var getMinMinute = t.getMinMinute;
+    var timePosition = t.timePosition;
+    var getIsCellAllDay = t.getIsCellAllDay;
+    var colContentLeft = t.colContentLeft;
+    var colContentRight = t.colContentRight;
+    var cellToDate = t.cellToDate;
+    var getColCnt = t.getColCnt;
+    var getColWidth = t.getColWidth;
+    var getSnapHeight = t.getSnapHeight;
+    var getSnapMinutes = t.getSnapMinutes;
+    var getSlotContainer = t.getSlotContainer;
+    var reportEventElement = t.reportEventElement;
+    var showEvents = t.showEvents;
+    var hideEvents = t.hideEvents;
+    var eventDrop = t.eventDrop;
+    var eventResize = t.eventResize;
+    var renderDayOverlay = t.renderDayOverlay;
+    var clearOverlays = t.clearOverlays;
+    var renderDayEvents = t.renderDayEvents;
+    var calendar = t.calendar;
+    var formatDate = calendar.formatDate;
+    var formatDates = calendar.formatDates;
+
+    t.draggableDayEvent = draggableDayEvent;
+
+    function renderEvents(events, modifiedEventId) {
+      var len = events.length;
+      var dayEvents = [];
+      var slotEvents = [];
+
+      for (var i = 0; i < len; i++) {
+        if (events[i].allDay) {
+          dayEvents.push(events[i]);
+        } else {
+          slotEvents.push(events[i]);
+        }
+      }
+
+      if (opt('allDaySlot')) {
+        renderDayEvents(dayEvents, modifiedEventId);
+        setHeight();
+      }
+
+      renderSlotSegs(compileSlotSegs(slotEvents), modifiedEventId);
+    }
+
+    function clearEvents() {
+      getDaySegmentContainer().empty();
+      getSlotSegmentContainer().empty();
+    }
+
+    function compileSlotSegs(events) {
+      var d, seg, colSegs;
+      var colCnt = getColCnt();
+      var minMinute = getMinMinute();
+      var maxMinute = getMaxMinute();
+      var visEventEnds = $.map(events, slotEventEnd);
+      var segs = [];
+
+      for (var i = 0; i < colCnt; i++) {
+        d = cellToDate(0, i);
+
+        addMinutes(d, minMinute);
+
+        colSegs = sliceSegs(events, visEventEnds, d, addMinutes(cloneDate(d), maxMinute-minMinute));
+        colSegs = placeSlotSegs(colSegs);
+
+        for (var j = 0; j < colSegs.length; j++) {
+          seg = colSegs[j];
+          seg.col = i;
+          segs.push(seg);
+        }
+      }
+
+      return segs;
+    }
+
+    function sliceSegs(events, visEventEnds, start, end) {
+      var segs = [];
+      var len=events.length;
+      var event, eventStart, eventEnd, segStart, segEnd, isStart, isEnd;
+
+      for (var i = 0; i < len; i++) {
+        event = events[i];
+        eventStart = event.start;
+        eventEnd = visEventEnds[i];
+
+        if (eventEnd > start && eventStart < end) {
+          if (eventStart < start) {
+            segStart = cloneDate(start);
+            isStart = false;
+          } else {
+            segStart = eventStart;
+            isStart = true;
+          }
+
+          if (eventEnd > end) {
+            segEnd = cloneDate(end);
+            isEnd = false;
+          } else {
+            segEnd = eventEnd;
+            isEnd = true;
+          }
+
+          segs.push({
+            event: event,
+            start: segStart,
+            end: segEnd,
+            isStart: isStart,
+            isEnd: isEnd
+          });
+        }
+      }
+
+      return segs.sort(compareSlotSegs);
+    }
+
+    function slotEventEnd(event) {
+      if (event.end) {
+        return cloneDate(event.end);
+      } else {
+        return addMinutes(cloneDate(event.start), opt('defaultEventMinutes'));
+      }
+    }
+
+    function renderSlotSegs(segs, modifiedEventId) {
+      var segCnt = segs.length;
+      var html = '';
+      var slotSegmentContainer = getSlotSegmentContainer();
+      var seg, i, event, top, bottom, columnLeft, columnRight, columnWidth, width, left, right, eventElements,
+        eventElement, triggerRes, titleElement, height;
+
+      for (i = 0; i < segCnt; i++) {
+        seg = segs[i];
+        event = seg.event;
+        top = timePosition(seg.start, seg.start);
+        bottom = timePosition(seg.start, seg.end);
+        columnLeft = colContentLeft(seg.col);
+        columnRight = colContentRight(seg.col);
+        columnWidth = columnRight - columnLeft;
+        columnRight -= columnWidth * 0.025;
+        columnWidth = columnRight - columnLeft;
+        width = columnWidth * (seg.forwardCoord - seg.backwardCoord);
+
+        if (opt('slotEventOverlap')) {
+          width = Math.max((width - (20/2)) * 2, width);
+        }
+
+        left = columnLeft + seg.backwardCoord * columnWidth;
+        right = left + width;
+        left = Math.max(left, columnLeft);
+        right = Math.min(right, columnRight);
+        width = right - left;
+
+        seg.top = top;
+        seg.left = left;
+        seg.outerWidth = width;
+        seg.outerHeight = bottom - top;
+
+        html += slotSegHtml(event, seg);
+      }
+
+      slotSegmentContainer[0].innerHTML = html;
+      eventElements = slotSegmentContainer.children();
+
+      for (i = 0; i < segCnt; i++) {
+        seg = segs[i];
+        event = seg.event;
+        eventElement = $(eventElements[i]);
+        triggerRes = trigger('eventRender', event, event, eventElement);
+
+        if (triggerRes === false) {
+          eventElement.remove();
+        } else {
+          if (triggerRes && triggerRes !== true) {
+            eventElement.remove();
+            eventElement = $(triggerRes)
+              .css({
+                position: 'absolute',
+                top: seg.top,
+                left: seg.left
+              })
+              .appendTo(slotSegmentContainer);
+          }
+
+          seg.element = eventElement;
+
+          if (event._id === modifiedEventId) {
+            bindSlotSeg(event, eventElement, seg);
+          } else {
+            eventElement[0]._fci = i;
+          }
+
+          reportEventElement(event, eventElement);
+        }
+      }
+
+      lazySegBind(slotSegmentContainer, segs, bindSlotSeg);
+
+      for (i = 0; i < segCnt; i++) {
+        seg = segs[i];
+
+        if (eventElement = seg.element) {
+          seg.vsides = vsides(eventElement, true);
+          seg.hsides = hsides(eventElement, true);
+
+          titleElement = eventElement.find('.calendar-event-title');
+
+          if (titleElement.length) {
+            seg.contentTop = titleElement[0].offsetTop;
+          }
+        }
+      }
+
+      for (i = 0; i < segCnt; i++) {
+        seg = segs[i];
+
+        if (eventElement = seg.element) {
+          eventElement[0].style.width = Math.max(0, seg.outerWidth - seg.hsides) + 'px';
+          height = Math.max(0, seg.outerHeight - seg.vsides);
+          eventElement[0].style.height = height + 'px';
+          event = seg.event;
+
+          if (seg.contentTop !== undefined && height - seg.contentTop < 10) {
+            eventElement.find('div.calendar-event-time')
+              .text(formatDate(event.start, opt('timeFormat')) + ' - ' + event.title);
+            eventElement.find('div.calendar-event-title')
+              .remove();
+          }
+
+          trigger('eventAfterRender', event, event, eventElement);
+        }
+      }
+    }
+
+    function slotSegHtml(event, seg) {
+      var html = '<';
+      var url = event.url;
+      var skinCss = getSkinCss(event, opt);
+      var classes = ['calendar-event', 'calendar-event-vert'];
+
+      if (isEventDraggable(event)) classes.push('calendar-event-draggable');
+      if (seg.isStart) classes.push('calendar-event-start');
+      if (seg.isEnd) classes.push('calendar-event-end');
+
+      classes = classes.concat(event.className);
+
+      if (event.source) {
+        classes = classes.concat(event.source.className || []);
+      }
+
+      if (url) {
+        html += 'a href="' + htmlEscape(event.url) + '"';
+      } else {
+        html += 'div';
+      }
+
+      html += ' class="' + classes.join(' ') + '" style="position: absolute; ' +
+        'top:' + seg.top + 'px; ' +
+        'left:' + seg.left + 'px; ' +
+        skinCss +
+        "'>" +
+        '<div class="calendar-event-inner">' +
+          '<div class="calendar-event-time">' +
+            htmlEscape(formatDates(event.start, event.end, opt('timeFormat'))) +
+          '</div>' +
+          '<div class="calendar-event-title">' +
+            htmlEscape(event.title || '') +
+          '</div>' +
+        '</div>' +
+        '<div class="calendar-event-bg"></div>';
+
+      html += '</' + (url ? 'a' : 'div') + '>';
+
+      return html;
+    }
+
+    function bindSlotSeg(event, eventElement, seg) {
+      var timeElement = eventElement.find('div.calendar-event-time');
+
+      if (isEventDraggable(event)) draggableSlotEvent(event, eventElement, timeElement);
+      if (seg.isEnd && isEventResizable(event)) resizableSlotEvent(event, eventElement, timeElement);
+
+      eventElementHandlers(event, eventElement);
+    }
+
+    function draggableDayEvent(event, eventElement, seg) {
+      var isStart = seg.isStart;
+      var allDay = true;
+      var hoverListener = getHoverListener();
+      var colWidth = getColWidth();
+      var snapHeight = getSnapHeight();
+      var snapMinutes = getSnapMinutes();
+      var minMinute = getMinMinute();
+      var origWidth, revert, dayDelta;
+
+      eventElement.draggable({
+        opacity: opt('dragOpacity', 'month'),
+        revertDuration: opt('dragRevertDuration'),
+        start: function (ev, ui) {
+          trigger('eventDragStart', eventElement, event, ev, ui);
+          hideEvents(event, eventElement);
+
+          origWidth = eventElement.width();
+
+          hoverListener.start(function (cell, origCell) {
+            clearOverlays();
+
+            if (cell) {
+              revert = false;
+
+              var origDate = cellToDate(0, origCell.col);
+              var date = cellToDate(0, cell.col);
+
+              dayDelta = dayDiff(date, origDate);
+
+              if (!cell.row) {
+                renderDayOverlay(addDays(cloneDate(event.start), dayDelta), addDays(exclEndDay(event), dayDelta));
+                resetElement();
+              } else {
+                if (isStart) {
+                  if (allDay) {
+                    eventElement.width(colWidth - 10);
+
+                    setOuterHeight(
+                      eventElement,
+                      snapHeight * Math.round(
+                        (event.end ? ((event.end - event.start) / MINUTE_MS) : opt('defaultEventMinutes')) /
+                          snapMinutes
+                      )
+                    );
+
+                    eventElement.draggable('option', 'grid', [colWidth, 1]);
+
+                    allDay = false;
+                  }
+                } else {
+                  revert = true;
+                }
+              }
+
+              revert = revert || (allDay && !dayDelta);
+            } else {
+              resetElement();
+              revert = true;
+            }
+
+            eventElement.draggable('option', 'revert', revert);
+          }, ev, 'drag');
+        },
+        stop: function (ev, ui) {
+          hoverListener.stop();
+          clearOverlays();
+          trigger('eventDragStop', eventElement, event, ev, ui);
+
+          if (revert) {
+            resetElement();
+            eventElement.css('filter', '');
+            showEvents(event, eventElement);
+          } else {
+            var minuteDelta = 0;
+
+            if (!allDay) {
+              minuteDelta = Math.round((eventElement.offset().top - getSlotContainer().offset().top) / snapHeight) *
+                snapMinutes +
+                minMinute -
+                (event.start.getHours() * 60 + event.start.getMinutes());
+            }
+
+            eventDrop(this, event, dayDelta, minuteDelta, allDay, ev, ui);
+          }
+        }
+      });
+
+      function resetElement() {
+        if (!allDay) {
+          eventElement
+            .width(origWidth)
+            .height('')
+            .draggable('option', 'grid', null);
+
+          allDay = true;
+        }
+      }
+    }
+
+    function draggableSlotEvent(event, eventElement, timeElement) {
+      var coordinateGrid = t.getCoordinateGrid();
+      var colCnt = getColCnt();
+      var colWidth = getColWidth();
+      var snapHeight = getSnapHeight();
+      var snapMinutes = getSnapMinutes();
+      var origPosition, origCell, isInBounds, prevIsInBounds, isAllDay, prevIsAllDay, colDelta, prevColDelta, dayDelta,
+        minuteDelta, prevMinuteDelta;
+
+      eventElement.draggable({
+        scroll: false,
+        grid: [colWidth, snapHeight],
+        axis: colCnt == 1 ? 'y' : false,
+        opacity: opt('dragOpacity'),
+        revertDuration: opt('dragRevertDuration'),
+        start: function (ev, ui) {
+          trigger('eventDragStart', eventElement, event, ev, ui);
+          hideEvents(event, eventElement);
+
+          coordinateGrid.build();
+
+          origPosition = eventElement.position();
+          origCell = coordinateGrid.cell(ev.pageX, ev.pageY);
+          isInBounds = prevIsInBounds = true;
+          isAllDay = prevIsAllDay = getIsCellAllDay(origCell);
+          colDelta = prevColDelta = 0;
+          dayDelta = 0;
+          minuteDelta = prevMinuteDelta = 0;
+        },
+        drag: function (ev, ui) {
+          var cell = coordinateGrid.cell(ev.pageX, ev.pageY);
+
+          isInBounds = !!cell;
+
+          if (isInBounds) {
+            isAllDay = getIsCellAllDay(cell);
+            colDelta = Math.round((ui.position.left - origPosition.left) / colWidth);
+
+            if (colDelta !== prevColDelta) {
+              var origDate = cellToDate(0, origCell.col);
+              var col = origCell.col + colDelta;
+
+              col = Math.max(0, col);
+              col = Math.min(colCnt-1, col);
+
+              var date = cellToDate(0, col);
+
+              dayDelta = dayDiff(date, origDate);
+            }
+
+            if (!isAllDay) {
+              minuteDelta = Math.round((ui.position.top - origPosition.top) / snapHeight) * snapMinutes;
+            }
+          }
+
+          if (
+            isInBounds !== prevIsInBounds ||
+            isAllDay !== prevIsAllDay ||
+            colDelta !== prevColDelta ||
+            minuteDelta !== prevMinuteDelta
+          ) {
+            updateUI();
+
+            prevIsInBounds = isInBounds;
+            prevIsAllDay = isAllDay;
+            prevColDelta = colDelta;
+            prevMinuteDelta = minuteDelta;
+          }
+
+          eventElement.draggable('option', 'revert', !isInBounds);
+        },
+        stop: function (ev, ui) {
+          clearOverlays();
+          trigger('eventDragStop', eventElement, event, ev, ui);
+
+          if (isInBounds && (isAllDay || dayDelta || minuteDelta)) {
+            eventDrop(this, event, dayDelta, isAllDay ? 0 : minuteDelta, isAllDay, ev, ui);
+          } else {
+            isInBounds = true;
+            isAllDay = false;
+            colDelta = 0;
+            dayDelta = 0;
+            minuteDelta = 0;
+
+            updateUI();
+
+            eventElement.css('filter', '');
+            eventElement.css(origPosition);
+
+            showEvents(event, eventElement);
+          }
+        }
+      });
+
+      function updateUI() {
+        clearOverlays();
+
+        if (isInBounds) {
+          if (isAllDay) {
+            timeElement.hide();
+            eventElement.draggable('option', 'grid', null);
+            renderDayOverlay(addDays(cloneDate(event.start), dayDelta), addDays(exclEndDay(event), dayDelta));
+          }
+          else {
+            updateTimeText(minuteDelta);
+            timeElement.css('display', '');
+            eventElement.draggable('option', 'grid', [colWidth, snapHeight]);
+          }
+        }
+      }
+
+      function updateTimeText(minuteDelta) {
+        var newStart = addMinutes(cloneDate(event.start), minuteDelta);
+        var newEnd;
+
+        if (event.end) {
+          newEnd = addMinutes(cloneDate(event.end), minuteDelta);
+        }
+
+        timeElement.text(formatDates(newStart, newEnd, opt('timeFormat')));
+      }
+    }
+
+    function resizableSlotEvent(event, eventElement, timeElement) {
+      var snapDelta, prevSnapDelta;
+      var snapHeight = getSnapHeight();
+      var snapMinutes = getSnapMinutes();
+
+      eventElement.resizable({
+        handles: { s: '.ui-resizable-handle' },
+        grid: snapHeight,
+        start: function (ev, ui) {
+          snapDelta = prevSnapDelta = 0;
+
+          hideEvents(event, eventElement);
+          trigger('eventResizeStart', this, event, ev, ui);
+        },
+        resize: function (ev, ui) {
+          snapDelta = Math.round((Math.max(snapHeight, eventElement.height()) - ui.originalSize.height) / snapHeight);
+
+          if (snapDelta !== prevSnapDelta) {
+            timeElement.text(
+              formatDates(
+                event.start,
+                (!snapDelta && !event.end) ? null : addMinutes(eventEnd(event), snapMinutes*snapDelta),
+                opt('timeFormat')
+              )
+            );
+
+            prevSnapDelta = snapDelta;
+          }
+        },
+        stop: function (ev, ui) {
+          trigger('eventResizeStop', this, event, ev, ui);
+
+          if (snapDelta) {
+            eventResize(this, event, 0, snapMinutes*snapDelta, ev, ui);
+          } else {
+            showEvents(event, eventElement);
+          }
+        }
+      });
+    }
+  }
+
+  function placeSlotSegs(segs) {
+    var levels = buildSlotSegLevels(segs);
+    var level0 = levels[0];
+    var i;
+
+    computeForwardSlotSegs(levels);
+
+    if (level0) {
+      for (i = 0; i < level0.length; i++) {
+        computeSlotSegPressures(level0[i]);
+      }
+      for (i = 0; i < level0.length; i++) {
+        computeSlotSegCoords(level0[i], 0, 0);
+      }
+    }
+
+    return flattenSlotSegLevels(levels);
+  }
+
+  function buildSlotSegLevels(segs) {
+    var levels = [];
+    var i, j, seg;
+
+    for (i = 0; i < segs.length; i++) {
+      seg = segs[i];
+
+      for (j = 0; j < levels.length; j++) {
+        if (!computeSlotSegCollisions(seg, levels[j]).length) break;
+      }
+
+      (levels[j] || (levels[j] = [])).push(seg);
+    }
+
+    return levels;
+  }
+
+  function computeForwardSlotSegs(levels) {
+    var level, seg;
+
+    for (var i = 0; i < levels.length; i++) {
+      level = levels[i];
+
+      for (var j = 0; j < level.length; j++) {
+        seg = level[j];
+
+        seg.forwardSegs = [];
+
+        for (var k = i + 1; k < levels.length; k++) {
+          computeSlotSegCollisions(seg, levels[k], seg.forwardSegs);
+        }
+      }
+    }
+  }
+
+  function computeSlotSegPressures(seg) {
+    var forwardSegs = seg.forwardSegs;
+    var forwardPressure = 0;
+    var forwardSeg;
+
+    if (seg.forwardPressure === undefined) {
+
+      for (var i = 0; i < forwardSegs.length; i++) {
+        forwardSeg = forwardSegs[i];
+
+        computeSlotSegPressures(forwardSeg);
+
+        forwardPressure = Math.max(forwardPressure, 1 + forwardSeg.forwardPressure);
+      }
+
+      seg.forwardPressure = forwardPressure;
+    }
+  }
+
+  function computeSlotSegCoords(seg, seriesBackwardPressure, seriesBackwardCoord) {
+    var forwardSegs = seg.forwardSegs;
+
+    if (seg.forwardCoord === undefined) {
+      if (!forwardSegs.length) {
+        seg.forwardCoord = 1;
+      } else {
+        forwardSegs.sort(compareForwardSlotSegs);
+
+        computeSlotSegCoords(forwardSegs[0], seriesBackwardPressure + 1, seriesBackwardCoord);
+
+        seg.forwardCoord = forwardSegs[0].backwardCoord;
+      }
+
+      seg.backwardCoord = seg.forwardCoord -
+        (seg.forwardCoord - seriesBackwardCoord) /
+        (seriesBackwardPressure + 1);
+
+      for (var i = 0; i < forwardSegs.length; i++) {
+        computeSlotSegCoords(forwardSegs[i], 0, seg.forwardCoord);
+      }
+    }
+  }
+
+  function flattenSlotSegLevels(levels) {
+    var segs = [];
+    var level;
+
+    for (var i = 0; i < levels.length; i++) {
+      level = levels[i];
+
+      for (var j = 0; j < level.length; j++) {
+        segs.push(level[j]);
+      }
+    }
+
+    return segs;
+  }
+
+  function computeSlotSegCollisions(seg, otherSegs, results) {
+    results = results || [];
+
+    for (var i = 0; i < otherSegs.length; i++) {
+      if (isSlotSegCollision(seg, otherSegs[i])) results.push(otherSegs[i]);
+    }
+
+    return results;
+  }
+
+  function isSlotSegCollision(seg1, seg2) {
+    return seg1.end > seg2.start && seg1.start < seg2.end;
+  }
+
+  function compareForwardSlotSegs(seg1, seg2) {
+    return seg2.forwardPressure - seg1.forwardPressure ||
+      (seg1.backwardCoord || 0) - (seg2.backwardCoord || 0) ||
+      compareSlotSegs(seg1, seg2);
+  }
+
+  function compareSlotSegs(seg1, seg2) {
+    return seg1.start - seg2.start ||
+      (seg2.end - seg2.start) - (seg1.end - seg1.start) ||
+      (seg1.event.title || '').localeCompare(seg2.event.title);
+  }
+
+  function View(element, calendar, viewName) {
+    var t = this;
+
+    t.element = element;
+    t.calendar = calendar;
+    t.name = viewName;
+    t.opt = opt;
+    t.trigger = trigger;
+    t.isEventDraggable = isEventDraggable;
+    t.isEventResizable = isEventResizable;
+    t.setEventData = setEventData;
+    t.clearEventData = clearEventData;
+    t.eventEnd = eventEnd;
+    t.reportEventElement = reportEventElement;
+    t.triggerEventDestroy = triggerEventDestroy;
+    t.eventElementHandlers = eventElementHandlers;
+    t.showEvents = showEvents;
+    t.hideEvents = hideEvents;
+    t.eventDrop = eventDrop;
+    t.eventResize = eventResize;
+
+    var defaultEventEnd = t.defaultEventEnd;
+    var normalizeEvent = calendar.normalizeEvent;
+    var reportEventChange = calendar.reportEventChange;
+    var eventsByID = {};
+    var eventElementsByID = {};
+    var eventElementCouples = [];
+    var options = calendar.options;
+
+    function opt(name, viewNameOverride) {
+      var v = options[name];
+
+      if ($.isPlainObject(v)) return smartProperty(v, viewNameOverride || viewName);
+      return v;
+    }
+
+    function trigger(name, thisObj) {
+      return calendar.trigger.apply(
+        calendar,
+        [name, thisObj || t].concat(Array.prototype.slice.call(arguments, 2), [t])
+      );
+    }
+
+    function isEventDraggable(event) {
+      var source = event.source || {};
+
+      return firstDefined(
+          event.startEditable,
+          source.startEditable,
+          opt('eventStartEditable'),
+          event.editable,
+          source.editable,
+          opt('editable')
+        ) &&
+        !opt('disableDragging');
+    }
+
+    function isEventResizable(event) {
+      var source = event.source || {};
+
+      return firstDefined(
+          event.durationEditable,
+          source.durationEditable,
+          opt('eventDurationEditable'),
+          event.editable,
+          source.editable,
+          opt('editable')
+        ) &&
+        !opt('disableResizing');
+    }
+
+    function setEventData(events) {
+      var len = events.length;
+      var event;
+
+      eventsByID = {};
+
+      for (var i = 0; i < len; i++) {
+        event = events[i];
+
+        if (eventsByID[event._id]) {
+          eventsByID[event._id].push(event);
+        } else {
+          eventsByID[event._id] = [event];
+        }
+      }
+    }
+
+    function clearEventData() {
+      eventsByID = {};
+      eventElementsByID = {};
+      eventElementCouples = [];
+    }
+
+    function eventEnd(event) {
+      return event.end ? cloneDate(event.end) : defaultEventEnd(event);
+    }
+
+    function reportEventElement(event, element) {
+      eventElementCouples.push({ event: event, element: element });
+
+      if (eventElementsByID[event._id]) {
+        eventElementsByID[event._id].push(element);
+      } else {
+        eventElementsByID[event._id] = [element];
+      }
+    }
+
+    function triggerEventDestroy() {
+      $.each(eventElementCouples, function (i, couple) {
+        t.trigger('eventDestroy', couple.event, couple.event, couple.element);
+      });
+    }
+
+    function eventElementHandlers(event, eventElement) {
+      eventElement
+        .click(function (ev) {
+          if (!eventElement.hasClass('ui-draggable-dragging') && !eventElement.hasClass('ui-resizable-resizing')) {
+            return trigger('eventClick', this, event, ev);
+          }
+        })
+        .hover(
+          function (ev) {
+            trigger('eventMouseover', this, event, ev);
+          },
+          function (ev) {
+            trigger('eventMouseout', this, event, ev);
+          }
+        );
+    }
+
+    function showEvents(event, exceptElement) {
+      eachEventElement(event, exceptElement, 'show');
+    }
+
+    function hideEvents(event, exceptElement) {
+      eachEventElement(event, exceptElement, 'hide');
+    }
+
+    function eachEventElement(event, exceptElement, funcName) {
+      var elements = eventElementsByID[event._id];
+      var len = elements.length;
+
+      for (var i = 0; i < len; i++) {
+        if (!exceptElement || elements[i][0] !== exceptElement[0]) elements[i][funcName]();
+      }
+    }
+
+    function eventDrop(e, event, dayDelta, minuteDelta, allDay, ev, ui) {
+      var oldAllDay = event.allDay;
+      var eventId = event._id;
+
+      moveEvents(eventsByID[eventId], dayDelta, minuteDelta, allDay);
+      trigger(
+        'eventDrop',
+        e,
+        event,
+        dayDelta,
+        minuteDelta,
+        allDay,
+        function () {
+          moveEvents(eventsByID[eventId], -dayDelta, -minuteDelta, oldAllDay);
+          reportEventChange(eventId);
+        },
+        ev,
+        ui
+      );
+      reportEventChange(eventId);
+    }
+
+    function eventResize(e, event, dayDelta, minuteDelta, ev, ui) {
+      var eventId = event._id;
+
+      elongateEvents(eventsByID[eventId], dayDelta, minuteDelta);
+      trigger(
+        'eventResize',
+        e,
+        event,
+        dayDelta,
+        minuteDelta,
+        function () {
+          elongateEvents(eventsByID[eventId], -dayDelta, -minuteDelta);
+          reportEventChange(eventId);
+        },
+        ev,
+        ui
+      );
+      reportEventChange(eventId);
+    }
+
+    function moveEvents(events, dayDelta, minuteDelta, allDay) {
+      var len = events.length;
+      var e;
+
+      minuteDelta = minuteDelta || 0;
+
+      for (var i = 0; i < len; i++) {
+        e = events[i];
+
+        if (allDay !== undefined) {
+          e.allDay = allDay;
+        }
+
+        addMinutes(addDays(e.start, dayDelta, true), minuteDelta);
+
+        if (e.end) {
+          e.end = addMinutes(addDays(e.end, dayDelta, true), minuteDelta);
+        }
+
+        normalizeEvent(e, options);
+      }
+    }
+
+    function elongateEvents(events, dayDelta, minuteDelta) {
+      var len = events.length;
+      var e;
+
+      minuteDelta = minuteDelta || 0;
+
+      for (var i = 0; i < len; i++) {
+        e = events[i];
+        e.end = addMinutes(addDays(eventEnd(e), dayDelta, true), minuteDelta);
+        normalizeEvent(e, options);
+      }
+    }
+
+    t.isHiddenDay = isHiddenDay;
+    t.skipHiddenDays = skipHiddenDays;
+    t.getCellsPerWeek = getCellsPerWeek;
+    t.dateToCell = dateToCell;
+    t.dateToDayOffset = dateToDayOffset;
+    t.dayOffsetToCellOffset = dayOffsetToCellOffset;
+    t.cellOffsetToCell = cellOffsetToCell;
+    t.cellToDate = cellToDate;
+    t.cellToCellOffset = cellToCellOffset;
+    t.cellOffsetToDayOffset = cellOffsetToDayOffset;
+    t.dayOffsetToDate = dayOffsetToDate;
+    t.rangeToSegments = rangeToSegments;
+
+    var hiddenDays = opt('hiddenDays') || [];
+    var isHiddenDayHash = [];
+    var dayToCellMap = [];
+    var cellToDayMap = [];
+    var cellsPerWeek;
+
+    (function () {
+      if (opt('weekends') === false) hiddenDays.push(0, 6);
+
+      for (var dayIndex=0, cellIndex=0; dayIndex<7; dayIndex++) {
+        dayToCellMap[dayIndex] = cellIndex;
+        isHiddenDayHash[dayIndex] = $.inArray(dayIndex, hiddenDays) !== -1;
+
+        if (!isHiddenDayHash[dayIndex]) {
+          cellToDayMap[cellIndex] = dayIndex;
+          cellIndex++;
+        }
+      }
+
+      cellsPerWeek = cellIndex;
+
+      if (!cellsPerWeek) throw 'invalid hiddenDays';
+    })();
+
+    function isHiddenDay(day) {
+      if (typeof day === 'object') {
+        day = day.getDay();
+      }
+
+      return isHiddenDayHash[day];
+    }
+
+    function getCellsPerWeek() {
+      return cellsPerWeek;
+    }
+
+    function skipHiddenDays(date, inc, isExclusive) {
+      inc = inc || 1;
+
+      while (isHiddenDayHash[(date.getDay() + (isExclusive ? inc : 0) + 7) % 7 ]) {
+        addDays(date, inc);
+      }
+    }
+
+    function cellToDate() {
+      var cellOffset = cellToCellOffset.apply(null, arguments);
+      var dayOffset = cellOffsetToDayOffset(cellOffset);
+      var date = dayOffsetToDate(dayOffset);
+      return date;
+    }
+
+    function cellToCellOffset(row, col) {
+      var colCnt = t.getColCnt();
+      var dis = 1;
+      var dit = 0;
+
+      if (typeof row === 'object') {
+        col = row.col;
+        row = row.row;
+      }
+
+      return row * colCnt + (col * dis + dit);
+    }
+
+    function cellOffsetToDayOffset(cellOffset) {
+      var day0 = t.visStart.getDay();
+
+      cellOffset += dayToCellMap[day0];
+
+      return Math.floor(cellOffset / cellsPerWeek) *
+        7 +
+        cellToDayMap[(cellOffset % cellsPerWeek + cellsPerWeek) % cellsPerWeek] -
+        day0;
+    }
+
+    function dayOffsetToDate(dayOffset) {
+      var date = cloneDate(t.visStart);
+
+      addDays(date, dayOffset);
+      return date;
+    }
+
+    function dateToCell(date) {
+      var dayOffset = dateToDayOffset(date);
+      var cellOffset = dayOffsetToCellOffset(dayOffset);
+      var cell = cellOffsetToCell(cellOffset);
+      return cell;
+    }
+
+    function dateToDayOffset(date) {
+      return dayDiff(date, t.visStart);
+    }
+
+    function dayOffsetToCellOffset(dayOffset) {
+      var day0 = t.visStart.getDay();
+
+      dayOffset += day0;
+
+      return Math.floor(dayOffset / 7) *
+        cellsPerWeek +
+        dayToCellMap[(dayOffset % 7 + 7) % 7] -
+        dayToCellMap[day0];
+    }
+
+    function cellOffsetToCell(cellOffset) {
+      var colCnt = t.getColCnt();
+      var dis = 1;
+      var dit = 0;
+      var row = Math.floor(cellOffset / colCnt);
+      var col = ((cellOffset % colCnt + colCnt) % colCnt) * dis + dit;
+
+      return {
+        row: row,
+        col: col
+      };
+    }
+
+    function rangeToSegments(startDate, endDate) {
+      var rowCnt = t.getRowCnt();
+      var colCnt = t.getColCnt();
+      var segments = [];
+      var rangeDayOffsetStart = dateToDayOffset(startDate);
+      var rangeDayOffsetEnd = dateToDayOffset(endDate);
+      var rangeCellOffsetFirst = dayOffsetToCellOffset(rangeDayOffsetStart);
+      var rangeCellOffsetLast = dayOffsetToCellOffset(rangeDayOffsetEnd) - 1;
+
+      for (var row = 0; row < rowCnt; row++) {
+        var rowCellOffsetFirst = row * colCnt;
+        var rowCellOffsetLast = rowCellOffsetFirst + colCnt - 1;
+        var segmentCellOffsetFirst = Math.max(rangeCellOffsetFirst, rowCellOffsetFirst);
+        var segmentCellOffsetLast = Math.min(rangeCellOffsetLast, rowCellOffsetLast);
+
+        if (segmentCellOffsetFirst <= segmentCellOffsetLast) {
+          var segmentCellFirst = cellOffsetToCell(segmentCellOffsetFirst);
+          var segmentCellLast = cellOffsetToCell(segmentCellOffsetLast);
+          var cols = [ segmentCellFirst.col, segmentCellLast.col ].sort();
+          var isStart = cellOffsetToDayOffset(segmentCellOffsetFirst) === rangeDayOffsetStart;
+          var isEnd = cellOffsetToDayOffset(segmentCellOffsetLast) + 1 === rangeDayOffsetEnd;
+
+          segments.push({
+            row: row,
+            leftCol: cols[0],
+            rightCol: cols[1],
+            isStart: isStart,
+            isEnd: isEnd
+          });
+        }
+      }
+
+      return segments;
+    }
+  }
+
+  function DayEventRenderer() {
+    var t = this;
+
+    t.renderDayEvents = renderDayEvents;
+    t.draggableDayEvent = draggableDayEvent;
+    t.resizableDayEvent = resizableDayEvent;
+
+    var opt = t.opt;
+    var trigger = t.trigger;
+    var isEventDraggable = t.isEventDraggable;
+    var isEventResizable = t.isEventResizable;
+    var eventEnd = t.eventEnd;
+    var reportEventElement = t.reportEventElement;
+    var eventElementHandlers = t.eventElementHandlers;
+    var showEvents = t.showEvents;
+    var hideEvents = t.hideEvents;
+    var eventDrop = t.eventDrop;
+    var eventResize = t.eventResize;
+    var getRowCnt = t.getRowCnt;
+    var getColCnt = t.getColCnt;
+    var getColWidth = t.getColWidth;
+    var allDayRow = t.allDayRow;
+    var colLeft = t.colLeft;
+    var colRight = t.colRight;
+    var colContentLeft = t.colContentLeft;
+    var colContentRight = t.colContentRight;
+    var dateToCell = t.dateToCell;
+    var getDaySegmentContainer = t.getDaySegmentContainer;
+    var formatDates = t.calendar.formatDates;
+    var renderDayOverlay = t.renderDayOverlay;
+    var clearOverlays = t.clearOverlays;
+    var clearSelection = t.clearSelection;
+    var getHoverListener = t.getHoverListener;
+    var rangeToSegments = t.rangeToSegments;
+    var cellToDate = t.cellToDate;
+    var cellToCellOffset = t.cellToCellOffset;
+    var cellOffsetToDayOffset = t.cellOffsetToDayOffset;
+    var dateToDayOffset = t.dateToDayOffset;
+    var dayOffsetToCellOffset = t.dayOffsetToCellOffset;
+
+    function renderDayEvents(events, modifiedEventId) {
+      var segments = _renderDayEvents(events, false, true);
+
+      segmentElementEach(segments, function (segment, element) {
+        reportEventElement(segment.event, element);
+      });
+
+      attachHandlers(segments, modifiedEventId);
+
+      segmentElementEach(segments, function (segment, element) {
+        trigger('eventAfterRender', segment.event, segment.event, element);
+      });
+    }
+
+    function renderTempDayEvent(event, adjustRow, adjustTop) {
+      var segments = _renderDayEvents( [event], true, false);
+      var elements = [];
+
+      segmentElementEach(segments, function (segment, element) {
+        if (segment.row === adjustRow) element.css('top', adjustTop);
+
+        elements.push(element[0]);
+      });
+
+      return elements;
+    }
+
+    function _renderDayEvents(events, doAppend, doRowHeights) {
+      var finalContainer = getDaySegmentContainer();
+      var renderContainer = doAppend ? $('<div/>') : finalContainer;
+      var segments = buildSegments(events);
+      var html, elements;
+
+      calculateHorizontals(segments);
+
+      html = buildHTML(segments);
+
+      renderContainer[0].innerHTML = html;
+
+      elements = renderContainer.children();
+
+      if (doAppend) finalContainer.append(elements);
+
+      resolveElements(segments, elements);
+      segmentElementEach(segments, function (segment, element) {
+        segment.hsides = hsides(element, true);
+      });
+      segmentElementEach(segments, function (segment, element) {
+        element.width(Math.max(0, segment.outerWidth - segment.hsides));
+      });
+      segmentElementEach(segments, function (segment, element) {
+        segment.outerHeight = element.outerHeight(true);
+      });
+      setVerticals(segments, doRowHeights);
+
+      return segments;
+    }
+
+    function buildSegments(events) {
+      var segments = [];
+
+      for (var i = 0; i < events.length; i++) {
+        var eventSegments = buildSegmentsForEvent(events[i]);
+
+        segments.push.apply(segments, eventSegments);
+      }
+
+      return segments;
+    }
+
+    function buildSegmentsForEvent(event) {
+      var startDate = event.start;
+      var endDate = exclEndDay(event);
+      var segments = rangeToSegments(startDate, endDate);
+
+      for (var i = 0; i < segments.length; i++) {
+        segments[i].event = event;
+      }
+
+      return segments;
+    }
+
+    function calculateHorizontals(segments) {
+      for (var i = 0; i < segments.length; i++) {
+        var segment = segments[i];
+        var leftFunc = segment.isStart ? colContentLeft : colLeft;
+        var rightFunc = segment.isEnd ? colContentRight : colRight;
+        var left = leftFunc(segment.leftCol);
+        var right = rightFunc(segment.rightCol);
+
+        segment.left = left;
+        segment.outerWidth = right - left;
+      }
+    }
+
+    function buildHTML(segments) {
+      var html = '';
+
+      for (var i = 0; i < segments.length; i++) {
+        html += buildHTMLForSegment(segments[i]);
+      }
+
+      return html;
+    }
+
+    function buildHTMLForSegment(segment) {
+      var html = '';
+      var event = segment.event;
+      var url = event.url;
+      var classNames = [ 'calendar-event', 'calendar-event-hori' ];
+
+      if (isEventDraggable(event)) classNames.push('calendar-event-draggable');
+      if (segment.isStart) classNames.push('calendar-event-start');
+      if (segment.isEnd) classNames.push('calendar-event-end');
+
+      classNames = classNames.concat(event.className);
+
+      if (event.source) {
+        classNames = classNames.concat(event.source.className || []);
+      }
+
+      var skinCss = getSkinCss(event, opt);
+
+      if (url) {
+        html += '<a href="' + htmlEscape(url) + '"';
+      } else {
+        html += '<div';
+      }
+
+      html +=' class="' + classNames.join(' ') + '"' +
+              ' style="position: absolute;' +
+              ' left:' + segment.left + 'px;' +
+              skinCss +
+              '">' +
+            '<div class="calendar-event-inner">';
+
+      if (!event.allDay && segment.isStart) {
+        html += '<span class="calendar-event-time">' +
+                  htmlEscape(formatDates(event.start, event.end, opt('timeFormat'))) +
+                '</span>';
+      }
+
+      html += '<span class="calendar-event-title">' +
+                htmlEscape(event.title || '') +
+              '</span></div>';
+
+      html += '</' + (url ? 'a' : 'div') + '>';
+
+      return html;
+    }
+
+    function resolveElements(segments, elements) {
+      for (var i = 0; i < segments.length; i++) {
+        var segment = segments[i];
+        var event = segment.event;
+        var element = elements.eq(i);
+        var triggerRes = trigger('eventRender', event, event, element);
+
+        if (triggerRes === false) {
+          element.remove();
+        } else {
+          if (triggerRes && triggerRes !== true) {
+            triggerRes = $(triggerRes)
+              .css({
+                position: 'absolute',
+                left: segment.left
+              });
+
+            element.replaceWith(triggerRes);
+            element = triggerRes;
+          }
+
+          segment.element = element;
+        }
+      }
+    }
+
+    function setVerticals(segments, doRowHeights) {
+      var rowContentHeights = calculateVerticals(segments);
+      var rowContentElements = getRowContentElements();
+      var rowContentTops = [];
+      var i;
+
+      if (doRowHeights) {
+        for (i = 0; i < rowContentElements.length; i++) {
+          rowContentElements[i].height(rowContentHeights[i]);
+        }
+      }
+
+      for (i = 0; i < rowContentElements.length; i++) {
+        rowContentTops.push(rowContentElements[i].position().top);
+      }
+
+      segmentElementEach(segments, function (segment, element) {
+        element.css('top', rowContentTops[segment.row] + segment.top);
+      });
+    }
+
+    function calculateVerticals(segments) {
+      var rowCnt = getRowCnt();
+      var colCnt = getColCnt();
+      var rowContentHeights = [];
+      var segmentRows = buildSegmentRows(segments);
+      var colI;
+
+      for (var rowI = 0; rowI < rowCnt; rowI++) {
+        var segmentRow = segmentRows[rowI];
+        var colHeights = [];
+
+        for (colI = 0; colI < colCnt; colI++) {
+          colHeights.push(0);
+        }
+
+        for (var segmentI = 0; segmentI < segmentRow.length; segmentI++) {
+          var segment = segmentRow[segmentI];
+
+          segment.top = arrayMax(
+            colHeights.slice(
+              segment.leftCol,
+              segment.rightCol + 1
+            )
+          );
+
+          for (colI = segment.leftCol; colI <= segment.rightCol; colI++) {
+            colHeights[colI] = segment.top + segment.outerHeight;
+          }
+        }
+
+        rowContentHeights.push(arrayMax(colHeights));
+      }
+
+      return rowContentHeights;
+    }
+
+    function buildSegmentRows(segments) {
+      var rowCnt = getRowCnt();
+      var segmentRows = [];
+      var rowI, segment, segmentI;
+
+      for (segmentI = 0; segmentI < segments.length; segmentI++) {
+        segment = segments[segmentI];
+        rowI = segment.row;
+
+        if (segment.element) {
+          if (segmentRows[rowI]) {
+            segmentRows[rowI].push(segment);
+          } else {
+            segmentRows[rowI] = [ segment ];
+          }
+        }
+      }
+
+      for (rowI = 0; rowI < rowCnt; rowI++) {
+        segmentRows[rowI] = sortSegmentRow(segmentRows[rowI] || []);
+      }
+
+      return segmentRows;
+    }
+
+    function sortSegmentRow(segments) {
+      var sortedSegments = [];
+      var subrows = buildSegmentSubrows(segments);
+
+      for (var i = 0; i < subrows.length; i++) {
+        sortedSegments.push.apply(sortedSegments, subrows[i]);
+      }
+
+      return sortedSegments;
+    }
+
+    function buildSegmentSubrows(segments) {
+      var subrows = [];
+
+      segments.sort(compareDaySegments);
+
+      for (var i = 0; i < segments.length; i++) {
+        var segment = segments[i];
+
+        for (var j=0; j<subrows.length; j++) {
+          if (!isDaySegmentCollision(segment, subrows[j])) break;
+        }
+
+        if (subrows[j]) {
+          subrows[j].push(segment);
+        } else {
+          subrows[j] = [ segment ];
+        }
+      }
+
+      return subrows;
+    }
+
+    function getRowContentElements() {
+      var rowCnt = getRowCnt();
+      var rowDivs = [];
+
+      for (var i = 0; i < rowCnt; i++) {
+        rowDivs[i] = allDayRow(i).find('div.calendar-day-content > div');
+      }
+
+      return rowDivs;
+    }
+
+    function attachHandlers(segments, modifiedEventId) {
+      var segmentContainer = getDaySegmentContainer();
+
+      segmentElementEach(segments, function (segment, element, i) {
+        var event = segment.event;
+
+        if (event._id === modifiedEventId) {
+          bindDaySeg(event, element, segment);
+        } else {
+          element[0]._fci = i;
+        }
+      });
+
+      lazySegBind(segmentContainer, segments, bindDaySeg);
+    }
+
+    function bindDaySeg(event, eventElement, segment) {
+      if (isEventDraggable(event)) t.draggableDayEvent(event, eventElement, segment);
+      if (segment.isEnd && isEventResizable(event)) t.resizableDayEvent(event, eventElement, segment);
+
+      eventElementHandlers(event, eventElement);
+    }
+
+    function draggableDayEvent(event, eventElement) {
+      var hoverListener = getHoverListener();
+      var dayDelta;
+
+      eventElement.draggable({
+        delay: 50,
+        opacity: opt('dragOpacity'),
+        revertDuration: opt('dragRevertDuration'),
+        start: function (ev, ui) {
+          trigger('eventDragStart', eventElement, event, ev, ui);
+          hideEvents(event, eventElement);
+
+          hoverListener.start(function (cell, origCell, rowDelta, colDelta) {
+            eventElement.draggable('option', 'revert', !cell || !rowDelta && !colDelta);
+
+            clearOverlays();
+
+            if (cell) {
+              var origDate = cellToDate(origCell);
+              var date = cellToDate(cell);
+
+              dayDelta = dayDiff(date, origDate);
+
+              renderDayOverlay(addDays(cloneDate(event.start), dayDelta), addDays(exclEndDay(event), dayDelta));
+            } else {
+              dayDelta = 0;
+            }
+          }, ev, 'drag');
+        },
+        stop: function (ev, ui) {
+          hoverListener.stop();
+
+          clearOverlays();
+          trigger('eventDragStop', eventElement, event, ev, ui);
+
+          if (dayDelta) {
+            eventDrop(this, event, dayDelta, 0, event.allDay, ev, ui);
+          } else {
+            eventElement.css('filter', '');
+            showEvents(event, eventElement);
+          }
+        }
+      });
+    }
+
+    function resizableDayEvent(event, element, segment) {
+      var direction = 'e';
+      var handle = element.find('.ui-resizable-' + direction);
+      var isResizing = false;
+
+      disableTextSelection(element);
+
+      element
+        .mousedown(function (ev) {
+          ev.preventDefault();
+        })
+        .click(function (ev) {
+          if (isResizing) {
+            ev.preventDefault();
+            ev.stopImmediatePropagation();
+          }
+        });
+
+      handle.mousedown(function (ev) {
+        if (ev.which !== 1) return;
+
+        isResizing = true;
+
+        var hoverListener = getHoverListener();
+        var rowCnt = getRowCnt();
+        var colCnt = getColCnt();
+        var elementTop = element.css('top');
+        var dayDelta;
+        var helpers;
+        var eventCopy = $.extend({}, event);
+        var minCellOffset = dayOffsetToCellOffset( dateToDayOffset(event.start) );
+
+        clearSelection();
+
+        $('body')
+          .css('cursor', direction + '-resize')
+          .one('mouseup', mouseup);
+
+        trigger('eventResizeStart', this, event, ev);
+
+        hoverListener.start(function (cell, origCell) {
+          if (cell) {
+            var origCellOffset = cellToCellOffset(origCell);
+            var cellOffset = cellToCellOffset(cell);
+
+            cellOffset = Math.max(cellOffset, minCellOffset);
+            dayDelta = cellOffsetToDayOffset(cellOffset) - cellOffsetToDayOffset(origCellOffset);
+
+            if (dayDelta) {
+              eventCopy.end = addDays(eventEnd(event), dayDelta, true);
+
+              var oldHelpers = helpers;
+
+              helpers = renderTempDayEvent(eventCopy, segment.row, elementTop);
+              helpers = $(helpers);
+
+              helpers.find('*').css('cursor', direction + '-resize');
+
+              if (oldHelpers) oldHelpers.remove();
+
+              hideEvents(event);
+            } else {
+              if (helpers) {
+                showEvents(event);
+                helpers.remove();
+                helpers = null;
+              }
+            }
+
+            clearOverlays();
+            renderDayOverlay(event.start, addDays(exclEndDay(event), dayDelta));
+          }
+        }, ev);
+
+        function mouseup(ev) {
+          trigger('eventResizeStop', this, event, ev);
+
+          $('body').css('cursor', '');
+
+          hoverListener.stop();
+
+          clearOverlays();
+
+          if (dayDelta) eventResize(this, event, dayDelta, 0, ev);
+
+          setTimeout(function () {
+            isResizing = false;
+          }, 0);
+        }
+      });
+    }
+  }
+
+  function isDaySegmentCollision(segment, otherSegments) {
+    for (var i = 0; i < otherSegments.length; i++) {
+      var otherSegment = otherSegments[i];
+
+      if (otherSegment.leftCol <= segment.rightCol && otherSegment.rightCol >= segment.leftCol) return true;
+    }
+
+    return false;
+  }
+
+
+  function segmentElementEach(segments, callback) {
+    for (var i = 0; i < segments.length; i++) {
+      var segment = segments[i];
+      var element = segment.element;
+
+      if (element) callback(segment, element, i);
+    }
+  }
+
+
+  function compareDaySegments(a, b) {
+    return (b.rightCol - b.leftCol) - (a.rightCol - a.leftCol) ||
+      b.event.allDay - a.event.allDay ||
+      a.event.start - b.event.start ||
+      (a.event.title || '').localeCompare(b.event.title);
+  }
+
+  function SelectionManager() {
+    var t = this;
+
+    t.select = select;
+    t.unselect = unselect;
+    t.reportSelection = reportSelection;
+    t.daySelectionMousedown = daySelectionMousedown;
+
+    var opt = t.opt;
+    var trigger = t.trigger;
+    var defaultSelectionEnd = t.defaultSelectionEnd;
+    var renderSelection = t.renderSelection;
+    var clearSelection = t.clearSelection;
+    var selected = false;
+
+    if (opt('selectable') && opt('unselectAuto')) {
+      $(document).mousedown(function (ev) {
+        var ignore = opt('unselectCancel');
+
+        if (ignore) {
+          if ($(ev.target).parents(ignore).length) return;
+        }
+
+        unselect(ev);
+      });
+    }
+
+    function select(startDate, endDate, allDay) {
+      unselect();
+
+      if (!endDate) {
+        endDate = defaultSelectionEnd(startDate, allDay);
+      }
+
+      renderSelection(startDate, endDate, allDay);
+      reportSelection(startDate, endDate, allDay);
+    }
+
+    function unselect(ev) {
+      if (selected) {
+        selected = false;
+        clearSelection();
+        trigger('unselect', null, ev);
+      }
+    }
+
+    function reportSelection(startDate, endDate, allDay, ev) {
+      selected = true;
+      trigger('select', null, startDate, endDate, allDay, ev);
+    }
+
+    function daySelectionMousedown(ev) {
+      var cellToDate = t.cellToDate;
+      var getIsCellAllDay = t.getIsCellAllDay;
+      var hoverListener = t.getHoverListener();
+      var reportDayClick = t.reportDayClick;
+
+      if (ev.which === 1 && opt('selectable')) {
+        unselect(ev);
+
+        var _mousedownElement = this;
+        var dates;
+
+        hoverListener.start(function (cell, origCell) {
+          clearSelection();
+
+          if (cell && getIsCellAllDay(cell)) {
+            dates = [ cellToDate(origCell), cellToDate(cell) ].sort(dateCompare);
+
+            renderSelection(dates[0], dates[1], true);
+          } else {
+            dates = null;
+          }
+        }, ev);
+
+        $(document).one('mouseup', function (ev) {
+          hoverListener.stop();
+
+          if (dates) {
+            if (+dates[0] === +dates[1]) reportDayClick(dates[0], true, ev);
+
+            reportSelection(dates[0], dates[1], true, ev);
+          }
+        });
+      }
+    }
+  }
+
+  function OverlayManager() {
+    var t = this;
+
+    t.renderOverlay = renderOverlay;
+    t.clearOverlays = clearOverlays;
+
+    var usedOverlays = [];
+    var unusedOverlays = [];
+
+    function renderOverlay(rect, parent) {
+      var e = unusedOverlays.shift();
+
+      if (!e) {
+        e = $("<div class='calendar-cell-overlay' style='position:absolute;z-index:3'/>");
+      }
+
+      if (e[0].parentNode !== parent[0]) e.appendTo(parent);
+
+      usedOverlays.push(e.css(rect).show());
+
+      return e;
+    }
+
+    function clearOverlays() {
+      var e;
+
+      while (e = usedOverlays.shift()) {
+        unusedOverlays.push(e.hide().unbind());
+      }
+    }
+  }
+
+  function CoordinateGrid(buildFunc) {
+    var t = this;
+    var cols, rows;
+
+    t.build = function () {
+      rows = [];
+      cols = [];
+
+      buildFunc(rows, cols);
+    };
+
+    t.cell = function (x, y) {
+      var rowCnt = rows.length;
+      var colCnt = cols.length;
+      var i, r=-1, c=-1;
+
+      for (i = 0; i < rowCnt; i++) {
+        if (y >= rows[i][0] && y < rows[i][1]) {
+          r = i;
+          break;
+        }
+      }
+      for (i = 0; i < colCnt; i++) {
+        if (x >= cols[i][0] && x < cols[i][1]) {
+          c = i;
+          break;
+        }
+      }
+
+      return (r >= 0 && c >= 0) ? { row: r, col: c } : null;
+    };
+
+    t.rect = function (row0, col0, row1, col1, originElement) {
+      var origin = originElement.offset();
+
+      return {
+        top: rows[row0][0] - origin.top,
+        left: cols[col0][0] - origin.left,
+        width: cols[col1][1] - cols[col0][0],
+        height: rows[row1][1] - rows[row0][0]
+      };
+    };
+  }
+
+  function HoverListener(coordinateGrid) {
+    var t = this;
+    var bindType, change, firstCell, cell;
+
+    t.start = function (_change, ev, _bindType) {
+      change = _change;
+      firstCell = cell = null;
+
+      coordinateGrid.build();
+
+      mouse(ev);
+
+      bindType = _bindType || 'mousemove';
+
+      $(document).bind(bindType, mouse);
+    };
+
+    function mouse(ev) {
+      _fixUIEvent(ev);
+
+      var newCell = coordinateGrid.cell(ev.pageX, ev.pageY);
+
+      if (newCell !== cell || newCell && (newCell.row !== cell.row || newCell.col !== cell.col)) {
+        if (newCell) {
+          if (!firstCell) {
+            firstCell = newCell;
+          }
+
+          change(newCell, firstCell, newCell.row-firstCell.row, newCell.col-firstCell.col);
+        } else {
+          change(newCell, firstCell);
+        }
+
+        cell = newCell;
+      }
+    }
+
+    t.stop = function () {
+      $(document).unbind(bindType, mouse);
+      return cell;
+    };
+  }
+
+  function _fixUIEvent(event) {
+    if (event.pageX === undefined) {
+      event.pageX = event.originalEvent.pageX;
+      event.pageY = event.originalEvent.pageY;
+    }
+  }
+
+  function HorizontalPositionCache(getElement) {
+    var t = this;
+    var elements = {};
+    var lefts = {};
+    var rights = {};
+
+    function e(i) {
+      return elements[i] = elements[i] || getElement(i);
+    }
+
+    t.left = function (i) {
+      return lefts[i] = lefts[i] === undefined ? e(i).position().left : lefts[i];
+    };
+    t.right = function (i) {
+      return rights[i] = rights[i] === undefined ? t.left(i) + e(i).width() : rights[i];
+    };
+    t.clear = function () {
+      elements = {};
+      lefts = {};
+      rights = {};
+    };
+  }
+
+})(jQuery);