fullcalendar.io-rails 3.3.1 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 183d16d2fc0cd0013d71ab3931e407e1c462d825
-  data.tar.gz: c240d22deeced6d3ed07fa23f1c2fd5773146531
+  metadata.gz: b02874e67890f4d0b6f1992597ecead7235953ff
+  data.tar.gz: 6afc0a25ade54f6389f810f86833ba26067be68b
 SHA512:
-  metadata.gz: 647278a51aa2ad0b2416cd7e6f2be82499e04a06eeaa3f40a7950d02884b75538d6d2dd0d5567313053c20c9c4b3cf45f4c94d6862355def7fa66bd6318f4f9f
-  data.tar.gz: eec81bf6e5a4038afb977bb8d725751159582fbe657ae95cdc7cde4598be179c7a54a6caed08d97872e0d642ef02d16d14f5adac7f001b51ca13471dc825d3c4
+  metadata.gz: 030d51c3449b814cf150dab1c0d96b8124515317252a3c9cef5a4c2f1325ed7cc37e88281aa71e9452eae3883172e7c7ec9d7d3c22894195711cb1eed89deecc
+  data.tar.gz: 90b2d739fc26cd1d7fc5fd3fa2170c62ec63fe6942e3a7cc2db766e0f39ac11f931fb35a4e2364545ab4d56140d9119c29208769bf25cfa0cf5abe085e910604

data/lib/fullcalendar.io/rails/version.rb

@@ -1,5 +1,5 @@
 module Fullcalendario
   module Rails
-    VERSION = "3.3.1"
+    VERSION = "3.4.0"
   end
 end

data/vendor/assets/javascripts/fullcalendar.js

@@ -1,5 +1,5 @@
 /*!
- * FullCalendar v3.3.1
+ * FullCalendar v3.4.0
  * Docs & License: https://fullcalendar.io/
  * (c) 2017 Adam Shaw
  */
@@ -19,7 +19,7 @@
 ;;
 
 var FC = $.fullCalendar = {
-	version: "3.3.1",
+	version: "3.4.0",
 	// When introducing internal API incompatibilities (where fullcalendar plugins would break),
 	// the minor version of the calendar should be upped (ex: 2.7.2 -> 2.8.0)
 	// and the below integer should be incremented.
@@ -1402,28 +1402,48 @@ newMomentProto.utcOffset = function(tzo) {
 // -------------------------------------------------------------------------------------------------
 
 newMomentProto.format = function() {
+
 	if (this._fullCalendar && arguments[0]) { // an enhanced moment? and a format string provided?
 		return formatDate(this, arguments[0]); // our extended formatting
 	}
 	if (this._ambigTime) {
-		return oldMomentFormat(this, 'YYYY-MM-DD');
+		return oldMomentFormat(englishMoment(this), 'YYYY-MM-DD');
 	}
 	if (this._ambigZone) {
-		return oldMomentFormat(this, 'YYYY-MM-DD[T]HH:mm:ss');
+		return oldMomentFormat(englishMoment(this), 'YYYY-MM-DD[T]HH:mm:ss');
+	}
+	if (this._fullCalendar) { // enhanced non-ambig moment?
+		// moment.format() doesn't ensure english, but we want to.
+		return oldMomentFormat(englishMoment(this));
 	}
+
 	return oldMomentProto.format.apply(this, arguments);
 };
 
 newMomentProto.toISOString = function() {
+
 	if (this._ambigTime) {
-		return oldMomentFormat(this, 'YYYY-MM-DD');
+		return oldMomentFormat(englishMoment(this), 'YYYY-MM-DD');
 	}
 	if (this._ambigZone) {
-		return oldMomentFormat(this, 'YYYY-MM-DD[T]HH:mm:ss');
+		return oldMomentFormat(englishMoment(this), 'YYYY-MM-DD[T]HH:mm:ss');
 	}
+	if (this._fullCalendar) { // enhanced non-ambig moment?
+		// depending on browser, moment might not output english. ensure english.
+		// https://github.com/moment/moment/blob/2.18.1/src/lib/moment/format.js#L22
+		return oldMomentProto.toISOString.apply(englishMoment(this), arguments);
+	}
+
 	return oldMomentProto.toISOString.apply(this, arguments);
 };
 
+function englishMoment(mom) {
+	if (mom.locale() !== 'en') {
+		return mom.clone().locale('en');
+	}
+	return mom;
+}
+
 ;;
 (function() {
 
@@ -1906,293 +1926,742 @@ function mixIntoClass(theClass, members) {
 }
 ;;
 
-/*
-Wrap jQuery's Deferred Promise object to be slightly more Promise/A+ compliant.
-With the added non-standard feature of synchronously executing handlers on resolved promises,
-which doesn't always happen otherwise (esp with nested .then handlers!?),
-so, this makes things a lot easier, esp because jQuery 3 changed the synchronicity for Deferred objects.
+var Model = Class.extend(EmitterMixin, ListenerMixin, {
 
-TODO: write tests and more comments
-*/
+	_props: null,
+	_watchers: null,
+	_globalWatchArgs: null,
 
-function Promise(executor) {
-	var deferred = $.Deferred();
-	var promise = deferred.promise();
+	constructor: function() {
+		this._watchers = {};
+		this._props = {};
+		this.applyGlobalWatchers();
+	},
 
-	if (typeof executor === 'function') {
-		executor(
-			function(value) { // resolve
-				if (Promise.immediate) {
-					promise._value = value;
-				}
-				deferred.resolve(value);
-			},
-			function() { // reject
-				deferred.reject();
+	applyGlobalWatchers: function() {
+		var argSets = this._globalWatchArgs || [];
+		var i;
+
+		for (i = 0; i < argSets.length; i++) {
+			this.watch.apply(this, argSets[i]);
+		}
+	},
+
+	has: function(name) {
+		return name in this._props;
+	},
+
+	get: function(name) {
+		if (name === undefined) {
+			return this._props;
+		}
+
+		return this._props[name];
+	},
+
+	set: function(name, val) {
+		var newProps;
+
+		if (typeof name === 'string') {
+			newProps = {};
+			newProps[name] = val === undefined ? null : val;
+		}
+		else {
+			newProps = name;
+		}
+
+		this.setProps(newProps);
+	},
+
+	reset: function(newProps) {
+		var oldProps = this._props;
+		var changeset = {}; // will have undefined's to signal unsets
+		var name;
+
+		for (name in oldProps) {
+			changeset[name] = undefined;
+		}
+
+		for (name in newProps) {
+			changeset[name] = newProps[name];
+		}
+
+		this.setProps(changeset);
+	},
+
+	unset: function(name) { // accepts a string or array of strings
+		var newProps = {};
+		var names;
+		var i;
+
+		if (typeof name === 'string') {
+			names = [ name ];
+		}
+		else {
+			names = name;
+		}
+
+		for (i = 0; i < names.length; i++) {
+			newProps[names[i]] = undefined;
+		}
+
+		this.setProps(newProps);
+	},
+
+	setProps: function(newProps) {
+		var changedProps = {};
+		var changedCnt = 0;
+		var name, val;
+
+		for (name in newProps) {
+			val = newProps[name];
+
+			// a change in value?
+			// if an object, don't check equality, because might have been mutated internally.
+			// TODO: eventually enforce immutability.
+			if (
+				typeof val === 'object' ||
+				val !== this._props[name]
+			) {
+				changedProps[name] = val;
+				changedCnt++;
 			}
-		);
-	}
-	
-	if (Promise.immediate) {
-		var origThen = promise.then;
-
-		promise.then = function(onFulfilled, onRejected) {
-			var state = promise.state();
-			
-			if (state === 'resolved') {
-				if (typeof onFulfilled === 'function') {
-					return Promise.resolve(onFulfilled(promise._value));
+		}
+
+		if (changedCnt) {
+
+			this.trigger('before:batchChange', changedProps);
+
+			for (name in changedProps) {
+				val = changedProps[name];
+
+				this.trigger('before:change', name, val);
+				this.trigger('before:change:' + name, val);
+			}
+
+			for (name in changedProps) {
+				val = changedProps[name];
+
+				if (val === undefined) {
+					delete this._props[name];
 				}
+				else {
+					this._props[name] = val;
+				}
+
+				this.trigger('change:' + name, val);
+				this.trigger('change', name, val);
+			}
+
+			this.trigger('batchChange', changedProps);
+		}
+	},
+
+	watch: function(name, depList, startFunc, stopFunc) {
+		var _this = this;
+
+		this.unwatch(name);
+
+		this._watchers[name] = this._watchDeps(depList, function(deps) {
+			var res = startFunc.call(_this, deps);
+
+			if (res && res.then) {
+				_this.unset(name); // put in an unset state while resolving
+				res.then(function(val) {
+					_this.set(name, val);
+				});
+			}
+			else {
+				_this.set(name, res);
+			}
+		}, function() {
+			_this.unset(name);
+
+			if (stopFunc) {
+				stopFunc.call(_this);
 			}
-			else if (state === 'rejected') {
-				if (typeof onRejected === 'function') {
-					onRejected();
-					return promise; // already rejected
+		});
+	},
+
+	unwatch: function(name) {
+		var watcher = this._watchers[name];
+
+		if (watcher) {
+			delete this._watchers[name];
+			watcher.teardown();
+		}
+	},
+
+	_watchDeps: function(depList, startFunc, stopFunc) {
+		var _this = this;
+		var queuedChangeCnt = 0;
+		var depCnt = depList.length;
+		var satisfyCnt = 0;
+		var values = {}; // what's passed as the `deps` arguments
+		var bindTuples = []; // array of [ eventName, handlerFunc ] arrays
+		var isCallingStop = false;
+
+		function onBeforeDepChange(depName, val, isOptional) {
+			queuedChangeCnt++;
+			if (queuedChangeCnt === 1) { // first change to cause a "stop" ?
+				if (satisfyCnt === depCnt) { // all deps previously satisfied?
+					isCallingStop = true;
+					stopFunc();
+					isCallingStop = false;
 				}
 			}
+		}
 
-			return origThen.call(promise, onFulfilled, onRejected);
-		};
-	}
+		function onDepChange(depName, val, isOptional) {
 
-	return promise; // instanceof Promise will break :( TODO: make Promise a real class
-}
+			if (val === undefined) { // unsetting a value?
 
-FC.Promise = Promise;
+				// required dependency that was previously set?
+				if (!isOptional && values[depName] !== undefined) {
+					satisfyCnt--;
+				}
 
-Promise.immediate = true;
+				delete values[depName];
+			}
+			else { // setting a value?
 
+				// required dependency that was previously unset?
+				if (!isOptional && values[depName] === undefined) {
+					satisfyCnt++;
+				}
 
-Promise.resolve = function(value) {
-	if (value && typeof value.resolve === 'function') {
-		return value.promise();
-	}
-	if (value && typeof value.then === 'function') {
-		return value;
-	}
-	else {
-		var deferred = $.Deferred().resolve(value);
-		var promise = deferred.promise();
+				values[depName] = val;
+			}
 
-		if (Promise.immediate) {
-			var origThen = promise.then;
+			queuedChangeCnt--;
+			if (!queuedChangeCnt) { // last change to cause a "start"?
 
-			promise._value = value;
+				// now finally satisfied or satisfied all along?
+				if (satisfyCnt === depCnt) {
 
-			promise.then = function(onFulfilled, onRejected) {
-				if (typeof onFulfilled === 'function') {
-					return Promise.resolve(onFulfilled(value));
+					// if the stopFunc initiated another value change, ignore it.
+					// it will be processed by another change event anyway.
+					if (!isCallingStop) {
+						startFunc(values);
+					}
 				}
-				return origThen.call(promise, onFulfilled, onRejected);
-			};
+			}
 		}
 
-		return promise;
-	}
-};
+		// intercept for .on() that remembers handlers
+		function bind(eventName, handler) {
+			_this.on(eventName, handler);
+			bindTuples.push([ eventName, handler ]);
+		}
 
+		// listen to dependency changes
+		depList.forEach(function(depName) {
+			var isOptional = false;
 
-Promise.reject = function() {
-	return $.Deferred().reject().promise();
-};
+			if (depName.charAt(0) === '?') { // TODO: more DRY
+				depName = depName.substring(1);
+				isOptional = true;
+			}
 
+			bind('before:change:' + depName, function(val) {
+				onBeforeDepChange(depName, val, isOptional);
+			});
 
-Promise.all = function(inputs) {
-	var hasAllValues = false;
-	var values;
-	var i, input;
+			bind('change:' + depName, function(val) {
+				onDepChange(depName, val, isOptional);
+			});
+		});
 
-	if (Promise.immediate) {
-		hasAllValues = true;
-		values = [];
+		// process current dependency values
+		depList.forEach(function(depName) {
+			var isOptional = false;
 
-		for (i = 0; i < inputs.length; i++) {
-			input = inputs[i];
+			if (depName.charAt(0) === '?') { // TODO: more DRY
+				depName = depName.substring(1);
+				isOptional = true;
+			}
 
-			if (input && typeof input.state === 'function' && input.state() === 'resolved' && ('_value' in input)) {
-				values.push(input._value);
+			if (_this.has(depName)) {
+				values[depName] = _this.get(depName);
+				satisfyCnt++;
 			}
-			else if (input && typeof input.then === 'function') {
-				hasAllValues = false;
-				break;
+			else if (isOptional) {
+				satisfyCnt++;
 			}
-			else {
-				values.push(input);
+		});
+
+		// initially satisfied
+		if (satisfyCnt === depCnt) {
+			startFunc(values);
+		}
+
+		return {
+			teardown: function() {
+				// remove all handlers
+				for (var i = 0; i < bindTuples.length; i++) {
+					_this.off(bindTuples[i][0], bindTuples[i][1]);
+				}
+				bindTuples = null;
+
+				// was satisfied, so call stopFunc
+				if (satisfyCnt === depCnt) {
+					stopFunc();
+				}
+			},
+			flash: function() {
+				if (satisfyCnt === depCnt) {
+					stopFunc();
+					startFunc(values);
+				}
 			}
+		};
+	},
+
+	flash: function(name) {
+		var watcher = this._watchers[name];
+
+		if (watcher) {
+			watcher.flash();
 		}
 	}
 
-	if (hasAllValues) {
-		return Promise.resolve(values);
-	}
-	else {
-		return $.when.apply($.when, inputs).then(function() {
-			return $.when($.makeArray(arguments));
-		});
+});
+
+
+Model.watch = function(/* same arguments as this.watch() */) {
+	var proto = this.prototype;
+
+	if (!proto._globalWatchArgs) {
+		proto._globalWatchArgs = [];
 	}
+
+	proto._globalWatchArgs.push(arguments);
 };
 
+
+FC.Model = Model;
+
+
 ;;
 
-// TODO: write tests and clean up code
+var Promise = {
 
-function TaskQueue(debounceWait) {
-	var q = []; // array of runFuncs
+	construct: function(executor) {
+		var deferred = $.Deferred();
+		var promise = deferred.promise();
 
-	function addTask(taskFunc) {
-		return new Promise(function(resolve) {
+		if (typeof executor === 'function') {
+			executor(
+				function(val) { // resolve
+					deferred.resolve(val);
+					attachImmediatelyResolvingThen(promise, val);
+				},
+				function() { // reject
+					deferred.reject();
+					attachImmediatelyRejectingThen(promise);
+				}
+			);
+		}
 
-			// should run this function when it's taskFunc's turn to run.
-			// responsible for popping itself off the queue.
-			var runFunc = function() {
-				Promise.resolve(taskFunc()) // result might be async, coerce to promise
-					.then(resolve) // resolve TaskQueue::push's promise, for the caller. will receive result of taskFunc.
-					.then(function() {
-						q.shift(); // pop itself off
+		return promise;
+	},
 
-						// run the next task, if any
-						if (q.length) {
-							q[0]();
-						}
-					});
-			};
+	resolve: function(val) {
+		var deferred = $.Deferred().resolve(val);
+		var promise = deferred.promise();
 
-			// always put the task at the end of the queue, BEFORE running the task
-			q.push(runFunc);
+		attachImmediatelyResolvingThen(promise, val);
 
-			// if it's the only task in the queue, run immediately
-			if (q.length === 1) {
-				runFunc();
-			}
-		});
-	}
+		return promise;
+	},
 
-	this.add = // potentially debounce, for the public method
-		typeof debounceWait === 'number' ?
-			debounce(addTask, debounceWait) :
-			addTask; // if not a number (null/undefined/false), no debounce at all
+	reject: function() {
+		var deferred = $.Deferred().reject();
+		var promise = deferred.promise();
 
-	this.addQuickly = addTask; // guaranteed no debounce
-}
+		attachImmediatelyRejectingThen(promise);
 
-FC.TaskQueue = TaskQueue;
+		return promise;
+	}
 
-/*
-q = new TaskQueue();
+};
 
-function work(i) {
-	return q.push(function() {
-		trigger();
-		console.log('work' + i);
-	});
+
+function attachImmediatelyResolvingThen(promise, val) {
+	promise.then = function(onResolve) {
+		if (typeof onResolve === 'function') {
+			onResolve(val);
+		}
+		return promise; // for chaining
+	};
 }
 
-var cnt = 0;
 
-function trigger() {
-	if (cnt < 5) {
-		cnt++;
-		work(cnt);
-	}
+function attachImmediatelyRejectingThen(promise) {
+	promise.then = function(onResolve, onReject) {
+		if (typeof onReject === 'function') {
+			onReject();
+		}
+		return promise; // for chaining
+	};
 }
 
-work(9);
-*/
+
+FC.Promise = Promise;
 
 ;;
 
-var EmitterMixin = FC.EmitterMixin = {
+var TaskQueue = Class.extend(EmitterMixin, {
 
-	// jQuery-ification via $(this) allows a non-DOM object to have
-	// the same event handling capabilities (including namespaces).
+	q: null,
+	isPaused: false,
+	isRunning: false,
 
 
-	on: function(types, handler) {
-		$(this).on(types, this._prepareIntercept(handler));
-		return this; // for chaining
+	constructor: function() {
+		this.q = [];
 	},
 
 
-	one: function(types, handler) {
-		$(this).one(types, this._prepareIntercept(handler));
-		return this; // for chaining
+	queue: function(/* taskFunc, taskFunc... */) {
+		this.q.push.apply(this.q, arguments); // append
+		this.tryStart();
 	},
 
 
-	_prepareIntercept: function(handler) {
-		// handlers are always called with an "event" object as their first param.
-		// sneak the `this` context and arguments into the extra parameter object
-		// and forward them on to the original handler.
-		var intercept = function(ev, extra) {
-			return handler.apply(
-				extra.context || this,
-				extra.args || []
-			);
-		};
+	pause: function() {
+		this.isPaused = true;
+	},
 
-		// mimick jQuery's internal "proxy" system (risky, I know)
-		// causing all functions with the same .guid to appear to be the same.
-		// https://github.com/jquery/jquery/blob/2.2.4/src/core.js#L448
-		// this is needed for calling .off with the original non-intercept handler.
-		if (!handler.guid) {
-			handler.guid = $.guid++;
-		}
-		intercept.guid = handler.guid;
 
-		return intercept;
+	resume: function() {
+		this.isPaused = false;
+		this.tryStart();
 	},
 
 
-	off: function(types, handler) {
-		$(this).off(types, handler);
+	tryStart: function() {
+		if (!this.isRunning && this.canRunNext()) {
+			this.isRunning = true;
+			this.trigger('start');
+			this.runNext();
+		}
+	},
 
-		return this; // for chaining
+
+	canRunNext: function() {
+		return !this.isPaused && this.q.length;
 	},
 
 
-	trigger: function(types) {
-		var args = Array.prototype.slice.call(arguments, 1); // arguments after the first
+	runNext: function() { // does not check canRunNext
+		this.runTask(this.q.shift());
+	},
 
-		// pass in "extra" info to the intercept
-		$(this).triggerHandler(types, { args: args });
 
-		return this; // for chaining
+	runTask: function(task) {
+		this.runTaskFunc(task);
 	},
 
 
-	triggerWith: function(types, context, args) {
+	runTaskFunc: function(taskFunc) {
+		var _this = this;
+		var res = taskFunc();
 
-		// `triggerHandler` is less reliant on the DOM compared to `trigger`.
-		// pass in "extra" info to the intercept.
-		$(this).triggerHandler(types, { context: context, args: args });
+		if (res && res.then) {
+			res.then(done);
+		}
+		else {
+			done();
+		}
 
-		return this; // for chaining
+		function done() {
+			if (_this.canRunNext()) {
+				_this.runNext();
+			}
+			else {
+				_this.isRunning = false;
+				_this.trigger('stop');
+			}
+		}
 	}
 
-};
+});
+
+FC.TaskQueue = TaskQueue;
 
 ;;
 
-/*
-Utility methods for easily listening to events on another object,
-and more importantly, easily unlistening from them.
-*/
-var ListenerMixin = FC.ListenerMixin = (function() {
-	var guid = 0;
-	var ListenerMixin = {
+var RenderQueue = TaskQueue.extend({
 
-		listenerId: null,
+	waitsByNamespace: null,
+	waitNamespace: null,
+	waitId: null,
 
-		/*
-		Given an `other` object that has on/off methods, bind the given `callback` to an event by the given name.
-		The `callback` will be called with the `this` context of the object that .listenTo is being called on.
-		Can be called:
-			.listenTo(other, eventName, callback)
-		OR
-			.listenTo(other, {
-				eventName1: callback1,
-				eventName2: callback2
-			})
+
+	constructor: function(waitsByNamespace) {
+		TaskQueue.call(this); // super-constructor
+
+		this.waitsByNamespace = waitsByNamespace || {};
+	},
+
+
+	queue: function(taskFunc, namespace, type) {
+		var task = {
+			func: taskFunc,
+			namespace: namespace,
+			type: type
+		};
+		var waitMs;
+
+		if (namespace) {
+			waitMs = this.waitsByNamespace[namespace];
+		}
+
+		if (this.waitNamespace) {
+			if (namespace === this.waitNamespace && waitMs != null) {
+				this.delayWait(waitMs);
+			}
+			else {
+				this.clearWait();
+				this.tryStart();
+			}
+		}
+
+		if (this.compoundTask(task)) { // appended to queue?
+
+			if (!this.waitNamespace && waitMs != null) {
+				this.startWait(namespace, waitMs);
+			}
+			else {
+				this.tryStart();
+			}
+		}
+	},
+
+
+	startWait: function(namespace, waitMs) {
+		this.waitNamespace = namespace;
+		this.spawnWait(waitMs);
+	},
+
+
+	delayWait: function(waitMs) {
+		clearTimeout(this.waitId);
+		this.spawnWait(waitMs);
+	},
+
+
+	spawnWait: function(waitMs) {
+		var _this = this;
+
+		this.waitId = setTimeout(function() {
+			_this.waitNamespace = null;
+			_this.tryStart();
+		}, waitMs);
+	},
+
+
+	clearWait: function() {
+		if (this.waitNamespace) {
+			clearTimeout(this.waitId);
+			this.waitId = null;
+			this.waitNamespace = null;
+		}
+	},
+
+
+	canRunNext: function() {
+		if (!TaskQueue.prototype.canRunNext.apply(this, arguments)) {
+			return false;
+		}
+
+		// waiting for a certain namespace to stop receiving tasks?
+		if (this.waitNamespace) {
+
+			// if there was a different namespace task in the meantime,
+			// that forces all previously-waiting tasks to suddenly execute.
+			// TODO: find a way to do this in constant time.
+			for (var q = this.q, i = 0; i < q.length; i++) {
+				if (q[i].namespace !== this.waitNamespace) {
+					return true; // allow execution
+				}
+			}
+
+			return false;
+		}
+
+		return true;
+	},
+
+
+	runTask: function(task) {
+		this.runTaskFunc(task.func);
+	},
+
+
+	compoundTask: function(newTask) {
+		var q = this.q;
+		var shouldAppend = true;
+		var i, task;
+
+		if (newTask.namespace) {
+
+			if (newTask.type === 'destroy' || newTask.type === 'init') {
+
+				// remove all add/remove ops with same namespace, regardless of order
+				for (i = q.length - 1; i >= 0; i--) {
+					task = q[i];
+
+					if (
+						task.namespace === newTask.namespace &&
+						(task.type === 'add' || task.type === 'remove')
+					) {
+						q.splice(i, 1); // remove task
+					}
+				}
+
+				if (newTask.type === 'destroy') {
+					// eat away final init/destroy operation
+					if (q.length) {
+						task = q[q.length - 1]; // last task
+
+						if (task.namespace === newTask.namespace) {
+
+							// the init and our destroy cancel each other out
+							if (task.type === 'init') {
+								shouldAppend = false;
+								q.pop();
+							}
+							// prefer to use the destroy operation that's already present
+							else if (task.type === 'destroy') {
+								shouldAppend = false;
+							}
+						}
+					}
+				}
+				else if (newTask.type === 'init') {
+					// eat away final init operation
+					if (q.length) {
+						task = q[q.length - 1]; // last task
+
+						if (
+							task.namespace === newTask.namespace &&
+							task.type === 'init'
+						) {
+							// our init operation takes precedence
+							q.pop();
+						}
+					}
+				}
+			}
+		}
+
+		if (shouldAppend) {
+			q.push(newTask);
+		}
+
+		return shouldAppend;
+	}
+
+});
+
+FC.RenderQueue = RenderQueue;
+
+;;
+
+var EmitterMixin = FC.EmitterMixin = {
+
+	// jQuery-ification via $(this) allows a non-DOM object to have
+	// the same event handling capabilities (including namespaces).
+
+
+	on: function(types, handler) {
+		$(this).on(types, this._prepareIntercept(handler));
+		return this; // for chaining
+	},
+
+
+	one: function(types, handler) {
+		$(this).one(types, this._prepareIntercept(handler));
+		return this; // for chaining
+	},
+
+
+	_prepareIntercept: function(handler) {
+		// handlers are always called with an "event" object as their first param.
+		// sneak the `this` context and arguments into the extra parameter object
+		// and forward them on to the original handler.
+		var intercept = function(ev, extra) {
+			return handler.apply(
+				extra.context || this,
+				extra.args || []
+			);
+		};
+
+		// mimick jQuery's internal "proxy" system (risky, I know)
+		// causing all functions with the same .guid to appear to be the same.
+		// https://github.com/jquery/jquery/blob/2.2.4/src/core.js#L448
+		// this is needed for calling .off with the original non-intercept handler.
+		if (!handler.guid) {
+			handler.guid = $.guid++;
+		}
+		intercept.guid = handler.guid;
+
+		return intercept;
+	},
+
+
+	off: function(types, handler) {
+		$(this).off(types, handler);
+
+		return this; // for chaining
+	},
+
+
+	trigger: function(types) {
+		var args = Array.prototype.slice.call(arguments, 1); // arguments after the first
+
+		// pass in "extra" info to the intercept
+		$(this).triggerHandler(types, { args: args });
+
+		return this; // for chaining
+	},
+
+
+	triggerWith: function(types, context, args) {
+
+		// `triggerHandler` is less reliant on the DOM compared to `trigger`.
+		// pass in "extra" info to the intercept.
+		$(this).triggerHandler(types, { context: context, args: args });
+
+		return this; // for chaining
+	}
+
+};
+
+;;
+
+/*
+Utility methods for easily listening to events on another object,
+and more importantly, easily unlistening from them.
+*/
+var ListenerMixin = FC.ListenerMixin = (function() {
+	var guid = 0;
+	var ListenerMixin = {
+
+		listenerId: null,
+
+		/*
+		Given an `other` object that has on/off methods, bind the given `callback` to an event by the given name.
+		The `callback` will be called with the `this` context of the object that .listenTo is being called on.
+		Can be called:
+			.listenTo(other, eventName, callback)
+		OR
+			.listenTo(other, {
+				eventName1: callback1,
+				eventName2: callback2
+			})
 		*/
 		listenTo: function(other, arg, callback) {
 			if (typeof arg === 'object') { // given dictionary of callbacks
@@ -4734,7 +5203,7 @@ Grid.mixin({
 		if (businessHours == null) {
 			// fallback
 			// access from calendawr. don't access from view. doesn't update with dynamic options.
-			businessHours = calendar.options.businessHours;
+			businessHours = calendar.opt('businessHours');
 		}
 
 		events = calendar.computeBusinessHourEvents(wholeDay, businessHours);
@@ -5802,7 +6271,9 @@ Grid.mixin({
 				});
 			}
 
-			start = range.end;
+			if (range.end > start) {
+				start = range.end;
+			}
 		}
 
 		// add the span of time after the last event (if there is any)
@@ -8686,7 +9157,7 @@ function isSlotSegCollision(seg1, seg2) {
 /* An abstract class from which other views inherit from
 ----------------------------------------------------------------------------------------------------------------------*/
 
-var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
+var View = FC.View = Model.extend({
 
 	type: null, // subclass' view name (string)
 	name: null, // deprecated. use `type` instead
@@ -8697,14 +9168,13 @@ var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
 	options: null, // hash containing all options. already merged with view-specific-options
 	el: null, // the view's containing element. set by Calendar
 
-	isDateSet: false,
-	isDateRendered: false,
-	dateRenderQueue: null,
-
-	isEventsBound: false,
-	isEventsSet: false,
+	renderQueue: null,
+	batchRenderDepth: 0,
+	isDatesRendered: false,
 	isEventsRendered: false,
-	eventRenderQueue: null,
+	isBaseRendered: false, // related to viewRender/viewDestroy triggers
+
+	queuedScroll: null,
 
 	isRTL: false,
 	isSelected: false, // boolean whether a range of time is user-selected or not
@@ -8730,6 +9200,7 @@ var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
 
 
 	constructor: function(calendar, viewSpec) {
+		Model.prototype.constructor.call(this);
 
 		this.calendar = calendar;
 		this.viewSpec = viewSpec;
@@ -8748,13 +9219,60 @@ var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
 
 		this.eventOrderSpecs = parseFieldSpecs(this.opt('eventOrder'));
 
-		this.dateRenderQueue = new TaskQueue();
-		this.eventRenderQueue = new TaskQueue(this.opt('eventRenderWait'));
+		this.renderQueue = this.buildRenderQueue();
+		this.initAutoBatchRender();
 
 		this.initialize();
 	},
 
 
+	buildRenderQueue: function() {
+		var _this = this;
+		var renderQueue = new RenderQueue({
+			event: this.opt('eventRenderWait')
+		});
+
+		renderQueue.on('start', function() {
+			_this.freezeHeight();
+			_this.addScroll(_this.queryScroll());
+		});
+
+		renderQueue.on('stop', function() {
+			_this.thawHeight();
+			_this.popScroll();
+		});
+
+		return renderQueue;
+	},
+
+
+	initAutoBatchRender: function() {
+		var _this = this;
+
+		this.on('before:change', function() {
+			_this.startBatchRender();
+		});
+
+		this.on('change', function() {
+			_this.stopBatchRender();
+		});
+	},
+
+
+	startBatchRender: function() {
+		if (!(this.batchRenderDepth++)) {
+			this.renderQueue.pause();
+		}
+	},
+
+
+	stopBatchRender: function() {
+		if (!(--this.batchRenderDepth)) {
+			this.renderQueue.resume();
+		}
+	},
+
+
 	// A good place for subclasses to initialize member variables
 	initialize: function() {
 		// subclasses can implement
@@ -8781,29 +9299,6 @@ var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
 	},
 
 
-	// Returns a proxy of the given promise that will be rejected if the given event fires
-	// before the promise resolves.
-	rejectOn: function(eventName, promise) {
-		var _this = this;
-
-		return new Promise(function(resolve, reject) {
-			_this.one(eventName, reject);
-
-			function cleanup() {
-				_this.off(eventName, reject);
-			}
-
-			promise.then(function(res) { // success
-				cleanup();
-				resolve(res);
-			}, function() { // failure
-				cleanup();
-				reject();
-			});
-		});
-	},
-
-
 	/* Title and Date Formatting
 	------------------------------------------------------------------------------------------------------------------*/
 
@@ -8936,6 +9431,7 @@ var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
 	setElement: function(el) {
 		this.el = el;
 		this.bindGlobalHandlers();
+		this.bindBaseRenderHandlers();
 		this.renderSkeleton();
 	},
 
@@ -8947,6 +9443,7 @@ var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
 		this.unrenderSkeleton();
 
 		this.unbindGlobalHandlers();
+		this.unbindBaseRenderHandlers();
 
 		this.el.remove();
 		// NOTE: don't null-out this.el in case the View was destroyed within an API callback.
@@ -8972,165 +9469,155 @@ var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
 
 
 	setDate: function(date) {
-		var isReset = this.isDateSet;
+		var currentDateProfile = this.get('dateProfile');
+		var newDateProfile = this.buildDateProfile(date, null, true); // forceToValid=true
+
+		if (
+			!currentDateProfile ||
+			!isRangesEqual(currentDateProfile.activeRange, newDateProfile.activeRange)
+		) {
+			this.set('dateProfile', newDateProfile);
+		}
 
-		this.isDateSet = true;
-		this.handleRawDate(date);
-		this.trigger(isReset ? 'dateReset' : 'dateSet', date);
+		return newDateProfile.date;
 	},
 
 
 	unsetDate: function() {
-		if (this.isDateSet) {
-			this.isDateSet = false;
-			this.handleDateUnset();
-			this.trigger('dateUnset');
-		}
+		this.unset('dateProfile');
 	},
 
 
-	// Date Handling
+	// Date Rendering
 	// -----------------------------------------------------------------------------------------------------------------
 
 
-	handleRawDate: function(date) {
+	requestDateRender: function(dateProfile) {
 		var _this = this;
-		var dateProfile = this.buildDateProfile(date, null, true); // forceToValid=true
 
-		if (!this.isSameDateProfile(dateProfile)) { // real change
-			this.handleDate(dateProfile);
-		}
-		else {
-			// View might have no date change, but still needs to render (because of a view unrender/rerender).
-			// Wait for possible queued unrenders. TODO: refactor.
-			this.dateRenderQueue.add(function() {
-				if (!_this.isDateRendered) {
-					_this.handleDate(dateProfile);
-				}
-			});
-		}
+		this.renderQueue.queue(function() {
+			_this.executeDateRender(dateProfile);
+		}, 'date', 'init');
 	},
 
 
-	handleDate: function(dateProfile) {
+	requestDateUnrender: function() {
 		var _this = this;
 
-		this.unbindEvents(); // will do nothing if not already bound
-		this.requestDateRender(dateProfile).then(function() {
-			// wish we could start earlier, but setDateProfile needs to execute first
-			_this.bindEvents(); // will request events
-		});
+		this.renderQueue.queue(function() {
+			_this.executeDateUnrender();
+		}, 'date', 'destroy');
 	},
 
 
-	handleDateUnset: function() {
-		this.unbindEvents();
-		this.requestDateUnrender();
+	// Event Data
+	// -----------------------------------------------------------------------------------------------------------------
+
+
+	fetchInitialEvents: function(dateProfile) {
+		return this.calendar.requestEvents(
+			dateProfile.activeRange.start,
+			dateProfile.activeRange.end
+		);
 	},
 
 
-	// Date Render Queuing
-	// -----------------------------------------------------------------------------------------------------------------
+	bindEventChanges: function() {
+		this.listenTo(this.calendar, 'eventsReset', this.resetEvents);
+	},
 
 
-	// if dateProfile not specified, uses current
-	requestDateRender: function(dateProfile) {
-		var _this = this;
+	unbindEventChanges: function() {
+		this.stopListeningTo(this.calendar, 'eventsReset');
+	},
 
-		return this.dateRenderQueue.add(function() {
-			return _this.executeDateRender(dateProfile);
-		});
+
+	setEvents: function(events) {
+		this.set('currentEvents', events);
+		this.set('hasEvents', true);
 	},
 
 
-	requestDateUnrender: function() {
-		var _this = this;
+	unsetEvents: function() {
+		this.unset('currentEvents');
+		this.unset('hasEvents');
+	},
 
-		return this.dateRenderQueue.add(function() {
-			return _this.executeDateUnrender();
-		});
+
+	resetEvents: function(events) {
+		this.startBatchRender();
+		this.unsetEvents();
+		this.setEvents(events);
+		this.stopBatchRender();
 	},
 
 
-	// Date High-level Rendering
+	// Event Rendering
 	// -----------------------------------------------------------------------------------------------------------------
 
 
-	// if dateProfile not specified, uses current
-	executeDateRender: function(dateProfile) {
+	requestEventsRender: function(events) {
 		var _this = this;
 
-		if (dateProfile) {
-			_this.setDateProfile(dateProfile);
-		}
+		this.renderQueue.queue(function() {
+			_this.executeEventsRender(events);
+		}, 'event', 'init');
+	},
 
-		this.updateTitle();
-		this.calendar.updateToolbarButtons();
 
-		// if rendering a new date, reset scroll to initial state (scrollTime)
-		if (dateProfile) {
-			this.captureInitialScroll();
-		}
-		else {
-			this.captureScroll(); // a rerender of the current date
-		}
+	requestEventsUnrender: function() {
+		var _this = this;
 
-		this.freezeHeight();
+		this.renderQueue.queue(function() {
+			_this.executeEventsUnrender();
+		}, 'event', 'destroy');
+	},
 
-		// potential issue: date-unrendering will happen with the *new* range
-		return this.executeDateUnrender().then(function() {
 
-			if (_this.render) {
-				_this.render(); // TODO: deprecate
-			}
+	// Date High-level Rendering
+	// -----------------------------------------------------------------------------------------------------------------
 
-			_this.renderDates();
-			_this.updateSize();
-			_this.renderBusinessHours(); // might need coordinates, so should go after updateSize()
-			_this.startNowIndicator();
 
-			_this.thawHeight();
-			_this.releaseScroll();
+	// if dateProfile not specified, uses current
+	executeDateRender: function(dateProfile, skipScroll) {
 
-			_this.isDateRendered = true;
-			_this.onDateRender();
-			_this.trigger('dateRender');
-		});
-	},
+		this.setDateProfileForRendering(dateProfile);
+		this.updateTitle();
+		this.calendar.updateToolbarButtons();
 
+		if (this.render) {
+			this.render(); // TODO: deprecate
+		}
 
-	executeDateUnrender: function() {
-		var _this = this;
+		this.renderDates();
+		this.updateSize();
+		this.renderBusinessHours(); // might need coordinates, so should go after updateSize()
+		this.startNowIndicator();
 
-		if (_this.isDateRendered) {
-			return this.requestEventsUnrender().then(function() {
+		if (!skipScroll) {
+			this.addScroll(this.computeInitialDateScroll());
+		}
 
-				_this.unselect();
-				_this.stopNowIndicator();
-				_this.triggerUnrender();
-				_this.unrenderBusinessHours();
-				_this.unrenderDates();
+		this.isDatesRendered = true;
+		this.trigger('datesRendered');
+	},
 
-				if (_this.destroy) {
-					_this.destroy(); // TODO: deprecate
-				}
 
-				_this.isDateRendered = false;
-				_this.trigger('dateUnrender');
-			});
-		}
-		else {
-			return Promise.resolve();
-		}
-	},
+	executeDateUnrender: function() {
 
+		this.unselect();
+		this.stopNowIndicator();
 
-	// Date Rendering Triggers
-	// -----------------------------------------------------------------------------------------------------------------
+		this.trigger('before:datesUnrendered');
 
+		this.unrenderBusinessHours();
+		this.unrenderDates();
+
+		if (this.destroy) {
+			this.destroy(); // TODO: deprecate
+		}
 
-	onDateRender: function() {
-		this.triggerRender();
+		this.isDatesRendered = false;
 	},
 
 
@@ -9150,22 +9637,44 @@ var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
 	},
 
 
-	// Misc view rendering utils
-	// -------------------------
+	// Determing when the "meat" of the view is rendered (aka the base)
+	// -----------------------------------------------------------------------------------------------------------------
+
+
+	bindBaseRenderHandlers: function() {
+		var _this = this;
+
+		this.on('datesRendered.baseHandler', function() {
+			_this.onBaseRender();
+		});
+
+		this.on('before:datesUnrendered.baseHandler', function() {
+			_this.onBeforeBaseUnrender();
+		});
+	},
+
+
+	unbindBaseRenderHandlers: function() {
+		this.off('.baseHandler');
+	},
 
 
-	// Signals that the view's content has been rendered
-	triggerRender: function() {
+	onBaseRender: function() {
+		this.applyScreenState();
 		this.publiclyTrigger('viewRender', this, this, this.el);
 	},
 
 
-	// Signals that the view's content is about to be unrendered
-	triggerUnrender: function() {
+	onBeforeBaseUnrender: function() {
+		this.applyScreenState();
 		this.publiclyTrigger('viewDestroy', this, this, this.el);
 	},
 
 
+	// Misc view rendering utils
+	// -----------------------------------------------------------------------------------------------------------------
+
+
 	// Binds DOM handlers to elements that reside outside the view container, such as the document
 	bindGlobalHandlers: function() {
 		this.listenTo(GlobalEmitter.get(), {
@@ -9301,9 +9810,10 @@ var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
 
 	// Refreshes anything dependant upon sizing of the container element of the grid
 	updateSize: function(isResize) {
+		var scroll;
 
 		if (isResize) {
-			this.captureScroll();
+			scroll = this.queryScroll();
 		}
 
 		this.updateHeight(isResize);
@@ -9311,7 +9821,7 @@ var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
 		this.updateNowIndicator();
 
 		if (isResize) {
-			this.releaseScroll();
+			this.applyScroll(scroll);
 		}
 	},
 
@@ -9344,90 +9854,65 @@ var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
 	------------------------------------------------------------------------------------------------------------------*/
 
 
-	capturedScroll: null,
-	capturedScrollDepth: 0,
-
-
-	captureScroll: function() {
-		if (!(this.capturedScrollDepth++)) {
-			this.capturedScroll = this.isDateRendered ? this.queryScroll() : {}; // require a render first
-			return true; // root?
-		}
-		return false;
+	addForcedScroll: function(scroll) {
+		this.addScroll(
+			$.extend(scroll, { isForced: true })
+		);
 	},
 
 
-	captureInitialScroll: function(forcedScroll) {
-		if (this.captureScroll()) { // root?
-			this.capturedScroll.isInitial = true;
+	addScroll: function(scroll) {
+		var queuedScroll = this.queuedScroll || (this.queuedScroll = {});
 
-			if (forcedScroll) {
-				$.extend(this.capturedScroll, forcedScroll);
-			}
-			else {
-				this.capturedScroll.isComputed = true;
-			}
+		if (!queuedScroll.isForced) {
+			$.extend(queuedScroll, scroll);
 		}
 	},
 
 
-	releaseScroll: function() {
-		var scroll = this.capturedScroll;
-		var isRoot = this.discardScroll();
-
-		if (scroll.isComputed) {
-			if (isRoot) {
-				// only compute initial scroll if it will actually be used (is the root capture)
-				$.extend(scroll, this.computeInitialScroll());
-			}
-			else {
-				scroll = null; // scroll couldn't be computed. don't apply it to the DOM
-			}
-		}
+	popScroll: function() {
+		this.applyQueuedScroll();
+		this.queuedScroll = null;
+	},
 
-		if (scroll) {
-			// we act immediately on a releaseScroll operation, as opposed to captureScroll.
-			// if capture/release wraps a render operation that screws up the scroll,
-			// we still want to restore it a good state after, regardless of depth.
 
-			if (scroll.isInitial) {
-				this.hardSetScroll(scroll); // outsmart how browsers set scroll on initial DOM
-			}
-			else {
-				this.setScroll(scroll);
-			}
+	applyQueuedScroll: function() {
+		if (this.queuedScroll) {
+			this.applyScroll(this.queuedScroll);
 		}
 	},
 
 
-	discardScroll: function() {
-		if (!(--this.capturedScrollDepth)) {
-			this.capturedScroll = null;
-			return true; // root?
+	queryScroll: function() {
+		var scroll = {};
+
+		if (this.isDatesRendered) {
+			$.extend(scroll, this.queryDateScroll());
 		}
-		return false;
+
+		return scroll;
 	},
 
 
-	computeInitialScroll: function() {
-		return {};
+	applyScroll: function(scroll) {
+		if (this.isDatesRendered) {
+			this.applyDateScroll(scroll);
+		}
 	},
 
 
-	queryScroll: function() {
-		return {};
+	computeInitialDateScroll: function() {
+		return {}; // subclasses must implement
 	},
 
 
-	hardSetScroll: function(scroll) {
-		var _this = this;
-		var exec = function() { _this.setScroll(scroll); };
-		exec();
-		setTimeout(exec, 0); // to surely clear the browser's initial scroll for the DOM
+	queryDateScroll: function() {
+		return {}; // subclasses must implement
 	},
 
 
-	setScroll: function(scroll) {
+	applyDateScroll: function(scroll) {
+		; // subclasses must implement
 	},
 
 
@@ -9445,165 +9930,27 @@ var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
 	},
 
 
-	// Event Binding/Unbinding
-	// -----------------------------------------------------------------------------------------------------------------
-
-
-	bindEvents: function() {
-		var _this = this;
-
-		if (!this.isEventsBound) {
-			this.isEventsBound = true;
-			this.rejectOn('eventsUnbind', this.requestEvents()).then(function(events) { // TODO: test rejection
-				_this.listenTo(_this.calendar, 'eventsReset', _this.setEvents);
-				_this.setEvents(events);
-			});
-		}
-	},
-
-
-	unbindEvents: function() {
-		if (this.isEventsBound) {
-			this.isEventsBound = false;
-			this.stopListeningTo(this.calendar, 'eventsReset');
-			this.unsetEvents();
-			this.trigger('eventsUnbind');
-		}
-	},
-
-
-	// Event Setting/Unsetting
-	// -----------------------------------------------------------------------------------------------------------------
-
-
-	setEvents: function(events) {
-		var isReset = this.isEventSet;
-
-		this.isEventsSet = true;
-		this.handleEvents(events, isReset);
-		this.trigger(isReset ? 'eventsReset' : 'eventsSet', events);
-	},
-
-
-	unsetEvents: function() {
-		if (this.isEventsSet) {
-			this.isEventsSet = false;
-			this.handleEventsUnset();
-			this.trigger('eventsUnset');
-		}
-	},
-
-
-	whenEventsSet: function() {
-		var _this = this;
-
-		if (this.isEventsSet) {
-			return Promise.resolve(this.getCurrentEvents());
-		}
-		else {
-			return new Promise(function(resolve) {
-				_this.one('eventsSet', resolve);
-			});
-		}
-	},
-
-
-	// Event Handling
-	// -----------------------------------------------------------------------------------------------------------------
-
-
-	handleEvents: function(events, isReset) {
-		this.requestEventsRender(events);
-	},
-
-
-	handleEventsUnset: function() {
-		this.requestEventsUnrender();
-	},
-
-
-	// Event Render Queuing
-	// -----------------------------------------------------------------------------------------------------------------
-
-
-	// assumes any previous event renders have been cleared already
-	requestEventsRender: function(events) {
-		var _this = this;
-
-		return this.eventRenderQueue.add(function() { // might not return a promise if debounced!? bad
-			return _this.executeEventsRender(events);
-		});
-	},
-
-
-	requestEventsUnrender: function() {
-		var _this = this;
-
-		if (this.isEventsRendered) {
-			return this.eventRenderQueue.addQuickly(function() {
-				return _this.executeEventsUnrender();
-			});
-		}
-		else {
-			return Promise.resolve();
-		}
-	},
-
-
-	requestCurrentEventsRender: function() {
-		if (this.isEventsSet) {
-			this.requestEventsRender(this.getCurrentEvents());
-		}
-		else {
-			return Promise.reject();
-		}
-	},
-
-
 	// Event High-level Rendering
 	// -----------------------------------------------------------------------------------------------------------------
 
 
 	executeEventsRender: function(events) {
-		var _this = this;
-
-		this.captureScroll();
-		this.freezeHeight();
+		this.renderEvents(events);
+		this.isEventsRendered = true;
 
-		return this.executeEventsUnrender().then(function() {
-			_this.renderEvents(events);
-
-			_this.thawHeight();
-			_this.releaseScroll();
-
-			_this.isEventsRendered = true;
-			_this.onEventsRender();
-			_this.trigger('eventsRender');
-		});
+		this.onEventsRender();
 	},
 
 
 	executeEventsUnrender: function() {
-		if (this.isEventsRendered) {
-			this.onBeforeEventsUnrender();
+		this.onBeforeEventsUnrender();
 
-			this.captureScroll();
-			this.freezeHeight();
-
-			if (this.destroyEvents) {
-				this.destroyEvents(); // TODO: deprecate
-			}
-
-			this.unrenderEvents();
-
-			this.thawHeight();
-			this.releaseScroll();
-
-			this.isEventsRendered = false;
-			this.trigger('eventsUnrender');
+		if (this.destroyEvents) {
+			this.destroyEvents(); // TODO: deprecate
 		}
 
-		return Promise.resolve(); // always synchronous
+		this.unrenderEvents();
+		this.isEventsRendered = false;
 	},
 
 
@@ -9613,6 +9960,8 @@ var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
 
 	// Signals that all events have been rendered
 	onEventsRender: function() {
+		this.applyScreenState();
+
 		this.renderedEventSegEach(function(seg) {
 			this.publiclyTrigger('eventAfterRender', seg.event, seg.event, seg.el);
 		});
@@ -9622,12 +9971,21 @@ var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
 
 	// Signals that all event elements are about to be removed
 	onBeforeEventsUnrender: function() {
+		this.applyScreenState();
+
 		this.renderedEventSegEach(function(seg) {
 			this.publiclyTrigger('eventDestroy', seg.event, seg.event, seg.el);
 		});
 	},
 
 
+	applyScreenState: function() {
+		this.thawHeight();
+		this.freezeHeight();
+		this.applyQueuedScroll();
+	},
+
+
 	// Event Low-level Rendering
 	// -----------------------------------------------------------------------------------------------------------------
 
@@ -9644,23 +10002,6 @@ var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
 	},
 
 
-	// Event Data Access
-	// -----------------------------------------------------------------------------------------------------------------
-
-
-	requestEvents: function() {
-		return this.calendar.requestEvents(
-			this.activeRange.start,
-			this.activeRange.end
-		);
-	},
-
-
-	getCurrentEvents: function() {
-		return this.calendar.getPrunedEventCache();
-	},
-
-
 	// Event Rendering Utils
 	// -----------------------------------------------------------------------------------------------------------------
 
@@ -10065,6 +10406,34 @@ var View = FC.View = Class.extend(EmitterMixin, ListenerMixin, {
 
 });
 
+
+View.watch('displayingDates', [ 'dateProfile' ], function(deps) {
+	this.requestDateRender(deps.dateProfile);
+}, function() {
+	this.requestDateUnrender();
+});
+
+
+View.watch('initialEvents', [ 'dateProfile' ], function(deps) {
+	return this.fetchInitialEvents(deps.dateProfile);
+});
+
+
+View.watch('bindingEvents', [ 'initialEvents' ], function(deps) {
+	this.setEvents(deps.initialEvents);
+	this.bindEventChanges();
+}, function() {
+	this.unbindEventChanges();
+	this.unsetEvents();
+});
+
+
+View.watch('displayingEvents', [ 'displayingDates', 'hasEvents' ], function() {
+	this.requestEventsRender(this.get('currentEvents')); // if there were event mutations after initialEvents
+}, function() {
+	this.requestEventsUnrender();
+});
+
 ;;
 
 View.mixin({
@@ -10088,10 +10457,6 @@ View.mixin({
 	// how far the current date will move for a prev/next operation
 	dateIncrement: null,
 
-	// stores the *calendar's* current date after setDate
-	// TODO: entirely Calendar's responsibility
-	currentDate: null,
-
 	minTime: null, // Duration object that denotes the first visible time of any given day
 	maxTime: null, // Duration object that denotes the exclusive visible end time of any given day
 	usesMinMaxTime: false, // whether minTime/maxTime will affect the activeRange. Views must opt-in.
@@ -10107,19 +10472,13 @@ View.mixin({
 	------------------------------------------------------------------------------------------------------------------*/
 
 
-	isSameDateProfile: function(dateProfile) {
-		return this.activeRange && isRangesEqual(this.activeRange, dateProfile.activeRange);
-	},
-
-
-	setDateProfile: function(dateProfile) {
+	setDateProfileForRendering: function(dateProfile) {
 		this.currentRange = dateProfile.currentRange;
 		this.currentRangeUnit = dateProfile.currentRangeUnit;
 		this.renderRange = dateProfile.renderRange;
 		this.activeRange = dateProfile.activeRange;
 		this.validRange = dateProfile.validRange;
 		this.dateIncrement = dateProfile.dateIncrement;
-		this.currentDate = dateProfile.date;
 		this.minTime = dateProfile.minTime;
 		this.maxTime = dateProfile.maxTime;
 
@@ -10675,7 +11034,7 @@ function Toolbar(calendar, toolbarOptions) {
 	function render() {
 		var sections = toolbarOptions.layout;
 
-		tm = calendar.options.theme ? 'ui' : 'fc';
+		tm = calendar.opt('theme') ? 'ui' : 'fc';
 
 		if (sections) {
 			if (!el) {
@@ -10706,6 +11065,8 @@ function Toolbar(calendar, toolbarOptions) {
 	function renderSection(position) {
 		var sectionEl = $('<div class="fc-' + position + '"/>');
 		var buttonStr = toolbarOptions.layout[position];
+		var calendarCustomButtons = calendar.opt('customButtons') || {};
+		var calendarButtonText = calendar.opt('buttonText') || {};
 
 		if (buttonStr) {
 			$.each(buttonStr.split(' '), function(i) {
@@ -10730,7 +11091,7 @@ function Toolbar(calendar, toolbarOptions) {
 						isOnlyButtons = false;
 					}
 					else {
-						if ((customButtonProps = (calendar.options.customButtons || {})[buttonName])) {
+						if ((customButtonProps = calendarCustomButtons[buttonName])) {
 							buttonClick = function(ev) {
 								if (customButtonProps.click) {
 									customButtonProps.click.call(button[0], ev);
@@ -10752,7 +11113,7 @@ function Toolbar(calendar, toolbarOptions) {
 								calendar[buttonName]();
 							};
 							overrideText = (calendar.overrides.buttonText || {})[buttonName];
-							defaultText = calendar.options.buttonText[buttonName]; // everything else is considered default
+							defaultText = calendarButtonText[buttonName]; // everything else is considered default
 						}
 
 						if (buttonClick) {
@@ -10760,20 +11121,20 @@ function Toolbar(calendar, toolbarOptions) {
 							themeIcon =
 								customButtonProps ?
 									customButtonProps.themeIcon :
-									calendar.options.themeButtonIcons[buttonName];
+									calendar.opt('themeButtonIcons')[buttonName];
 
 							normalIcon =
 								customButtonProps ?
 									customButtonProps.icon :
-									calendar.options.buttonIcons[buttonName];
+									calendar.opt('buttonIcons')[buttonName];
 
 							if (overrideText) {
 								innerHtml = htmlEscape(overrideText);
 							}
-							else if (themeIcon && calendar.options.theme) {
+							else if (themeIcon && calendar.opt('theme')) {
 								innerHtml = "<span class='ui-icon ui-icon-" + themeIcon + "'></span>";
 							}
-							else if (normalIcon && !calendar.options.theme) {
+							else if (normalIcon && !calendar.opt('theme')) {
 								innerHtml = "<span class='fc-icon fc-icon-" + normalIcon + "'></span>";
 							}
 							else {
@@ -10914,24 +11275,31 @@ function Toolbar(calendar, toolbarOptions) {
 
 ;;
 
-var Calendar = FC.Calendar = Class.extend({
+var Calendar = FC.Calendar = Class.extend(EmitterMixin, {
 
-	dirDefaults: null, // option defaults related to LTR or RTL
-	localeDefaults: null, // option defaults related to current locale
-	overrides: null, // option overrides given to the fullCalendar constructor
-	dynamicOverrides: null, // options set with dynamic setter method. higher precedence than view overrides.
-	options: null, // all defaults combined with overrides
-	viewSpecCache: null, // cache of view definitions
 	view: null, // current View object
+	viewsByType: null, // holds all instantiated view instances, current or not
 	currentDate: null, // unzoned moment. private (public API should use getDate instead)
-	header: null,
-	footer: null,
 	loadingLevel: 0, // number of simultaneous loading tasks
 
 
-	// a lot of this class' OOP logic is scoped within this constructor function,
-	// but in the future, write individual methods on the prototype.
-	constructor: Calendar_constructor,
+	constructor: function(el, overrides) {
+
+		// declare the current calendar instance relies on GlobalEmitter. needed for garbage collection.
+		// unneeded() is called in destroy.
+		GlobalEmitter.needed();
+
+		this.el = el;
+		this.viewsByType = {};
+		this.viewSpecCache = {};
+
+		this.initOptionsInternals(overrides);
+		this.initMomentInternals(); // needs to happen after options hash initialized
+		this.initCurrentDate();
+
+		EventManager.call(this); // needs options immediately
+		this.initialize();
+	},
 
 
 	// Subclasses can override this for initialization logic after the constructor has been called
@@ -10939,199 +11307,35 @@ var Calendar = FC.Calendar = Class.extend({
 	},
 
 
-	// Computes the flattened options hash for the calendar and assigns to `this.options`.
-	// Assumes this.overrides and this.dynamicOverrides have already been initialized.
-	populateOptionsHash: function() {
-		var locale, localeDefaults;
-		var isRTL, dirDefaults;
+	// Public API
+	// -----------------------------------------------------------------------------------------------------------------
 
-		locale = firstDefined( // explicit locale option given?
-			this.dynamicOverrides.locale,
-			this.overrides.locale
-		);
-		localeDefaults = localeOptionHash[locale];
-		if (!localeDefaults) { // explicit locale option not given or invalid?
-			locale = Calendar.defaults.locale;
-			localeDefaults = localeOptionHash[locale] || {};
-		}
 
-		isRTL = firstDefined( // based on options computed so far, is direction RTL?
-			this.dynamicOverrides.isRTL,
-			this.overrides.isRTL,
-			localeDefaults.isRTL,
-			Calendar.defaults.isRTL
-		);
-		dirDefaults = isRTL ? Calendar.rtlDefaults : {};
+	getCalendar: function() {
+		return this;
+	},
 
-		this.dirDefaults = dirDefaults;
-		this.localeDefaults = localeDefaults;
-		this.options = mergeOptions([ // merge defaults and overrides. lowest to highest precedence
-			Calendar.defaults, // global defaults
-			dirDefaults,
-			localeDefaults,
-			this.overrides,
-			this.dynamicOverrides
-		]);
-		populateInstanceComputableOptions(this.options); // fill in gaps with computed options
+
+	getView: function() {
+		return this.view;
 	},
 
 
-	// Gets information about how to create a view. Will use a cache.
-	getViewSpec: function(viewType) {
-		var cache = this.viewSpecCache;
+	publiclyTrigger: function(name, thisObj) {
+		var args = Array.prototype.slice.call(arguments, 2);
+		var optHandler = this.opt(name);
 
-		return cache[viewType] || (cache[viewType] = this.buildViewSpec(viewType));
+		thisObj = thisObj || this.el[0];
+		this.triggerWith(name, thisObj, args); // Emitter's method
+
+		if (optHandler) {
+			return optHandler.apply(thisObj, args);
+		}
 	},
 
 
-	// Given a duration singular unit, like "week" or "day", finds a matching view spec.
-	// Preference is given to views that have corresponding buttons.
-	getUnitViewSpec: function(unit) {
-		var viewTypes;
-		var i;
-		var spec;
-
-		if ($.inArray(unit, unitsDesc) != -1) {
-
-			// put views that have buttons first. there will be duplicates, but oh well
-			viewTypes = this.header.getViewsWithButtons(); // TODO: include footer as well?
-			$.each(FC.views, function(viewType) { // all views
-				viewTypes.push(viewType);
-			});
-
-			for (i = 0; i < viewTypes.length; i++) {
-				spec = this.getViewSpec(viewTypes[i]);
-				if (spec) {
-					if (spec.singleUnit == unit) {
-						return spec;
-					}
-				}
-			}
-		}
-	},
-
-
-	// Builds an object with information on how to create a given view
-	buildViewSpec: function(requestedViewType) {
-		var viewOverrides = this.overrides.views || {};
-		var specChain = []; // for the view. lowest to highest priority
-		var defaultsChain = []; // for the view. lowest to highest priority
-		var overridesChain = []; // for the view. lowest to highest priority
-		var viewType = requestedViewType;
-		var spec; // for the view
-		var overrides; // for the view
-		var durationInput;
-		var duration;
-		var unit;
-
-		// iterate from the specific view definition to a more general one until we hit an actual View class
-		while (viewType) {
-			spec = fcViews[viewType];
-			overrides = viewOverrides[viewType];
-			viewType = null; // clear. might repopulate for another iteration
-
-			if (typeof spec === 'function') { // TODO: deprecate
-				spec = { 'class': spec };
-			}
-
-			if (spec) {
-				specChain.unshift(spec);
-				defaultsChain.unshift(spec.defaults || {});
-				durationInput = durationInput || spec.duration;
-				viewType = viewType || spec.type;
-			}
-
-			if (overrides) {
-				overridesChain.unshift(overrides); // view-specific option hashes have options at zero-level
-				durationInput = durationInput || overrides.duration;
-				viewType = viewType || overrides.type;
-			}
-		}
-
-		spec = mergeProps(specChain);
-		spec.type = requestedViewType;
-		if (!spec['class']) {
-			return false;
-		}
-
-		// fall back to top-level `duration` option
-		durationInput = durationInput ||
-			this.dynamicOverrides.duration ||
-			this.overrides.duration;
-
-		if (durationInput) {
-			duration = moment.duration(durationInput);
-
-			if (duration.valueOf()) { // valid?
-
-				unit = computeDurationGreatestUnit(duration, durationInput);
-
-				spec.duration = duration;
-				spec.durationUnit = unit;
-
-				// view is a single-unit duration, like "week" or "day"
-				// incorporate options for this. lowest priority
-				if (duration.as(unit) === 1) {
-					spec.singleUnit = unit;
-					overridesChain.unshift(viewOverrides[unit] || {});
-				}
-			}
-		}
-
-		spec.defaults = mergeOptions(defaultsChain);
-		spec.overrides = mergeOptions(overridesChain);
-
-		this.buildViewSpecOptions(spec);
-		this.buildViewSpecButtonText(spec, requestedViewType);
-
-		return spec;
-	},
-
-
-	// Builds and assigns a view spec's options object from its already-assigned defaults and overrides
-	buildViewSpecOptions: function(spec) {
-		spec.options = mergeOptions([ // lowest to highest priority
-			Calendar.defaults, // global defaults
-			spec.defaults, // view's defaults (from ViewSubclass.defaults)
-			this.dirDefaults,
-			this.localeDefaults, // locale and dir take precedence over view's defaults!
-			this.overrides, // calendar's overrides (options given to constructor)
-			spec.overrides, // view's overrides (view-specific options)
-			this.dynamicOverrides // dynamically set via setter. highest precedence
-		]);
-		populateInstanceComputableOptions(spec.options);
-	},
-
-
-	// Computes and assigns a view spec's buttonText-related options
-	buildViewSpecButtonText: function(spec, requestedViewType) {
-
-		// given an options object with a possible `buttonText` hash, lookup the buttonText for the
-		// requested view, falling back to a generic unit entry like "week" or "day"
-		function queryButtonText(options) {
-			var buttonText = options.buttonText || {};
-			return buttonText[requestedViewType] ||
-				// view can decide to look up a certain key
-				(spec.buttonTextKey ? buttonText[spec.buttonTextKey] : null) ||
-				// a key like "month"
-				(spec.singleUnit ? buttonText[spec.singleUnit] : null);
-		}
-
-		// highest to lowest priority
-		spec.buttonTextOverride =
-			queryButtonText(this.dynamicOverrides) ||
-			queryButtonText(this.overrides) || // constructor-specified buttonText lookup hash takes precedence
-			spec.overrides.buttonText; // `buttonText` for view-specific options is a string
-
-		// highest to lowest priority. mirrors buildViewSpecOptions
-		spec.buttonTextDefault =
-			queryButtonText(this.localeDefaults) ||
-			queryButtonText(this.dirDefaults) ||
-			spec.defaults.buttonText || // a single string. from ViewSubclass.defaults
-			queryButtonText(Calendar.defaults) ||
-			(spec.duration ? this.humanizeDuration(spec.duration) : null) || // like "3 days"
-			requestedViewType; // fall back to given view name
-	},
+	// View
+	// -----------------------------------------------------------------------------------------------------------------
 
 
 	// Given a view name for a custom view or a standard view, creates a ready-to-go View object
@@ -11148,52 +11352,47 @@ var Calendar = FC.Calendar = Class.extend({
 	},
 
 
-	// Should be called when any type of async data fetching begins
-	pushLoading: function() {
-		if (!(this.loadingLevel++)) {
-			this.publiclyTrigger('loading', null, true, this.view);
-		}
-	},
+	changeView: function(viewName, dateOrRange) {
 
+		if (dateOrRange) {
 
-	// Should be called when any type of async data fetching completes
-	popLoading: function() {
-		if (!(--this.loadingLevel)) {
-			this.publiclyTrigger('loading', null, false, this.view);
+			if (dateOrRange.start && dateOrRange.end) { // a range
+				this.recordOptionOverrides({ // will not rerender
+					visibleRange: dateOrRange
+				});
+			}
+			else { // a date
+				this.currentDate = this.moment(dateOrRange).stripZone(); // just like gotoDate
+			}
 		}
+
+		this.renderView(viewName);
 	},
 
 
-	// Given arguments to the select method in the API, returns a span (unzoned start/end and other info)
-	buildSelectSpan: function(zonedStartInput, zonedEndInput) {
-		var start = this.moment(zonedStartInput).stripZone();
-		var end;
+	// Forces navigation to a view for the given date.
+	// `viewType` can be a specific view name or a generic one like "week" or "day".
+	zoomTo: function(newDate, viewType) {
+		var spec;
 
-		if (zonedEndInput) {
-			end = this.moment(zonedEndInput).stripZone();
-		}
-		else if (start.hasTime()) {
-			end = start.clone().add(this.defaultTimedEventDuration);
-		}
-		else {
-			end = start.clone().add(this.defaultAllDayEventDuration);
-		}
+		viewType = viewType || 'day'; // day is default zoom
+		spec = this.getViewSpec(viewType) || this.getUnitViewSpec(viewType);
 
-		return { start: start, end: end };
+		this.currentDate = newDate.clone();
+		this.renderView(spec ? spec.type : null);
 	},
 
 
 	// Current Date
-	// ------------
+	// -----------------------------------------------------------------------------------------------------------------
 
 
-	/*
-	Called before initialize()
-	*/
 	initCurrentDate: function() {
+		var defaultDateInput = this.opt('defaultDate');
+
 		// compute the initial ambig-timezone date
-		if (this.options.defaultDate != null) {
-			this.currentDate = this.moment(this.options.defaultDate).stripZone();
+		if (defaultDateInput != null) {
+			this.currentDate = this.moment(defaultDateInput).stripZone();
 		}
 		else {
 			this.currentDate = this.getNow(); // getNow already returns unzoned
@@ -11201,24 +11400,6 @@ var Calendar = FC.Calendar = Class.extend({
 	},
 
 
-	changeView: function(viewName, dateOrRange) {
-
-		if (dateOrRange) {
-
-			if (dateOrRange.start && dateOrRange.end) { // a range
-				this.recordOptionOverrides({ // will not rerender
-					visibleRange: dateOrRange
-				});
-			}
-			else { // a date
-				this.currentDate = this.moment(dateOrRange).stripZone(); // just like gotoDate
-			}
-		}
-
-		this.renderView(viewName);
-	},
-
-
 	prev: function() {
 		var prevInfo = this.view.buildPrevDateProfile(this.currentDate);
 
@@ -11275,6 +11456,68 @@ var Calendar = FC.Calendar = Class.extend({
 	},
 
 
+	// Loading Triggering
+	// -----------------------------------------------------------------------------------------------------------------
+
+
+	// Should be called when any type of async data fetching begins
+	pushLoading: function() {
+		if (!(this.loadingLevel++)) {
+			this.publiclyTrigger('loading', null, true, this.view);
+		}
+	},
+
+
+	// Should be called when any type of async data fetching completes
+	popLoading: function() {
+		if (!(--this.loadingLevel)) {
+			this.publiclyTrigger('loading', null, false, this.view);
+		}
+	},
+
+
+	// Selection
+	// -----------------------------------------------------------------------------------------------------------------
+
+
+	// this public method receives start/end dates in any format, with any timezone
+	select: function(zonedStartInput, zonedEndInput) {
+		this.view.select(
+			this.buildSelectSpan.apply(this, arguments)
+		);
+	},
+
+
+	unselect: function() { // safe to be called before renderView
+		if (this.view) {
+			this.view.unselect();
+		}
+	},
+
+
+	// Given arguments to the select method in the API, returns a span (unzoned start/end and other info)
+	buildSelectSpan: function(zonedStartInput, zonedEndInput) {
+		var start = this.moment(zonedStartInput).stripZone();
+		var end;
+
+		if (zonedEndInput) {
+			end = this.moment(zonedEndInput).stripZone();
+		}
+		else if (start.hasTime()) {
+			end = start.clone().add(this.defaultTimedEventDuration);
+		}
+		else {
+			end = start.clone().add(this.defaultAllDayEventDuration);
+		}
+
+		return { start: start, end: end };
+	},
+
+
+	// Misc
+	// -----------------------------------------------------------------------------------------------------------------
+
+
 	// will return `null` if invalid range
 	parseRange: function(rangeInput) {
 		var start = null;
@@ -11297,122 +11540,247 @@ var Calendar = FC.Calendar = Class.extend({
 		}
 
 		return { start: start, end: end };
-	}
+	},
 
-});
 
+	rerenderEvents: function() { // API method. destroys old events if previously rendered.
+		if (this.elementVisible()) {
+			this.reportEventChange(); // will re-trasmit events to the view, causing a rerender
+		}
+	}
 
-Calendar.mixin(EmitterMixin);
+});
 
+;;
+/*
+Options binding/triggering system.
+*/
+Calendar.mixin({
 
-function Calendar_constructor(element, overrides) {
-	var t = this;
+	dirDefaults: null, // option defaults related to LTR or RTL
+	localeDefaults: null, // option defaults related to current locale
+	overrides: null, // option overrides given to the fullCalendar constructor
+	dynamicOverrides: null, // options set with dynamic setter method. higher precedence than view overrides.
+	optionsModel: null, // all defaults combined with overrides
 
-	// declare the current calendar instance relies on GlobalEmitter. needed for garbage collection.
-	GlobalEmitter.needed();
 
+	initOptionsInternals: function(overrides) {
+		this.overrides = $.extend({}, overrides); // make a copy
+		this.dynamicOverrides = {};
+		this.optionsModel = new Model();
 
-	// Exports
-	// -----------------------------------------------------------------------------------
+		this.populateOptionsHash();
+	},
 
-	t.render = render;
-	t.destroy = destroy;
-	t.rerenderEvents = rerenderEvents;
-	t.select = select;
-	t.unselect = unselect;
-	t.zoomTo = zoomTo;
-	t.getCalendar = getCalendar;
-	t.getView = getView;
-	t.option = option; // getter/setter method
-	t.recordOptionOverrides = recordOptionOverrides;
-	t.publiclyTrigger = publiclyTrigger;
-
-
-	// Options
-	// -----------------------------------------------------------------------------------
 
-	t.dynamicOverrides = {};
-	t.viewSpecCache = {};
-	t.optionHandlers = {}; // for Calendar.options.js
-	t.overrides = $.extend({}, overrides); // make a copy
+	// public getter/setter
+	option: function(name, value) {
+		var newOptionHash;
 
-	t.populateOptionsHash(); // sets this.options
+		if (typeof name === 'string') {
+			if (value === undefined) { // getter
+				return this.optionsModel.get(name);
+			}
+			else { // setter for individual option
+				newOptionHash = {};
+				newOptionHash[name] = value;
+				this.setOptions(newOptionHash);
+			}
+		}
+		else if (typeof name === 'object') { // compound setter with object input
+			this.setOptions(name);
+		}
+	},
 
 
+	// private getter
+	opt: function(name) {
+		return this.optionsModel.get(name);
+	},
 
-	// Locale-data Internals
-	// -----------------------------------------------------------------------------------
-	// Apply overrides to the current locale's data
 
-	var localeData;
+	setOptions: function(newOptionHash) {
+		var optionCnt = 0;
+		var optionName;
 
-	// Called immediately, and when any of the options change.
-	// Happens before any internal objects rebuild or rerender, because this is very core.
-	t.bindOptions([
-		'locale', 'monthNames', 'monthNamesShort', 'dayNames', 'dayNamesShort', 'firstDay', 'weekNumberCalculation'
-	], function(locale, monthNames, monthNamesShort, dayNames, dayNamesShort, firstDay, weekNumberCalculation) {
+		this.recordOptionOverrides(newOptionHash);
 
-		// normalize
-		if (weekNumberCalculation === 'iso') {
-			weekNumberCalculation = 'ISO'; // normalize
+		for (optionName in newOptionHash) {
+			optionCnt++;
 		}
 
-		localeData = createObject( // make a cheap copy
-			getMomentLocaleData(locale) // will fall back to en
-		);
-
-		if (monthNames) {
-			localeData._months = monthNames;
-		}
-		if (monthNamesShort) {
-			localeData._monthsShort = monthNamesShort;
-		}
-		if (dayNames) {
-			localeData._weekdays = dayNames;
-		}
-		if (dayNamesShort) {
-			localeData._weekdaysShort = dayNamesShort;
+		// special-case handling of single option change.
+		// if only one option change, `optionName` will be its name.
+		if (optionCnt === 1) {
+			if (optionName === 'height' || optionName === 'contentHeight' || optionName === 'aspectRatio') {
+				this.updateSize(true); // true = allow recalculation of height
+				return;
+			}
+			else if (optionName === 'defaultDate') {
+				return; // can't change date this way. use gotoDate instead
+			}
+			else if (optionName === 'businessHours') {
+				if (this.view) {
+					this.view.unrenderBusinessHours();
+					this.view.renderBusinessHours();
+				}
+				return;
+			}
+			else if (optionName === 'timezone') {
+				this.rezoneArrayEventSources();
+				this.refetchEvents();
+				return;
+			}
 		}
 
-		if (firstDay == null && weekNumberCalculation === 'ISO') {
-			firstDay = 1;
-		}
-		if (firstDay != null) {
-			var _week = createObject(localeData._week); // _week: { dow: # }
-			_week.dow = firstDay;
-			localeData._week = _week;
-		}
+		// catch-all. rerender the header and footer and rebuild/rerender the current view
+		this.renderHeader();
+		this.renderFooter();
 
-		if ( // whitelist certain kinds of input
-			weekNumberCalculation === 'ISO' ||
-			weekNumberCalculation === 'local' ||
-			typeof weekNumberCalculation === 'function'
-		) {
-			localeData._fullCalendar_weekCalc = weekNumberCalculation; // moment-ext will know what to do with it
+		// even non-current views will be affected by this option change. do before rerender
+		// TODO: detangle
+		this.viewsByType = {};
+
+		this.reinitView();
+	},
+
+
+	// Computes the flattened options hash for the calendar and assigns to `this.options`.
+	// Assumes this.overrides and this.dynamicOverrides have already been initialized.
+	populateOptionsHash: function() {
+		var locale, localeDefaults;
+		var isRTL, dirDefaults;
+		var rawOptions;
+
+		locale = firstDefined( // explicit locale option given?
+			this.dynamicOverrides.locale,
+			this.overrides.locale
+		);
+		localeDefaults = localeOptionHash[locale];
+		if (!localeDefaults) { // explicit locale option not given or invalid?
+			locale = Calendar.defaults.locale;
+			localeDefaults = localeOptionHash[locale] || {};
 		}
 
-		// If the internal current date object already exists, move to new locale.
-		// We do NOT need to do this technique for event dates, because this happens when converting to "segments".
-		if (t.currentDate) {
-			localizeMoment(t.currentDate); // sets to localeData
+		isRTL = firstDefined( // based on options computed so far, is direction RTL?
+			this.dynamicOverrides.isRTL,
+			this.overrides.isRTL,
+			localeDefaults.isRTL,
+			Calendar.defaults.isRTL
+		);
+		dirDefaults = isRTL ? Calendar.rtlDefaults : {};
+
+		this.dirDefaults = dirDefaults;
+		this.localeDefaults = localeDefaults;
+
+		rawOptions = mergeOptions([ // merge defaults and overrides. lowest to highest precedence
+			Calendar.defaults, // global defaults
+			dirDefaults,
+			localeDefaults,
+			this.overrides,
+			this.dynamicOverrides
+		]);
+		populateInstanceComputableOptions(rawOptions); // fill in gaps with computed options
+
+		this.optionsModel.reset(rawOptions);
+	},
+
+
+	// stores the new options internally, but does not rerender anything.
+	recordOptionOverrides: function(newOptionHash) {
+		var optionName;
+
+		for (optionName in newOptionHash) {
+			this.dynamicOverrides[optionName] = newOptionHash[optionName];
 		}
-	});
 
+		this.viewSpecCache = {}; // the dynamic override invalidates the options in this cache, so just clear it
+		this.populateOptionsHash(); // this.options needs to be recomputed after the dynamic override
+	}
 
-	// Calendar-specific Date Utilities
-	// -----------------------------------------------------------------------------------
+});
+
+;;
+
+Calendar.mixin({
+
+	defaultAllDayEventDuration: null,
+	defaultTimedEventDuration: null,
+	localeData: null,
+
+
+	initMomentInternals: function() {
+		var _this = this;
 
+		this.defaultAllDayEventDuration = moment.duration(this.opt('defaultAllDayEventDuration'));
+		this.defaultTimedEventDuration = moment.duration(this.opt('defaultTimedEventDuration'));
 
-	t.defaultAllDayEventDuration = moment.duration(t.options.defaultAllDayEventDuration);
-	t.defaultTimedEventDuration = moment.duration(t.options.defaultTimedEventDuration);
+		// Called immediately, and when any of the options change.
+		// Happens before any internal objects rebuild or rerender, because this is very core.
+		this.optionsModel.watch('buildingMomentLocale', [
+			'?locale', '?monthNames', '?monthNamesShort', '?dayNames', '?dayNamesShort',
+			'?firstDay', '?weekNumberCalculation'
+		], function(opts) {
+			var weekNumberCalculation = opts.weekNumberCalculation;
+			var firstDay = opts.firstDay;
+			var _week;
+
+			// normalize
+			if (weekNumberCalculation === 'iso') {
+				weekNumberCalculation = 'ISO'; // normalize
+			}
+
+			var localeData = createObject( // make a cheap copy
+				getMomentLocaleData(opts.locale) // will fall back to en
+			);
+
+			if (opts.monthNames) {
+				localeData._months = opts.monthNames;
+			}
+			if (opts.monthNamesShort) {
+				localeData._monthsShort = opts.monthNamesShort;
+			}
+			if (opts.dayNames) {
+				localeData._weekdays = opts.dayNames;
+			}
+			if (opts.dayNamesShort) {
+				localeData._weekdaysShort = opts.dayNamesShort;
+			}
+
+			if (firstDay == null && weekNumberCalculation === 'ISO') {
+				firstDay = 1;
+			}
+			if (firstDay != null) {
+				_week = createObject(localeData._week); // _week: { dow: # }
+				_week.dow = firstDay;
+				localeData._week = _week;
+			}
+
+			if ( // whitelist certain kinds of input
+				weekNumberCalculation === 'ISO' ||
+				weekNumberCalculation === 'local' ||
+				typeof weekNumberCalculation === 'function'
+			) {
+				localeData._fullCalendar_weekCalc = weekNumberCalculation; // moment-ext will know what to do with it
+			}
+
+			_this.localeData = localeData;
+
+			// If the internal current date object already exists, move to new locale.
+			// We do NOT need to do this technique for event dates, because this happens when converting to "segments".
+			if (_this.currentDate) {
+				_this.localizeMoment(_this.currentDate); // sets to localeData
+			}
+		});
+	},
 
 
 	// Builds a moment using the settings of the current calendar: timezone and locale.
 	// Accepts anything the vanilla moment() constructor accepts.
-	t.moment = function() {
+	moment: function() {
 		var mom;
 
-		if (t.options.timezone === 'local') {
+		if (this.opt('timezone') === 'local') {
 			mom = FC.moment.apply(null, arguments);
 
 			// Force the moment to be local, because FC.moment doesn't guarantee it.
@@ -11420,40 +11788,39 @@ function Calendar_constructor(element, overrides) {
 				mom.local();
 			}
 		}
-		else if (t.options.timezone === 'UTC') {
+		else if (this.opt('timezone') === 'UTC') {
 			mom = FC.moment.utc.apply(null, arguments); // process as UTC
 		}
 		else {
 			mom = FC.moment.parseZone.apply(null, arguments); // let the input decide the zone
 		}
 
-		localizeMoment(mom);
+		this.localizeMoment(mom); // TODO
 
 		return mom;
-	};
+	},
 
 
 	// Updates the given moment's locale settings to the current calendar locale settings.
-	function localizeMoment(mom) {
-		mom._locale = localeData;
-	}
-	t.localizeMoment = localizeMoment;
+	localizeMoment: function(mom) {
+		mom._locale = this.localeData;
+	},
 
 
 	// Returns a boolean about whether or not the calendar knows how to calculate
 	// the timezone offset of arbitrary dates in the current timezone.
-	t.getIsAmbigTimezone = function() {
-		return t.options.timezone !== 'local' && t.options.timezone !== 'UTC';
-	};
+	getIsAmbigTimezone: function() {
+		return this.opt('timezone') !== 'local' && this.opt('timezone') !== 'UTC';
+	},
 
 
 	// Returns a copy of the given date in the current timezone. Has no effect on dates without times.
-	t.applyTimezone = function(date) {
+	applyTimezone: function(date) {
 		if (!date.hasTime()) {
 			return date.clone();
 		}
 
-		var zonedDate = t.moment(date.toArray());
+		var zonedDate = this.moment(date.toArray());
 		var timeAdjust = date.time() - zonedDate.time();
 		var adjustedZonedDate;
 
@@ -11466,115 +11833,268 @@ function Calendar_constructor(element, overrides) {
 		}
 
 		return zonedDate;
-	};
+	},
 
 
 	// Returns a moment for the current date, as defined by the client's computer or from the `now` option.
 	// Will return an moment with an ambiguous timezone.
-	t.getNow = function() {
-		var now = t.options.now;
+	getNow: function() {
+		var now = this.opt('now');
 		if (typeof now === 'function') {
 			now = now();
 		}
-		return t.moment(now).stripZone();
-	};
+		return this.moment(now).stripZone();
+	},
+
+
+	// Produces a human-readable string for the given duration.
+	// Side-effect: changes the locale of the given duration.
+	humanizeDuration: function(duration) {
+		return duration.locale(this.opt('locale')).humanize();
+	},
+
+
+
+	// Event-Specific Date Utilities. TODO: move
+	// -----------------------------------------------------------------------------------------------------------------
 
 
 	// Get an event's normalized end date. If not present, calculate it from the defaults.
-	t.getEventEnd = function(event) {
+	getEventEnd: function(event) {
 		if (event.end) {
 			return event.end.clone();
 		}
 		else {
-			return t.getDefaultEventEnd(event.allDay, event.start);
+			return this.getDefaultEventEnd(event.allDay, event.start);
 		}
-	};
+	},
 
 
 	// Given an event's allDay status and start date, return what its fallback end date should be.
 	// TODO: rename to computeDefaultEventEnd
-	t.getDefaultEventEnd = function(allDay, zonedStart) {
+	getDefaultEventEnd: function(allDay, zonedStart) {
 		var end = zonedStart.clone();
 
 		if (allDay) {
-			end.stripTime().add(t.defaultAllDayEventDuration);
+			end.stripTime().add(this.defaultAllDayEventDuration);
 		}
 		else {
-			end.add(t.defaultTimedEventDuration);
+			end.add(this.defaultTimedEventDuration);
 		}
 
-		if (t.getIsAmbigTimezone()) {
+		if (this.getIsAmbigTimezone()) {
 			end.stripZone(); // we don't know what the tzo should be
 		}
 
 		return end;
-	};
+	}
 
+});
 
-	// Produces a human-readable string for the given duration.
-	// Side-effect: changes the locale of the given duration.
-	t.humanizeDuration = function(duration) {
-		return duration.locale(t.options.locale).humanize();
-	};
+;;
 
+Calendar.mixin({
 
+	viewSpecCache: null, // cache of view definitions (initialized in Calendar.js)
 
-	// Imports
-	// -----------------------------------------------------------------------------------
+
+	// Gets information about how to create a view. Will use a cache.
+	getViewSpec: function(viewType) {
+		var cache = this.viewSpecCache;
+
+		return cache[viewType] || (cache[viewType] = this.buildViewSpec(viewType));
+	},
 
 
-	EventManager.call(t);
+	// Given a duration singular unit, like "week" or "day", finds a matching view spec.
+	// Preference is given to views that have corresponding buttons.
+	getUnitViewSpec: function(unit) {
+		var viewTypes;
+		var i;
+		var spec;
 
+		if ($.inArray(unit, unitsDesc) != -1) {
 
+			// put views that have buttons first. there will be duplicates, but oh well
+			viewTypes = this.header.getViewsWithButtons(); // TODO: include footer as well?
+			$.each(FC.views, function(viewType) { // all views
+				viewTypes.push(viewType);
+			});
 
-	// Locals
-	// -----------------------------------------------------------------------------------
+			for (i = 0; i < viewTypes.length; i++) {
+				spec = this.getViewSpec(viewTypes[i]);
+				if (spec) {
+					if (spec.singleUnit == unit) {
+						return spec;
+					}
+				}
+			}
+		}
+	},
+
+
+	// Builds an object with information on how to create a given view
+	buildViewSpec: function(requestedViewType) {
+		var viewOverrides = this.overrides.views || {};
+		var specChain = []; // for the view. lowest to highest priority
+		var defaultsChain = []; // for the view. lowest to highest priority
+		var overridesChain = []; // for the view. lowest to highest priority
+		var viewType = requestedViewType;
+		var spec; // for the view
+		var overrides; // for the view
+		var durationInput;
+		var duration;
+		var unit;
+
+		// iterate from the specific view definition to a more general one until we hit an actual View class
+		while (viewType) {
+			spec = fcViews[viewType];
+			overrides = viewOverrides[viewType];
+			viewType = null; // clear. might repopulate for another iteration
 
+			if (typeof spec === 'function') { // TODO: deprecate
+				spec = { 'class': spec };
+			}
+
+			if (spec) {
+				specChain.unshift(spec);
+				defaultsChain.unshift(spec.defaults || {});
+				durationInput = durationInput || spec.duration;
+				viewType = viewType || spec.type;
+			}
+
+			if (overrides) {
+				overridesChain.unshift(overrides); // view-specific option hashes have options at zero-level
+				durationInput = durationInput || overrides.duration;
+				viewType = viewType || overrides.type;
+			}
+		}
+
+		spec = mergeProps(specChain);
+		spec.type = requestedViewType;
+		if (!spec['class']) {
+			return false;
+		}
+
+		// fall back to top-level `duration` option
+		durationInput = durationInput ||
+			this.dynamicOverrides.duration ||
+			this.overrides.duration;
+
+		if (durationInput) {
+			duration = moment.duration(durationInput);
+
+			if (duration.valueOf()) { // valid?
+
+				unit = computeDurationGreatestUnit(duration, durationInput);
+
+				spec.duration = duration;
+				spec.durationUnit = unit;
+
+				// view is a single-unit duration, like "week" or "day"
+				// incorporate options for this. lowest priority
+				if (duration.as(unit) === 1) {
+					spec.singleUnit = unit;
+					overridesChain.unshift(viewOverrides[unit] || {});
+				}
+			}
+		}
+
+		spec.defaults = mergeOptions(defaultsChain);
+		spec.overrides = mergeOptions(overridesChain);
+
+		this.buildViewSpecOptions(spec);
+		this.buildViewSpecButtonText(spec, requestedViewType);
+
+		return spec;
+	},
+
+
+	// Builds and assigns a view spec's options object from its already-assigned defaults and overrides
+	buildViewSpecOptions: function(spec) {
+		spec.options = mergeOptions([ // lowest to highest priority
+			Calendar.defaults, // global defaults
+			spec.defaults, // view's defaults (from ViewSubclass.defaults)
+			this.dirDefaults,
+			this.localeDefaults, // locale and dir take precedence over view's defaults!
+			this.overrides, // calendar's overrides (options given to constructor)
+			spec.overrides, // view's overrides (view-specific options)
+			this.dynamicOverrides // dynamically set via setter. highest precedence
+		]);
+		populateInstanceComputableOptions(spec.options);
+	},
+
+
+	// Computes and assigns a view spec's buttonText-related options
+	buildViewSpecButtonText: function(spec, requestedViewType) {
+
+		// given an options object with a possible `buttonText` hash, lookup the buttonText for the
+		// requested view, falling back to a generic unit entry like "week" or "day"
+		function queryButtonText(options) {
+			var buttonText = options.buttonText || {};
+			return buttonText[requestedViewType] ||
+				// view can decide to look up a certain key
+				(spec.buttonTextKey ? buttonText[spec.buttonTextKey] : null) ||
+				// a key like "month"
+				(spec.singleUnit ? buttonText[spec.singleUnit] : null);
+		}
+
+		// highest to lowest priority
+		spec.buttonTextOverride =
+			queryButtonText(this.dynamicOverrides) ||
+			queryButtonText(this.overrides) || // constructor-specified buttonText lookup hash takes precedence
+			spec.overrides.buttonText; // `buttonText` for view-specific options is a string
 
-	var _element = element[0];
-	var toolbarsManager;
-	var header;
-	var footer;
-	var content;
-	var tm; // for making theme classes
-	var currentView; // NOTE: keep this in sync with this.view
-	var viewsByType = {}; // holds all instantiated view instances, current or not
-	var suggestedViewHeight;
-	var windowResizeProxy; // wraps the windowResize function
-	var ignoreWindowResize = 0;
+		// highest to lowest priority. mirrors buildViewSpecOptions
+		spec.buttonTextDefault =
+			queryButtonText(this.localeDefaults) ||
+			queryButtonText(this.dirDefaults) ||
+			spec.defaults.buttonText || // a single string. from ViewSubclass.defaults
+			queryButtonText(Calendar.defaults) ||
+			(spec.duration ? this.humanizeDuration(spec.duration) : null) || // like "3 days"
+			requestedViewType; // fall back to given view name
+	}
 
+});
 
-	this.initCurrentDate();
+;;
 
+Calendar.mixin({
 
-	// Main Rendering
-	// -----------------------------------------------------------------------------------
+	el: null,
+	contentEl: null,
+	suggestedViewHeight: null,
+	windowResizeProxy: null,
+	ignoreWindowResize: 0,
 
 
-	function render() {
-		if (!content) {
-			initialRender();
+	render: function() {
+		if (!this.contentEl) {
+			this.initialRender();
 		}
-		else if (elementVisible()) {
+		else if (this.elementVisible()) {
 			// mainly for the public API
-			calcSize();
-			renderView();
+			this.calcSize();
+			this.renderView();
 		}
-	}
+	},
+
 
+	initialRender: function() {
+		var _this = this;
+		var el = this.el;
 
-	function initialRender() {
-		element.addClass('fc');
+		el.addClass('fc');
 
 		// event delegation for nav links
-		element.on('click.fc', 'a[data-goto]', function(ev) {
+		el.on('click.fc', 'a[data-goto]', function(ev) {
 			var anchorEl = $(this);
 			var gotoOptions = anchorEl.data('goto'); // will automatically parse JSON
-			var date = t.moment(gotoOptions.date);
+			var date = _this.moment(gotoOptions.date);
 			var viewType = gotoOptions.type;
 
 			// property like "navLinkDayClick". might be a string or a function
-			var customAction = currentView.opt('navLink' + capitaliseFirstLetter(viewType) + 'Click');
+			var customAction = _this.view.opt('navLink' + capitaliseFirstLetter(viewType) + 'Click');
 
 			if (typeof customAction === 'function') {
 				customAction(date, ev);
@@ -11583,69 +12103,68 @@ function Calendar_constructor(element, overrides) {
 				if (typeof customAction === 'string') {
 					viewType = customAction;
 				}
-				zoomTo(date, viewType);
+				_this.zoomTo(date, viewType);
 			}
 		});
 
 		// called immediately, and upon option change
-		t.bindOption('theme', function(theme) {
-			tm = theme ? 'ui' : 'fc'; // affects a larger scope
-			element.toggleClass('ui-widget', theme);
-			element.toggleClass('fc-unthemed', !theme);
+		this.optionsModel.watch('applyingThemeClasses', [ '?theme' ], function(opts) {
+			el.toggleClass('ui-widget', opts.theme);
+			el.toggleClass('fc-unthemed', !opts.theme);
 		});
 
 		// called immediately, and upon option change.
 		// HACK: locale often affects isRTL, so we explicitly listen to that too.
-		t.bindOptions([ 'isRTL', 'locale' ], function(isRTL) {
-			element.toggleClass('fc-ltr', !isRTL);
-			element.toggleClass('fc-rtl', isRTL);
+		this.optionsModel.watch('applyingDirClasses', [ '?isRTL', '?locale' ], function(opts) {
+			el.toggleClass('fc-ltr', !opts.isRTL);
+			el.toggleClass('fc-rtl', opts.isRTL);
 		});
 
-		content = $("<div class='fc-view-container'/>").prependTo(element);
+		this.contentEl = $("<div class='fc-view-container'/>").prependTo(el);
 
-		var toolbars = buildToolbars();
-		toolbarsManager = new Iterator(toolbars);
+		this.initToolbars();
+		this.renderHeader();
+		this.renderFooter();
+		this.renderView(this.opt('defaultView'));
 
-		header = t.header = toolbars[0];
-		footer = t.footer = toolbars[1];
-
-		renderHeader();
-		renderFooter();
-		renderView(t.options.defaultView);
-
-		if (t.options.handleWindowResize) {
-			windowResizeProxy = debounce(windowResize, t.options.windowResizeDelay); // prevents rapid calls
-			$(window).resize(windowResizeProxy);
+		if (this.opt('handleWindowResize')) {
+			$(window).resize(
+				this.windowResizeProxy = debounce( // prevents rapid calls
+					this.windowResize.bind(this),
+					this.opt('windowResizeDelay')
+				)
+			);
 		}
-	}
+	},
 
 
-	function destroy() {
+	destroy: function() {
 
-		if (currentView) {
-			currentView.removeElement();
+		if (this.view) {
+			this.view.removeElement();
 
-			// NOTE: don't null-out currentView/t.view in case API methods are called after destroy.
+			// NOTE: don't null-out this.view in case API methods are called after destroy.
 			// It is still the "current" view, just not rendered.
 		}
 
-		toolbarsManager.proxyCall('removeElement');
-		content.remove();
-		element.removeClass('fc fc-ltr fc-rtl fc-unthemed ui-widget');
+		this.toolbarsManager.proxyCall('removeElement');
+		this.contentEl.remove();
+		this.el.removeClass('fc fc-ltr fc-rtl fc-unthemed ui-widget');
 
-		element.off('.fc'); // unbind nav link handlers
+		this.el.off('.fc'); // unbind nav link handlers
 
-		if (windowResizeProxy) {
-			$(window).unbind('resize', windowResizeProxy);
+		if (this.windowResizeProxy) {
+			$(window).unbind('resize', this.windowResizeProxy);
+			this.windowResizeProxy = null;
 		}
 
 		GlobalEmitter.unneeded();
-	}
+	},
 
 
-	function elementVisible() {
-		return element.is(':visible');
-	}
+	elementVisible: function() {
+		return this.el.is(':visible');
+	},
 
 
 
@@ -11656,501 +12175,278 @@ function Calendar_constructor(element, overrides) {
 	// Renders a view because of a date change, view-type change, or for the first time.
 	// If not given a viewType, keep the current view but render different dates.
 	// Accepts an optional scroll state to restore to.
-	function renderView(viewType, forcedScroll) {
-		ignoreWindowResize++;
+	renderView: function(viewType, forcedScroll) {
+
+		this.ignoreWindowResize++;
 
-		var needsClearView = currentView && viewType && currentView.type !== viewType;
+		var needsClearView = this.view && viewType && this.view.type !== viewType;
 
 		// if viewType is changing, remove the old view's rendering
 		if (needsClearView) {
-			freezeContentHeight(); // prevent a scroll jump when view element is removed
-			clearView();
+			this.freezeContentHeight(); // prevent a scroll jump when view element is removed
+			this.clearView();
 		}
 
 		// if viewType changed, or the view was never created, create a fresh view
-		if (!currentView && viewType) {
-			currentView = t.view =
-				viewsByType[viewType] ||
-				(viewsByType[viewType] = t.instantiateView(viewType));
+		if (!this.view && viewType) {
+			this.view =
+				this.viewsByType[viewType] ||
+				(this.viewsByType[viewType] = this.instantiateView(viewType));
 
-			currentView.setElement(
-				$("<div class='fc-view fc-" + viewType + "-view' />").appendTo(content)
+			this.view.setElement(
+				$("<div class='fc-view fc-" + viewType + "-view' />").appendTo(this.contentEl)
 			);
-			toolbarsManager.proxyCall('activateButton', viewType);
+			this.toolbarsManager.proxyCall('activateButton', viewType);
 		}
 
-		if (currentView) {
-
-			if (elementVisible()) {
-
-				if (forcedScroll) {
-					currentView.captureInitialScroll(forcedScroll);
-				}
-
-				currentView.setDate(t.currentDate);
+		if (this.view) {
 
-				// TODO: make setDate return the revised date.
-				// Difficult because of the pseudo-async nature, promises.
-				t.currentDate = currentView.currentDate;
+			if (forcedScroll) {
+				this.view.addForcedScroll(forcedScroll);
+			}
 
-				if (forcedScroll) {
-					currentView.releaseScroll();
-				}
+			if (this.elementVisible()) {
+				this.currentDate = this.view.setDate(this.currentDate);
 			}
 		}
 
 		if (needsClearView) {
-			thawContentHeight();
+			this.thawContentHeight();
 		}
 
-		ignoreWindowResize--;
-	}
-	t.renderView = renderView;
+		this.ignoreWindowResize--;
+	},
 
 
 	// Unrenders the current view and reflects this change in the Header.
-	// Unregsiters the `currentView`, but does not remove from viewByType hash.
-	function clearView() {
-		toolbarsManager.proxyCall('deactivateButton', currentView.type);
-		currentView.removeElement();
-		currentView = t.view = null;
-	}
+	// Unregsiters the `view`, but does not remove from viewByType hash.
+	clearView: function() {
+		this.toolbarsManager.proxyCall('deactivateButton', this.view.type);
+		this.view.removeElement();
+		this.view = null;
+	},
 
 
 	// Destroys the view, including the view object. Then, re-instantiates it and renders it.
 	// Maintains the same scroll state.
 	// TODO: maintain any other user-manipulated state.
-	function reinitView() {
-		ignoreWindowResize++;
-		freezeContentHeight();
-
-		var viewType = currentView.type;
-		var scrollState = currentView.queryScroll();
-		clearView();
-		calcSize();
-		renderView(viewType, scrollState);
+	reinitView: function() {
+		this.ignoreWindowResize++;
+		this.freezeContentHeight();
 
-		thawContentHeight();
-		ignoreWindowResize--;
-	}
+		var viewType = this.view.type;
+		var scrollState = this.view.queryScroll();
+		this.clearView();
+		this.calcSize();
+		this.renderView(viewType, scrollState);
 
+		this.thawContentHeight();
+		this.ignoreWindowResize--;
+	},
 
 
 	// Resizing
 	// -----------------------------------------------------------------------------------
 
 
-	t.getSuggestedViewHeight = function() {
-		if (suggestedViewHeight === undefined) {
-			calcSize();
+	getSuggestedViewHeight: function() {
+		if (this.suggestedViewHeight === null) {
+			this.calcSize();
 		}
-		return suggestedViewHeight;
-	};
+		return this.suggestedViewHeight;
+	},
 
 
-	t.isHeightAuto = function() {
-		return t.options.contentHeight === 'auto' || t.options.height === 'auto';
-	};
+	isHeightAuto: function() {
+		return this.opt('contentHeight') === 'auto' || this.opt('height') === 'auto';
+	},
 
 
-	function updateSize(shouldRecalc) {
-		if (elementVisible()) {
+	updateSize: function(shouldRecalc) {
+		if (this.elementVisible()) {
 
 			if (shouldRecalc) {
-				_calcSize();
+				this._calcSize();
 			}
 
-			ignoreWindowResize++;
-			currentView.updateSize(true); // isResize=true. will poll getSuggestedViewHeight() and isHeightAuto()
-			ignoreWindowResize--;
+			this.ignoreWindowResize++;
+			this.view.updateSize(true); // isResize=true. will poll getSuggestedViewHeight() and isHeightAuto()
+			this.ignoreWindowResize--;
 
 			return true; // signal success
 		}
-	}
+	},
 
 
-	function calcSize() {
-		if (elementVisible()) {
-			_calcSize();
+	calcSize: function() {
+		if (this.elementVisible()) {
+			this._calcSize();
 		}
-	}
+	},
 
 
-	function _calcSize() { // assumes elementVisible
-		var contentHeightInput = t.options.contentHeight;
-		var heightInput = t.options.height;
+	_calcSize: function() { // assumes elementVisible
+		var contentHeightInput = this.opt('contentHeight');
+		var heightInput = this.opt('height');
 
 		if (typeof contentHeightInput === 'number') { // exists and not 'auto'
-			suggestedViewHeight = contentHeightInput;
+			this.suggestedViewHeight = contentHeightInput;
 		}
 		else if (typeof contentHeightInput === 'function') { // exists and is a function
-			suggestedViewHeight = contentHeightInput();
+			this.suggestedViewHeight = contentHeightInput();
 		}
 		else if (typeof heightInput === 'number') { // exists and not 'auto'
-			suggestedViewHeight = heightInput - queryToolbarsHeight();
+			this.suggestedViewHeight = heightInput - this.queryToolbarsHeight();
 		}
 		else if (typeof heightInput === 'function') { // exists and is a function
-			suggestedViewHeight = heightInput() - queryToolbarsHeight();
+			this.suggestedViewHeight = heightInput() - this.queryToolbarsHeight();
 		}
 		else if (heightInput === 'parent') { // set to height of parent element
-			suggestedViewHeight = element.parent().height() - queryToolbarsHeight();
+			this.suggestedViewHeight = this.el.parent().height() - this.queryToolbarsHeight();
 		}
 		else {
-			suggestedViewHeight = Math.round(content.width() / Math.max(t.options.aspectRatio, .5));
+			this.suggestedViewHeight = Math.round(
+				this.contentEl.width() /
+				Math.max(this.opt('aspectRatio'), .5)
+			);
 		}
-	}
-
-
-	function queryToolbarsHeight() {
-		return toolbarsManager.items.reduce(function(accumulator, toolbar) {
-			var toolbarHeight = toolbar.el ? toolbar.el.outerHeight(true) : 0; // includes margin
-			return accumulator + toolbarHeight;
-		}, 0);
-	}
+	},
 
 
-	function windowResize(ev) {
+	windowResize: function(ev) {
 		if (
-			!ignoreWindowResize &&
+			!this.ignoreWindowResize &&
 			ev.target === window && // so we don't process jqui "resize" events that have bubbled up
-			currentView.renderRange // view has already been rendered
+			this.view.renderRange // view has already been rendered
 		) {
-			if (updateSize(true)) {
-				currentView.publiclyTrigger('windowResize', _element);
+			if (this.updateSize(true)) {
+				this.view.publiclyTrigger('windowResize', this.el[0]);
 			}
 		}
-	}
-
+	},
 
 
-	/* Event Rendering
+	/* Height "Freezing"
 	-----------------------------------------------------------------------------*/
 
 
-	function rerenderEvents() { // API method. destroys old events if previously rendered.
-		if (elementVisible()) {
-			t.reportEventChange(); // will re-trasmit events to the view, causing a rerender
-		}
+	freezeContentHeight: function() {
+		this.contentEl.css({
+			width: '100%',
+			height: this.contentEl.height(),
+			overflow: 'hidden'
+		});
+	},
+
+
+	thawContentHeight: function() {
+		this.contentEl.css({
+			width: '',
+			height: '',
+			overflow: ''
+		});
 	}
 
+});
 
+;;
 
-	/* Toolbars
-	-----------------------------------------------------------------------------*/
+Calendar.mixin({
 
+	header: null,
+	footer: null,
+	toolbarsManager: null,
 
-	function buildToolbars() {
-		return [
-			new Toolbar(t, computeHeaderOptions()),
-			new Toolbar(t, computeFooterOptions())
-		];
-	}
+
+	initToolbars: function() {
+		this.header = new Toolbar(this, this.computeHeaderOptions());
+		this.footer = new Toolbar(this, this.computeFooterOptions());
+		this.toolbarsManager = new Iterator([ this.header, this.footer ]);
+	},
 
 
-	function computeHeaderOptions() {
+	computeHeaderOptions: function() {
 		return {
 			extraClasses: 'fc-header-toolbar',
-			layout: t.options.header
+			layout: this.opt('header')
 		};
-	}
+	},
 
 
-	function computeFooterOptions() {
+	computeFooterOptions: function() {
 		return {
 			extraClasses: 'fc-footer-toolbar',
-			layout: t.options.footer
+			layout: this.opt('footer')
 		};
-	}
+	},
 
 
 	// can be called repeatedly and Header will rerender
-	function renderHeader() {
-		header.setToolbarOptions(computeHeaderOptions());
+	renderHeader: function() {
+		var header = this.header;
+
+		header.setToolbarOptions(this.computeHeaderOptions());
 		header.render();
+
 		if (header.el) {
-			element.prepend(header.el);
+			this.el.prepend(header.el);
 		}
-	}
+	},
 
 
 	// can be called repeatedly and Footer will rerender
-	function renderFooter() {
-		footer.setToolbarOptions(computeFooterOptions());
+	renderFooter: function() {
+		var footer = this.footer;
+
+		footer.setToolbarOptions(this.computeFooterOptions());
 		footer.render();
+
 		if (footer.el) {
-			element.append(footer.el);
+			this.el.append(footer.el);
 		}
-	}
+	},
 
 
-	t.setToolbarsTitle = function(title) {
-		toolbarsManager.proxyCall('updateTitle', title);
-	};
+	setToolbarsTitle: function(title) {
+		this.toolbarsManager.proxyCall('updateTitle', title);
+	},
 
 
-	t.updateToolbarButtons = function() {
-		var now = t.getNow();
-		var todayInfo = currentView.buildDateProfile(now);
-		var prevInfo = currentView.buildPrevDateProfile(t.currentDate);
-		var nextInfo = currentView.buildNextDateProfile(t.currentDate);
+	updateToolbarButtons: function() {
+		var now = this.getNow();
+		var view = this.view;
+		var todayInfo = view.buildDateProfile(now);
+		var prevInfo = view.buildPrevDateProfile(this.currentDate);
+		var nextInfo = view.buildNextDateProfile(this.currentDate);
 
-		toolbarsManager.proxyCall(
-			(todayInfo.isValid && !isDateWithinRange(now, currentView.currentRange)) ?
+		this.toolbarsManager.proxyCall(
+			(todayInfo.isValid && !isDateWithinRange(now, view.currentRange)) ?
 				'enableButton' :
 				'disableButton',
 			'today'
 		);
 
-		toolbarsManager.proxyCall(
+		this.toolbarsManager.proxyCall(
 			prevInfo.isValid ?
 				'enableButton' :
 				'disableButton',
 			'prev'
 		);
 
-		toolbarsManager.proxyCall(
+		this.toolbarsManager.proxyCall(
 			nextInfo.isValid ?
 				'enableButton' :
 				'disableButton',
 			'next'
 		);
-	};
-
-
-
-	/* Selection
-	-----------------------------------------------------------------------------*/
-
-
-	// this public method receives start/end dates in any format, with any timezone
-	function select(zonedStartInput, zonedEndInput) {
-		currentView.select(
-			t.buildSelectSpan.apply(t, arguments)
-		);
-	}
-
-
-	function unselect() { // safe to be called before renderView
-		if (currentView) {
-			currentView.unselect();
-		}
-	}
-
-
-	// Forces navigation to a view for the given date.
-	// `viewType` can be a specific view name or a generic one like "week" or "day".
-	function zoomTo(newDate, viewType) {
-		var spec;
-
-		viewType = viewType || 'day'; // day is default zoom
-		spec = t.getViewSpec(viewType) || t.getUnitViewSpec(viewType);
-
-		t.currentDate = newDate.clone();
-		renderView(spec ? spec.type : null);
-	}
-
-
-
-	/* Height "Freezing"
-	-----------------------------------------------------------------------------*/
-
-
-	t.freezeContentHeight = freezeContentHeight;
-	t.thawContentHeight = thawContentHeight;
-
-	var freezeContentHeightDepth = 0;
-
-
-	function freezeContentHeight() {
-		if (!(freezeContentHeightDepth++)) {
-			content.css({
-				width: '100%',
-				height: content.height(),
-				overflow: 'hidden'
-			});
-		}
-	}
-
-
-	function thawContentHeight() {
-		if (!(--freezeContentHeightDepth)) {
-			content.css({
-				width: '',
-				height: '',
-				overflow: ''
-			});
-		}
-	}
-
-
-
-	/* Misc
-	-----------------------------------------------------------------------------*/
-
-
-	function getCalendar() {
-		return t;
-	}
-
-
-	function getView() {
-		return currentView;
-	}
-
-
-	function option(name, value) {
-		var newOptionHash;
-
-		if (typeof name === 'string') {
-			if (value === undefined) { // getter
-				return t.options[name];
-			}
-			else { // setter for individual option
-				newOptionHash = {};
-				newOptionHash[name] = value;
-				setOptions(newOptionHash);
-			}
-		}
-		else if (typeof name === 'object') { // compound setter with object input
-			setOptions(name);
-		}
-	}
-
-
-	function setOptions(newOptionHash) {
-		var optionCnt = 0;
-		var optionName;
-
-		recordOptionOverrides(newOptionHash);
-
-		for (optionName in newOptionHash) {
-			optionCnt++;
-		}
-
-		// special-case handling of single option change.
-		// if only one option change, `optionName` will be its name.
-		if (optionCnt === 1) {
-			if (optionName === 'height' || optionName === 'contentHeight' || optionName === 'aspectRatio') {
-				updateSize(true); // true = allow recalculation of height
-				return;
-			}
-			else if (optionName === 'defaultDate') {
-				return; // can't change date this way. use gotoDate instead
-			}
-			else if (optionName === 'businessHours') {
-				if (currentView) {
-					currentView.unrenderBusinessHours();
-					currentView.renderBusinessHours();
-				}
-				return;
-			}
-			else if (optionName === 'timezone') {
-				t.rezoneArrayEventSources();
-				t.refetchEvents();
-				return;
-			}
-		}
-
-		// catch-all. rerender the header and footer and rebuild/rerender the current view
-		renderHeader();
-		renderFooter();
-		viewsByType = {}; // even non-current views will be affected by this option change. do before rerender
-		reinitView();
-	}
-
-
-	// stores the new options internally, but does not rerender anything.
-	function recordOptionOverrides(newOptionHash) {
-		var optionName;
-
-		for (optionName in newOptionHash) {
-			t.dynamicOverrides[optionName] = newOptionHash[optionName];
-		}
-
-		t.viewSpecCache = {}; // the dynamic override invalidates the options in this cache, so just clear it
-		t.populateOptionsHash(); // this.options needs to be recomputed after the dynamic override
-
-		// trigger handlers after this.options has been updated
-		for (optionName in newOptionHash) {
-			t.triggerOptionHandlers(optionName); // recall bindOption/bindOptions
-		}
-	}
-
-
-	function publiclyTrigger(name, thisObj) {
-		var args = Array.prototype.slice.call(arguments, 2);
-
-		thisObj = thisObj || _element;
-		this.triggerWith(name, thisObj, args); // Emitter's method
-
-		if (t.options[name]) {
-			return t.options[name].apply(thisObj, args);
-		}
-	}
-
-	t.initialize();
-}
-
-;;
-/*
-Options binding/triggering system.
-*/
-Calendar.mixin({
-
-	// A map of option names to arrays of handler objects. Initialized to {} in Calendar.
-	// Format for a handler object:
-	// {
-	//   func // callback function to be called upon change
-	//   names // option names whose values should be given to func
-	// }
-	optionHandlers: null, 
-
-	// Calls handlerFunc immediately, and when the given option has changed.
-	// handlerFunc will be given the option value.
-	bindOption: function(optionName, handlerFunc) {
-		this.bindOptions([ optionName ], handlerFunc);
-	},
-
-	// Calls handlerFunc immediately, and when any of the given options change.
-	// handlerFunc will be given each option value as ordered function arguments.
-	bindOptions: function(optionNames, handlerFunc) {
-		var handlerObj = { func: handlerFunc, names: optionNames };
-		var i;
-
-		for (i = 0; i < optionNames.length; i++) {
-			this.registerOptionHandlerObj(optionNames[i], handlerObj);
-		}
-
-		this.triggerOptionHandlerObj(handlerObj);
-	},
-
-	// Puts the given handler object into the internal hash
-	registerOptionHandlerObj: function(optionName, handlerObj) {
-		(this.optionHandlers[optionName] || (this.optionHandlers[optionName] = []))
-			.push(handlerObj);
-	},
-
-	// Reports that the given option has changed, and calls all appropriate handlers.
-	triggerOptionHandlers: function(optionName) {
-		var handlerObjs = this.optionHandlers[optionName] || [];
-		var i;
-
-		for (i = 0; i < handlerObjs.length; i++) {
-			this.triggerOptionHandlerObj(handlerObjs[i]);
-		}
 	},
 
-	// Calls the callback for a specific handler object, passing in the appropriate arguments.
-	triggerOptionHandlerObj: function(handlerObj) {
-		var optionNames = handlerObj.names;
-		var optionValues = [];
-		var i;
-
-		for (i = 0; i < optionNames.length; i++) {
-			optionValues.push(this.options[optionNames[i]]);
-		}
 
-		handlerObj.func.apply(this, optionValues); // maintain the Calendar's `this` context
+	queryToolbarsHeight: function() {
+		return this.toolbarsManager.items.reduce(function(accumulator, toolbar) {
+			var toolbarHeight = toolbar.el ? toolbar.el.outerHeight(true) : 0; // includes margin
+			return accumulator + toolbarHeight;
+		}, 0);
 	}
 
 });
@@ -12463,6 +12759,7 @@ var instanceComputableOptions = {
 
 };
 
+// TODO: make these computable properties in optionsModel
 function populateInstanceComputableOptions(options) {
 	$.each(instanceComputableOptions, function(name, func) {
 		if (options[name] == null) {
@@ -12533,7 +12830,7 @@ function EventManager() { // assumed to be a calendar
 
 
 	$.each(
-		(t.options.events ? [ t.options.events ] : []).concat(t.options.eventSources || []),
+		(t.opt('events') ? [ t.opt('events') ] : []).concat(t.opt('eventSources') || []),
 		function(i, sourceInput) {
 			var source = buildEventSource(sourceInput);
 			if (source) {
@@ -12545,7 +12842,7 @@ function EventManager() { // assumed to be a calendar
 
 
 	function requestEvents(start, end) {
-		if (!t.options.lazyFetching || isFetchNeeded(start, end)) {
+		if (!t.opt('lazyFetching') || isFetchNeeded(start, end)) {
 			return fetchEvents(start, end);
 		}
 		else {
@@ -12584,11 +12881,6 @@ function EventManager() { // assumed to be a calendar
 	};
 
 
-	t.getPrunedEventCache = function() {
-		return prunedCache;
-	};
-
-
 
 	/* Fetching
 	-----------------------------------------------------------------------------*/
@@ -12650,7 +12942,7 @@ function EventManager() { // assumed to be a calendar
 		}
 
 		if (pendingSourceCnt) {
-			return new Promise(function(resolve) {
+			return Promise.construct(function(resolve) {
 				t.one('eventsReceived', resolve); // will send prunedCache
 			});
 		}
@@ -12734,7 +13026,7 @@ function EventManager() { // assumed to be a calendar
 				source,
 				rangeStart.clone(),
 				rangeEnd.clone(),
-				t.options.timezone,
+				t.opt('timezone'),
 				callback
 			);
 
@@ -12757,7 +13049,7 @@ function EventManager() { // assumed to be a calendar
 					t, // this, the Calendar object
 					rangeStart.clone(),
 					rangeEnd.clone(),
-					t.options.timezone,
+					t.opt('timezone'),
 					function(events) {
 						callback(events);
 						t.popLoading();
@@ -12792,9 +13084,9 @@ function EventManager() { // assumed to be a calendar
 				// and not affect the passed-in object.
 				var data = $.extend({}, customData || {});
 
-				var startParam = firstDefined(source.startParam, t.options.startParam);
-				var endParam = firstDefined(source.endParam, t.options.endParam);
-				var timezoneParam = firstDefined(source.timezoneParam, t.options.timezoneParam);
+				var startParam = firstDefined(source.startParam, t.opt('startParam'));
+				var endParam = firstDefined(source.endParam, t.opt('endParam'));
+				var timezoneParam = firstDefined(source.timezoneParam, t.opt('timezoneParam'));
 
 				if (startParam) {
 					data[startParam] = rangeStart.format();
@@ -12802,8 +13094,8 @@ function EventManager() { // assumed to be a calendar
 				if (endParam) {
 					data[endParam] = rangeEnd.format();
 				}
-				if (t.options.timezone && t.options.timezone != 'local') {
-					data[timezoneParam] = t.options.timezone;
+				if (t.opt('timezone') && t.opt('timezone') != 'local') {
+					data[timezoneParam] = t.opt('timezone');
 				}
 
 				t.pushLoading();
@@ -13212,12 +13504,13 @@ function EventManager() { // assumed to be a calendar
 	// Will return `false` when input is invalid.
 	// `source` is optional
 	function buildEventFromInput(input, source) {
+		var calendarEventDataTransform = t.opt('eventDataTransform');
 		var out = {};
 		var start, end;
 		var allDay;
 
-		if (t.options.eventDataTransform) {
-			input = t.options.eventDataTransform(input);
+		if (calendarEventDataTransform) {
+			input = calendarEventDataTransform(input);
 		}
 		if (source && source.eventDataTransform) {
 			input = source.eventDataTransform(input);
@@ -13283,7 +13576,7 @@ function EventManager() { // assumed to be a calendar
 			if (allDay === undefined) { // still undefined? fallback to default
 				allDay = firstDefined(
 					source ? source.allDayDefault : undefined,
-					t.options.allDayDefault
+					t.opt('allDayDefault')
 				);
 				// still undefined? normalizeEventDates will calculate it
 			}
@@ -13320,7 +13613,7 @@ function EventManager() { // assumed to be a calendar
 		}
 
 		if (!eventProps.end) {
-			if (t.options.forceEventDuration) {
+			if (t.opt('forceEventDuration')) {
 				eventProps.end = t.getDefaultEventEnd(eventProps.allDay, eventProps.start);
 			}
 			else {
@@ -13673,21 +13966,22 @@ function backupEventDates(event) {
 // Determines if the given event can be relocated to the given span (unzoned start/end with other misc data)
 Calendar.prototype.isEventSpanAllowed = function(span, event) {
 	var source = event.source || {};
+	var eventAllowFunc = this.opt('eventAllow');
 
 	var constraint = firstDefined(
 		event.constraint,
 		source.constraint,
-		this.options.eventConstraint
+		this.opt('eventConstraint')
 	);
 
 	var overlap = firstDefined(
 		event.overlap,
 		source.overlap,
-		this.options.eventOverlap
+		this.opt('eventOverlap')
 	);
 
 	return this.isSpanAllowed(span, constraint, overlap, event) &&
-		(!this.options.eventAllow || this.options.eventAllow(span, event) !== false);
+		(!eventAllowFunc || eventAllowFunc(span, event) !== false);
 };
 
 
@@ -13716,8 +14010,10 @@ Calendar.prototype.isExternalSpanAllowed = function(eventSpan, eventLocation, ev
 
 // Determines the given span (unzoned start/end with other misc data) can be selected.
 Calendar.prototype.isSelectionSpanAllowed = function(span) {
-	return this.isSpanAllowed(span, this.options.selectConstraint, this.options.selectOverlap) &&
-		(!this.options.selectAllow || this.options.selectAllow(span) !== false);
+	var selectAllowFunc = this.opt('selectAllow');
+
+	return this.isSpanAllowed(span, this.opt('selectConstraint'), this.opt('selectOverlap')) &&
+		(!selectAllowFunc || selectAllowFunc(span) !== false);
 };
 
 
@@ -13841,7 +14137,7 @@ var BUSINESS_HOUR_EVENT_DEFAULTS = {
 // Return events objects for business hours within the current view.
 // Abuse of our event system :(
 Calendar.prototype.getCurrentBusinessHourEvents = function(wholeDay) {
-	return this.computeBusinessHourEvents(wholeDay, this.options.businessHours);
+	return this.computeBusinessHourEvents(wholeDay, this.opt('businessHours'));
 };
 
 // Given a raw input value from options, return events objects for business hours within the current view.
@@ -14138,18 +14434,20 @@ var BasicView = FC.BasicView = View.extend({
 	------------------------------------------------------------------------------------------------------------------*/
 
 
-	computeInitialScroll: function() {
+	computeInitialDateScroll: function() {
 		return { top: 0 };
 	},
 
 
-	queryScroll: function() {
+	queryDateScroll: function() {
 		return { top: this.scroller.getScrollTop() };
 	},
 
 
-	setScroll: function(scroll) {
-		this.scroller.setScrollTop(scroll.top);
+	applyDateScroll: function(scroll) {
+		if (scroll.top !== undefined) {
+			this.scroller.setScrollTop(scroll.top);
+		}
 	},
 
 
@@ -14666,7 +14964,7 @@ var AgendaView = FC.AgendaView = View.extend({
 
 
 	// Computes the initial pre-configured scroll state prior to allowing the user to change it
-	computeInitialScroll: function() {
+	computeInitialDateScroll: function() {
 		var scrollTime = moment.duration(this.opt('scrollTime'));
 		var top = this.timeGrid.computeTimeTop(scrollTime);
 
@@ -14681,13 +14979,15 @@ var AgendaView = FC.AgendaView = View.extend({
 	},
 
 
-	queryScroll: function() {
+	queryDateScroll: function() {
 		return { top: this.scroller.getScrollTop() };
 	},
 
 
-	setScroll: function(scroll) {
-		this.scroller.setScrollTop(scroll.top);
+	applyDateScroll: function(scroll) {
+		if (scroll.top !== undefined) {
+			this.scroller.setScrollTop(scroll.top);
+		}
 	},