diff --git a/src/agenda/AgendaDayView.js b/src/agenda/AgendaDayView.js
index 12b6b56..a6526b5 100644
--- a/src/agenda/AgendaDayView.js
+++ b/src/agenda/AgendaDayView.js
@@ -1,6 +1,7 @@
 
 fcViews.agendaDay = AgendaDayView;
 
+
 function AgendaDayView(element, calendar) {
 	var t = this;
 	
@@ -13,22 +14,25 @@ function AgendaDayView(element, calendar) {
 	AgendaView.call(t, element, calendar, 'agendaDay');
 	var opt = t.opt;
 	var renderAgenda = t.renderAgenda;
+	var skipHiddenDays = t.skipHiddenDays;
 	var formatDate = calendar.formatDate;
 	
 	
-	
 	function render(date, delta) {
+
 		if (delta) {
 			addDays(date, delta);
-			if (!opt('weekends')) {
-				skipWeekend(date, delta < 0 ? -1 : 1);
-			}
 		}
+		skipHiddenDays(date, delta < 0 ? -1 : 1);
+
 		var start = cloneDate(date, true);
 		var end = addDays(cloneDate(start), 1);
+
 		t.title = formatDate(date, opt('titleFormat'));
+
 		t.start = t.visStart = start;
 		t.end = t.visEnd = end;
+
 		renderAgenda(1);
 	}
 	
diff --git a/src/agenda/AgendaEventRenderer.js b/src/agenda/AgendaEventRenderer.js
index 98cb861..6f5d516 100644
--- a/src/agenda/AgendaEventRenderer.js
+++ b/src/agenda/AgendaEventRenderer.js
@@ -5,17 +5,14 @@ function AgendaEventRenderer() {
 	
 	// exports
 	t.renderEvents = renderEvents;
-	t.compileDaySegs = compileDaySegs; // for DayEventRenderer
 	t.clearEvents = clearEvents;
 	t.slotSegHtml = slotSegHtml;
-	t.bindDaySeg = bindDaySeg;
 	
 	
 	// imports
 	DayEventRenderer.call(t);
 	var opt = t.opt;
 	var trigger = t.trigger;
-	//var setOverflowHidden = t.setOverflowHidden;
 	var isEventDraggable = t.isEventDraggable;
 	var isEventResizable = t.isEventResizable;
 	var eventEnd = t.eventEnd;
@@ -31,13 +28,13 @@ function AgendaEventRenderer() {
 	var timePosition = t.timePosition;
 	var colContentLeft = t.colContentLeft;
 	var colContentRight = t.colContentRight;
-	var renderDaySegs = t.renderDaySegs;
-	var resizableDayEvent = t.resizableDayEvent; // TODO: streamline binding architecture
+	var cellToDate = t.cellToDate;
+	var segmentCompare = t.segmentCompare;
 	var getColCnt = t.getColCnt;
 	var getColWidth = t.getColWidth;
 	var getSnapHeight = t.getSnapHeight;
 	var getSnapMinutes = t.getSnapMinutes;
-	var getBodyContent = t.getBodyContent;
+	var getSlotContainer = t.getSlotContainer;
 	var reportEventElement = t.reportEventElement;
 	var showEvents = t.showEvents;
 	var hideEvents = t.hideEvents;
@@ -45,10 +42,15 @@ function AgendaEventRenderer() {
 	var eventResize = t.eventResize;
 	var renderDayOverlay = t.renderDayOverlay;
 	var clearOverlays = t.clearOverlays;
+	var renderDayEvents = t.renderDayEvents;
 	var calendar = t.calendar;
 	var formatDate = calendar.formatDate;
 	var formatDates = calendar.formatDates;
-	
+
+
+	// overrides
+	t.draggableDayEvent = draggableDayEvent;
+
 	
 	
 	/* Rendering
@@ -67,11 +69,14 @@ function AgendaEventRenderer() {
 				slotEvents.push(events[i]);
 			}
 		}
+
 		if (opt('allDaySlot')) {
-			renderDaySegs(compileDaySegs(dayEvents), modifiedEventId);
+			renderDayEvents(dayEvents, modifiedEventId);
 			setHeight(); // no params means set to viewHeight
 		}
+
 		renderSlotSegs(compileSlotSegs(slotEvents), modifiedEventId);
+
 		trigger('eventAfterAllRender');
 	}
 	
@@ -81,39 +86,33 @@ function AgendaEventRenderer() {
 		getDaySegmentContainer().empty();
 		getSlotSegmentContainer().empty();
 	}
-	
-	
-	function compileDaySegs(events) {
-		var levels = stackSegs(sliceSegs(events, $.map(events, exclEndDay), t.visStart, t.visEnd)),
-			i, levelCnt=levels.length, level,
-			j, seg,
-			segs=[];
-		for (i=0; i<levelCnt; i++) {
-			level = levels[i];
-			for (j=0; j<level.length; j++) {
-				seg = level[j];
-				seg.row = 0;
-				seg.level = i; // not needed anymore
-				segs.push(seg);
-			}
-		}
-		return segs;
-	}
-	
+
 	
 	function compileSlotSegs(events) {
 		var colCnt = getColCnt(),
 			minMinute = getMinMinute(),
 			maxMinute = getMaxMinute(),
-			d = addMinutes(cloneDate(t.visStart), minMinute),
+			d,
 			visEventEnds = $.map(events, slotEventEnd),
 			i, col,
 			j, level,
 			k, seg,
-			segs=[];
+			segs = [];
 		for (i=0; i<colCnt; i++) {
-			col = stackSegs(sliceSegs(events, visEventEnds, d, addMinutes(cloneDate(d), maxMinute-minMinute)));
+
+			d = cellToDate(0, i);
+			addMinutes(d, minMinute);
+
+			col = stackAgendaSegs(
+				sliceSegs(
+					events,
+					visEventEnds,
+					d,
+					addMinutes(cloneDate(d), maxMinute-minMinute)
+				)
+			);
 			countForwardSegs(col);
+
 			for (j=0; j<col.length; j++) {
 				level = col[j];
 				for (k=0; k<level.length; k++) {
@@ -123,12 +122,50 @@ function AgendaEventRenderer() {
 					segs.push(seg);
 				}
 			}
-			addDays(d, 1, true);
 		}
 		return segs;
 	}
-	
-	
+
+
+	function sliceSegs(events, visEventEnds, start, end) {
+		var segs = [],
+			i, len=events.length, event,
+			eventStart, eventEnd,
+			segStart, segEnd,
+			isStart, isEnd;
+		for (i=0; i<len; i++) {
+			event = events[i];
+			eventStart = event.start;
+			eventEnd = visEventEnds[i];
+			if (eventEnd > start && eventStart < end) {
+				if (eventStart < start) {
+					segStart = cloneDate(start);
+					isStart = false;
+				}else{
+					segStart = eventStart;
+					isStart = true;
+				}
+				if (eventEnd > end) {
+					segEnd = cloneDate(end);
+					isEnd = false;
+				}else{
+					segEnd = eventEnd;
+					isEnd = true;
+				}
+				segs.push({
+					event: event,
+					start: segStart,
+					end: segEnd,
+					isStart: isStart,
+					isEnd: isEnd,
+					msLength: segEnd - segStart
+				});
+			}
+		}
+		return segs.sort(segmentCompare);
+	}
+
+
 	function slotEventEnd(event) {
 		if (event.end) {
 			return cloneDate(event.end);
@@ -139,6 +176,8 @@ function AgendaEventRenderer() {
 	
 	
 	// renders events in the 'time slots' at the bottom
+	// TODO: when we refactor this, when user returns `false` eventRender, don't have empty space
+	// TODO: refactor will include using pixels to detect collisions instead of dates (handy for seg cmp)
 	
 	function renderSlotSegs(segs, modifiedEventId) {
 	
@@ -155,21 +194,15 @@ function AgendaEventRenderer() {
 			eventElements,
 			eventElement,
 			triggerRes,
-			vsideCache={},
-			hsideCache={},
-			key, val,
 			titleElement,
 			height,
 			slotSegmentContainer = getSlotSegmentContainer(),
-			rtl, dis, dit,
-			colCnt = getColCnt();
+			rtl, dis;
 			
 		if (rtl = opt('isRTL')) {
 			dis = -1;
-			dit = colCnt - 1;
 		}else{
 			dis = 1;
-			dit = 0;
 		}
 			
 		// calculate position/dimensions, create html
@@ -181,8 +214,8 @@ function AgendaEventRenderer() {
 			colI = seg.col;
 			levelI = seg.level;
 			forward = seg.forward || 0;
-			leftmost = colContentLeft(colI*dis + dit);
-			availWidth = colContentRight(colI*dis + dit) - leftmost;
+			leftmost = colContentLeft(colI);
+			availWidth = colContentRight(colI) - leftmost;
 			availWidth = Math.min(availWidth-6, availWidth*.95); // TODO: move this to CSS
 			if (levelI) {
 				// indented and thin
@@ -243,10 +276,8 @@ function AgendaEventRenderer() {
 		for (i=0; i<segCnt; i++) {
 			seg = segs[i];
 			if (eventElement = seg.element) {
-				val = vsideCache[key = seg.key = cssKey(eventElement[0])];
-				seg.vsides = val === undefined ? (vsideCache[key] = vsides(eventElement, true)) : val;
-				val = hsideCache[key];
-				seg.hsides = val === undefined ? (hsideCache[key] = hsides(eventElement, true)) : val;
+				seg.vsides = vsides(eventElement, true);
+				seg.hsides = hsides(eventElement, true);
 				titleElement = eventElement.find('.fc-event-title');
 				if (titleElement.length) {
 					seg.contentTop = titleElement[0].offsetTop;
@@ -322,18 +353,6 @@ function AgendaEventRenderer() {
 	}
 	
 	
-	function bindDaySeg(event, eventElement, seg) {
-		if (isEventDraggable(event)) {
-			draggableDayEvent(event, eventElement, seg.isStart);
-		}
-		if (seg.isEnd && isEventResizable(event)) {
-			resizableDayEvent(event, eventElement, seg);
-		}
-		eventElementHandlers(event, eventElement);
-			// needs to be after, because resizableDayEvent might stopImmediatePropagation on click
-	}
-	
-	
 	function bindSlotSeg(event, eventElement, seg) {
 		var timeElement = eventElement.find('div.fc-event-time');
 		if (isEventDraggable(event)) {
@@ -352,13 +371,15 @@ function AgendaEventRenderer() {
 	
 	
 	// when event starts out FULL-DAY
+	// overrides DayEventRenderer's version because it needs to account for dragging elements
+	// to and from the slot area.
 	
-	function draggableDayEvent(event, eventElement, isStart) {
+	function draggableDayEvent(event, eventElement, seg) {
+		var isStart = seg.isStart;
 		var origWidth;
 		var revert;
-		var allDay=true;
+		var allDay = true;
 		var dayDelta;
-		var dis = opt('isRTL') ? -1 : 1;
 		var hoverListener = getHoverListener();
 		var colWidth = getColWidth();
 		var snapHeight = getSnapHeight();
@@ -372,12 +393,13 @@ function AgendaEventRenderer() {
 				trigger('eventDragStart', eventElement, event, ev, ui);
 				hideEvents(event, eventElement);
 				origWidth = eventElement.width();
-				hoverListener.start(function(cell, origCell, rowDelta, colDelta) {
+				hoverListener.start(function(cell, origCell) {
 					clearOverlays();
 					if (cell) {
-						//setOverflowHidden(true);
 						revert = false;
-						dayDelta = colDelta * dis;
+						var origDate = cellToDate(0, origCell.col);
+						var date = cellToDate(0, cell.col);
+						dayDelta = dayDiff(date, origDate);
 						if (!cell.row) {
 							// on full-days
 							renderDayOverlay(
@@ -408,7 +430,6 @@ function AgendaEventRenderer() {
 						revert = revert || (allDay && !dayDelta);
 					}else{
 						resetElement();
-						//setOverflowHidden(false);
 						revert = true;
 					}
 					eventElement.draggable('option', 'revert', revert);
@@ -427,14 +448,13 @@ function AgendaEventRenderer() {
 					// changed!
 					var minuteDelta = 0;
 					if (!allDay) {
-						minuteDelta = Math.round((eventElement.offset().top - getBodyContent().offset().top) / snapHeight)
+						minuteDelta = Math.round((eventElement.offset().top - getSlotContainer().offset().top) / snapHeight)
 							* snapMinutes
 							+ minMinute
 							- (event.start.getHours() * 60 + event.start.getMinutes());
 					}
 					eventDrop(this, event, dayDelta, minuteDelta, allDay, ev, ui);
 				}
-				//setOverflowHidden(false);
 			}
 		});
 		function resetElement() {
@@ -453,11 +473,10 @@ function AgendaEventRenderer() {
 	
 	function draggableSlotEvent(event, eventElement, timeElement) {
 		var origPosition;
-		var allDay=false;
+		var allDay = false;
 		var dayDelta;
 		var minuteDelta;
 		var prevMinuteDelta;
-		var dis = opt('isRTL') ? -1 : 1;
 		var hoverListener = getHoverListener();
 		var colCnt = getColCnt();
 		var colWidth = getColWidth();
@@ -475,11 +494,13 @@ function AgendaEventRenderer() {
 				hideEvents(event, eventElement);
 				origPosition = eventElement.position();
 				minuteDelta = prevMinuteDelta = 0;
-				hoverListener.start(function(cell, origCell, rowDelta, colDelta) {
+				hoverListener.start(function(cell, origCell) {
 					eventElement.draggable('option', 'revert', !cell);
 					clearOverlays();
 					if (cell) {
-						dayDelta = colDelta * dis;
+						var origDate = cellToDate(0, origCell.col);
+						var date = cellToDate(0, cell.col);
+						dayDelta = dayDiff(date, origDate);
 						if (opt('allDaySlot') && !cell.row) {
 							// over full days
 							if (!allDay) {
@@ -596,6 +617,45 @@ function AgendaEventRenderer() {
 }
 
 
+
+/* Agenda Event Segment Utilities
+-----------------------------------------------------------------------------*/
+// TODO: maybe somehow consolidate this with DayEventRenderer's segment system
+
+
+function stackAgendaSegs(segs) {
+	var levels = [],
+		i, len = segs.length, seg,
+		j, collide, k;
+	for (i=0; i<len; i++) {
+		seg = segs[i];
+		j = 0; // the level index where seg should belong
+		while (true) {
+			collide = false;
+			if (levels[j]) {
+				for (k=0; k<levels[j].length; k++) {
+					if (agendaSegsCollide(levels[j][k], seg)) {
+						collide = true;
+						break;
+					}
+				}
+			}
+			if (collide) {
+				j++;
+			}else{
+				break;
+			}
+		}
+		if (levels[j]) {
+			levels[j].push(seg);
+		}else{
+			levels[j] = [seg];
+		}
+	}
+	return levels;
+}
+
+
 function countForwardSegs(levels) {
 	var i, j, k, level, segForward, segBack;
 	for (i=levels.length-1; i>0; i--) {
@@ -604,7 +664,7 @@ function countForwardSegs(levels) {
 			segForward = level[j];
 			for (k=0; k<levels[i-1].length; k++) {
 				segBack = levels[i-1][k];
-				if (segsCollide(segForward, segBack)) {
+				if (agendaSegsCollide(segForward, segBack)) {
 					segBack.forward = Math.max(segBack.forward||0, (segForward.forward||0)+1);
 				}
 			}
@@ -613,3 +673,7 @@ function countForwardSegs(levels) {
 }
 
 
+function agendaSegsCollide(seg1, seg2) {
+	return seg1.end > seg2.start && seg1.start < seg2.end;
+}
+
diff --git a/src/agenda/AgendaView.js b/src/agenda/AgendaView.js
index b53d86d..6e5d88a 100644
--- a/src/agenda/AgendaView.js
+++ b/src/agenda/AgendaView.js
@@ -33,20 +33,18 @@ function AgendaView(element, calendar, viewName) {
 	t.afterShow = afterShow;
 	t.defaultEventEnd = defaultEventEnd;
 	t.timePosition = timePosition;
-	t.dayOfWeekCol = dayOfWeekCol;
-	t.dateCell = dateCell;
-	t.cellDate = cellDate;
-	t.cellIsAllDay = cellIsAllDay;
+	t.getIsCellAllDay = getIsCellAllDay;
 	t.allDayRow = getAllDayRow;
-	t.allDayBounds = allDayBounds;
 	t.getHoverListener = function() { return hoverListener };
+	t.colLeft = colLeft;
+	t.colRight = colRight;
 	t.colContentLeft = colContentLeft;
 	t.colContentRight = colContentRight;
 	t.getDaySegmentContainer = function() { return daySegmentContainer };
 	t.getSlotSegmentContainer = function() { return slotSegmentContainer };
 	t.getMinMinute = function() { return minMinute };
 	t.getMaxMinute = function() { return maxMinute };
-	t.getBodyContent = function() { return slotContent }; // !!??
+	t.getSlotContainer = function() { return slotContainer };
 	t.getRowCnt = function() { return 1 };
 	t.getColCnt = function() { return colCnt };
 	t.getColWidth = function() { return colWidth };
@@ -75,6 +73,9 @@ function AgendaView(element, calendar, viewName) {
 	var unselect = t.unselect;
 	var daySelectionMousedown = t.daySelectionMousedown;
 	var slotSegHtml = t.slotSegHtml;
+	var cellToDate = t.cellToDate;
+	var dateToCell = t.dateToCell;
+	var rangeToSegments = t.rangeToSegments;
 	var formatDate = calendar.formatDate;
 	
 	
@@ -86,6 +87,7 @@ function AgendaView(element, calendar, viewName) {
 	var dayBody;
 	var dayBodyCells;
 	var dayBodyCellInners;
+	var dayBodyCellContentInners;
 	var dayBodyFirstCell;
 	var dayBodyFirstCellStretcher;
 	var slotLayer;
@@ -93,12 +95,10 @@ function AgendaView(element, calendar, viewName) {
 	var allDayTable;
 	var allDayRow;
 	var slotScroller;
-	var slotContent;
+	var slotContainer;
 	var slotSegmentContainer;
 	var slotTable;
 	var slotTableFirstInner;
-	var axisFirstCells;
-	var gutterCells;
 	var selectionHelper;
 	
 	var viewWidth;
@@ -116,14 +116,13 @@ function AgendaView(element, calendar, viewName) {
 	var slotCnt;
 	var coordinateGrid;
 	var hoverListener;
+	var colPositions;
 	var colContentPositions;
 	var slotTopCache = {};
 	var savedScrollTop;
 	
 	var tm;
-	var firstDay;
-	var nwe;            // no weekends (int)
-	var rtl, dis, dit;  // day index sign / translate
+	var rtl;
 	var minMinute, maxMinute;
 	var colFormat;
 	var showWeekNumbers;
@@ -143,26 +142,18 @@ function AgendaView(element, calendar, viewName) {
 		colCnt = c;
 		updateOptions();
 		if (!dayTable) {
-			buildSkeleton();
+			buildSkeleton(); // builds day table, slot area, events containers
 		}else{
+			buildDayTable(); // rebuilds day table
 			clearEvents();
 		}
-		updateCells();
 	}
 	
 	
-	
 	function updateOptions() {
+
 		tm = opt('theme') ? 'ui' : 'fc';
-		nwe = opt('weekends') ? 0 : 1;
-		firstDay = opt('firstDay');
-		if (rtl = opt('isRTL')) {
-			dis = -1;
-			dit = colCnt - 1;
-		}else{
-			dis = 1;
-			dit = 0;
-		}
+		rtl = opt('isRTL')
 		minMinute = parseTime(opt('minTime'));
 		maxMinute = parseTime(opt('maxTime'));
 		colFormat = opt('columnFormat');
@@ -179,71 +170,24 @@ function AgendaView(element, calendar, viewName) {
 
 		snapMinutes = opt('snapMinutes') || opt('slotMinutes');
 	}
-	
-	
-	
+
+
+
+	/* Build DOM
+	-----------------------------------------------------------------------*/
+
+
 	function buildSkeleton() {
 		var headerClass = tm + "-widget-header";
 		var contentClass = tm + "-widget-content";
 		var s;
-		var i;
 		var d;
+		var i;
 		var maxd;
 		var minutes;
 		var slotNormal = opt('slotMinutes') % 15 == 0;
 		
-		s =
-			"<table style='width:100%' class='fc-agenda-days fc-border-separate' cellspacing='0'>" +
-			"<thead>" +
-			"<tr>";
-
-		if (showWeekNumbers) {
-			s += "<th class='fc-agenda-axis fc-week-number " + headerClass + "'/>";
-		}
-		else {
-			s += "<th class='fc-agenda-axis " + headerClass + "'>&nbsp;</th>";
-		}
-
-		for (i=0; i<colCnt; i++) {
-			s +=
-				"<th class='fc- fc-col" + i + ' ' + headerClass + "'/>"; // fc- needed for setDayID
-		}
-		s +=
-			"<th class='fc-agenda-gutter " + headerClass + "'>&nbsp;</th>" +
-			"</tr>" +
-			"</thead>" +
-			"<tbody>" +
-			"<tr>" +
-			"<th class='fc-agenda-axis " + headerClass + "'>&nbsp;</th>";
-		for (i=0; i<colCnt; i++) {
-			s +=
-				"<td class='fc- fc-col" + i + ' ' + contentClass + "'>" + // fc- needed for setDayID
-				"<div>" +
-				"<div class='fc-day-content'>" +
-				"<div style='position:relative'>&nbsp;</div>" +
-				"</div>" +
-				"</div>" +
-				"</td>";
-		}
-		s +=
-			"<td class='fc-agenda-gutter " + contentClass + "'>&nbsp;</td>" +
-			"</tr>" +
-			"</tbody>" +
-			"</table>";
-		dayTable = $(s).appendTo(element);
-		dayHead = dayTable.find('thead');
-		dayHeadCells = dayHead.find('th').slice(1, -1);
-		dayBody = dayTable.find('tbody');
-		dayBodyCells = dayBody.find('td').slice(0, -1);
-		dayBodyCellInners = dayBodyCells.find('div.fc-day-content div');
-		dayBodyFirstCell = dayBodyCells.eq(0);
-		dayBodyFirstCellStretcher = dayBodyFirstCell.find('> div');
-		
-		markFirstLast(dayHead.add(dayHead.find('tr')));
-		markFirstLast(dayBody.add(dayBody.find('tr')));
-		
-		axisFirstCells = dayHead.find('th:first');
-		gutterCells = dayTable.find('.fc-agenda-gutter');
+		buildDayTable();
 		
 		slotLayer =
 			$("<div style='position:absolute;z-index:2;left:0;width:100%'/>")
@@ -270,9 +214,6 @@ function AgendaView(element, calendar, viewName) {
 			
 			dayBind(allDayRow.find('td'));
 			
-			axisFirstCells = axisFirstCells.add(allDayTable.find('th:first'));
-			gutterCells = gutterCells.add(allDayTable.find('th.fc-agenda-gutter'));
-			
 			slotLayer.append(
 				"<div class='fc-agenda-divider " + headerClass + "'>" +
 				"<div class='fc-agenda-divider-inner'/>" +
@@ -289,13 +230,13 @@ function AgendaView(element, calendar, viewName) {
 			$("<div style='position:absolute;width:100%;overflow-x:hidden;overflow-y:auto'/>")
 				.appendTo(slotLayer);
 				
-		slotContent =
+		slotContainer =
 			$("<div style='position:relative;width:100%;overflow:hidden'/>")
 				.appendTo(slotScroller);
 				
 		slotSegmentContainer =
 			$("<div style='position:absolute;z-index:8;top:0;left:0'/>")
-				.appendTo(slotContent);
+				.appendTo(slotContainer);
 		
 		s =
 			"<table class='fc-agenda-slots' style='width:100%' cellspacing='0'>" +
@@ -321,49 +262,162 @@ function AgendaView(element, calendar, viewName) {
 		s +=
 			"</tbody>" +
 			"</table>";
-		slotTable = $(s).appendTo(slotContent);
+		slotTable = $(s).appendTo(slotContainer);
 		slotTableFirstInner = slotTable.find('div:first');
 		
 		slotBind(slotTable.find('td'));
-		
-		axisFirstCells = axisFirstCells.add(slotTable.find('th:first'));
 	}
-	
-	
-	
-	function updateCells() {
-		var i;
-		var headCell;
-		var bodyCell;
+
+
+
+	/* Build Day Table
+	-----------------------------------------------------------------------*/
+
+
+	function buildDayTable() {
+		var html = buildDayTableHTML();
+
+		if (dayTable) {
+			dayTable.remove();
+		}
+		dayTable = $(html).appendTo(element);
+
+		dayHead = dayTable.find('thead');
+		dayHeadCells = dayHead.find('th').slice(1, -1); // exclude gutter
+		dayBody = dayTable.find('tbody');
+		dayBodyCells = dayBody.find('td').slice(0, -1); // exclude gutter
+		dayBodyCellInners = dayBodyCells.find('> div');
+		dayBodyCellContentInners = dayBodyCells.find('.fc-day-content > div');
+
+		dayBodyFirstCell = dayBodyCells.eq(0);
+		dayBodyFirstCellStretcher = dayBodyCellInners.eq(0);
+		
+		markFirstLast(dayHead.add(dayHead.find('tr')));
+		markFirstLast(dayBody.add(dayBody.find('tr')));
+
+		// TODO: now that we rebuild the cells every time, we should call dayRender
+	}
+
+
+	function buildDayTableHTML() {
+		var html =
+			"<table style='width:100%' class='fc-agenda-days fc-border-separate' cellspacing='0'>" +
+			buildDayTableHeadHTML() +
+			buildDayTableBodyHTML() +
+			"</table>";
+
+		return html;
+	}
+
+
+	function buildDayTableHeadHTML() {
+		var headerClass = tm + "-widget-header";
 		var date;
-		var today = clearTime(new Date());
+		var html = '';
+		var weekText;
+		var col;
+
+		html +=
+			"<thead>" +
+			"<tr>";
 
 		if (showWeekNumbers) {
-			var weekText = formatDate(colDate(0), weekNumberFormat);
+			weekText = formatDate(date, weekNumberFormat);
 			if (rtl) {
-				weekText = weekText + weekNumberTitle;
+				weekText += weekNumberTitle;
 			}
 			else {
 				weekText = weekNumberTitle + weekText;
 			}
-			dayHead.find('.fc-week-number').text(weekText);
+			html +=
+				"<th class='fc-agenda-axis fc-week-number " + headerClass + "'>" +
+				htmlEscape(weekText) +
+				"</th>";
+		}
+		else {
+			html += "<th class='fc-agenda-axis " + headerClass + "'>&nbsp;</th>";
 		}
 
-		for (i=0; i<colCnt; i++) {
-			date = colDate(i);
-			headCell = dayHeadCells.eq(i);
-			headCell.html(formatDate(date, colFormat));
-			bodyCell = dayBodyCells.eq(i);
-			if (+date == +today) {
-				bodyCell.addClass(tm + '-state-highlight fc-today');
-			}else{
-				bodyCell.removeClass(tm + '-state-highlight fc-today');
-			}
-			setDayID(headCell.add(bodyCell), date);
+		for (col=0; col<colCnt; col++) {
+			date = cellToDate(0, col);
+			html +=
+				"<th class='fc-" + dayIDs[date.getDay()] + " fc-col" + col + ' ' + headerClass + "'>" +
+				htmlEscape(formatDate(date, colFormat)) +
+				"</th>";
 		}
+
+		html +=
+			"<th class='fc-agenda-gutter " + headerClass + "'>&nbsp;</th>" +
+			"</tr>" +
+			"</thead>";
+
+		return html;
 	}
+
+
+	function buildDayTableBodyHTML() {
+		var headerClass = tm + "-widget-header"; // TODO: make these when updateOptions() called
+		var contentClass = tm + "-widget-content";
+		var date;
+		var today = clearTime(new Date());
+		var col;
+		var cellsHTML;
+		var cellHTML;
+		var classNames;
+		var html = '';
+
+		html +=
+			"<tbody>" +
+			"<tr>" +
+			"<th class='fc-agenda-axis " + headerClass + "'>&nbsp;</th>";
+
+		cellsHTML = '';
+
+		for (col=0; col<colCnt; col++) {
+
+			date = cellToDate(0, col);
+
+			classNames = [
+				'fc-col' + col,
+				'fc-' + dayIDs[date.getDay()],
+				contentClass
+			];
+			if (+date == +today) {
+				classNames.push(
+					tm + '-state-highlight',
+					'fc-today'
+				);
+			}
+
+			cellHTML =
+				"<td class='" + classNames.join(' ') + "'>" +
+				"<div>" +
+				"<div class='fc-day-content'>" +
+				"<div style='position:relative'>&nbsp;</div>" +
+				"</div>" +
+				"</div>" +
+				"</td>";
+
+			cellsHTML += cellHTML;
+		}
+
+		html += cellsHTML;
+		html +=
+			"<td class='fc-agenda-gutter " + contentClass + "'>&nbsp;</td>" +
+			"</tr>" +
+			"</tbody>";
+
+		return html;
+	}
+
+
+	// TODO: data-date on the cells
+
 	
 	
+	/* Dimensions
+	-----------------------------------------------------------------------*/
+
 	
 	function setHeight(height, dateChanged) {
 		if (height === undefined) {
@@ -378,7 +432,7 @@ function AgendaView(element, calendar, viewName) {
 			height - headHeight,   // when scrollbars
 			slotTable.height() + allDayHeight + 1 // when no scrollbars. +1 for bottom border
 		);
-		
+
 		dayBodyFirstCellStretcher
 			.height(bodyHeight - vsides(dayBodyFirstCell));
 		
@@ -397,10 +451,16 @@ function AgendaView(element, calendar, viewName) {
 	}
 	
 	
-	
 	function setWidth(width) {
 		viewWidth = width;
+		colPositions.clear();
 		colContentPositions.clear();
+
+		var axisFirstCells = dayHead.find('th:first');
+		if (allDayTable) {
+			axisFirstCells = axisFirstCells.add(allDayTable.find('th:first'));
+		}
+		axisFirstCells = axisFirstCells.add(slotTable.find('th:first'));
 		
 		axisWidth = 0;
 		setOuterWidth(
@@ -412,8 +472,12 @@ function AgendaView(element, calendar, viewName) {
 			axisWidth
 		);
 		
+		var gutterCells = dayTable.find('.fc-agenda-gutter');
+		if (allDayTable) {
+			gutterCells = gutterCells.add(allDayTable.find('th.fc-agenda-gutter'));
+		}
+
 		var slotTableWidth = slotScroller[0].clientWidth; // needs to be done after axisWidth (for IE7)
-		//slotTable.width(slotTableWidth);
 		
 		gutterWidth = slotScroller.width() - slotTableWidth;
 		if (gutterWidth) {
@@ -435,6 +499,10 @@ function AgendaView(element, calendar, viewName) {
 	
 
 
+	/* Scrolling
+	-----------------------------------------------------------------------*/
+
+
 	function resetScroll() {
 		var d0 = zeroDate();
 		var scrollDate = cloneDate(d0);
@@ -478,7 +546,7 @@ function AgendaView(element, calendar, viewName) {
 	function slotClick(ev) {
 		if (!opt('selectable')) { // if selectable, SelectionManager will worry about dayClick
 			var col = Math.min(colCnt-1, Math.floor((ev.pageX - dayTable.offset().left - axisWidth) / colWidth));
-			var date = colDate(col);
+			var date = cellToDate(0, col);
 			var rowMatch = this.parentNode.className.match(/fc-slot(\d+)/); // TODO: maybe use data
 			if (rowMatch) {
 				var mins = parseInt(rowMatch[1]) * opt('slotMinutes');
@@ -496,26 +564,26 @@ function AgendaView(element, calendar, viewName) {
 	
 	/* Semi-transparent Overlay Helpers
 	-----------------------------------------------------*/
-	
+	// TODO: should be consolidated with BasicView's methods
+
+
+	function renderDayOverlay(overlayStart, overlayEnd, refreshCoordinateGrid) { // overlayEnd is exclusive
 
-	function renderDayOverlay(startDate, endDate, refreshCoordinateGrid) { // endDate is exclusive
 		if (refreshCoordinateGrid) {
 			coordinateGrid.build();
 		}
-		var visStart = cloneDate(t.visStart);
-		var startCol, endCol;
-		if (rtl) {
-			startCol = dayDiff(endDate, visStart)*dis+dit+1;
-			endCol = dayDiff(startDate, visStart)*dis+dit+1;
-		}else{
-			startCol = dayDiff(startDate, visStart);
-			endCol = dayDiff(endDate, visStart);
-		}
-		startCol = Math.max(0, startCol);
-		endCol = Math.min(colCnt, endCol);
-		if (startCol < endCol) {
+
+		var segments = rangeToSegments(overlayStart, overlayEnd);
+
+		for (var i=0; i<segments.length; i++) {
+			var segment = segments[i];
 			dayBind(
-				renderCellOverlay(0, startCol, 0, endCol-1)
+				renderCellOverlay(
+					segment.row,
+					segment.leftCol,
+					segment.row,
+					segment.rightCol
+				)
 			);
 		}
 	}
@@ -528,24 +596,21 @@ function AgendaView(element, calendar, viewName) {
 	
 
 	function renderSlotOverlay(overlayStart, overlayEnd) {
-		var dayStart = cloneDate(t.visStart);
-		var dayEnd = addDays(cloneDate(dayStart), 1);
 		for (var i=0; i<colCnt; i++) {
+			var dayStart = cellToDate(0, i);
+			var dayEnd = addDays(cloneDate(dayStart), 1);
 			var stretchStart = new Date(Math.max(dayStart, overlayStart));
 			var stretchEnd = new Date(Math.min(dayEnd, overlayEnd));
 			if (stretchStart < stretchEnd) {
-				var col = i*dis+dit;
-				var rect = coordinateGrid.rect(0, col, 0, col, slotContent); // only use it for horizontal coords
+				var rect = coordinateGrid.rect(0, i, 0, i, slotContainer); // only use it for horizontal coords
 				var top = timePosition(dayStart, stretchStart);
 				var bottom = timePosition(dayStart, stretchEnd);
 				rect.top = top;
 				rect.height = bottom - top;
 				slotBind(
-					renderOverlay(rect, slotContent)
+					renderOverlay(rect, slotContainer)
 				);
 			}
-			addDays(dayStart, 1);
-			addDays(dayEnd, 1);
 		}
 	}
 	
@@ -572,7 +637,7 @@ function AgendaView(element, calendar, viewName) {
 			n = e.offset().top;
 			rows[0] = [n, n+e.outerHeight()];
 		}
-		var slotTableTop = slotContent.offset().top;
+		var slotTableTop = slotContainer.offset().top;
 		var slotScrollerTop = slotScroller.offset().top;
 		var slotScrollerBottom = slotScrollerTop + slotScroller.outerHeight();
 		function constrain(n) {
@@ -589,34 +654,42 @@ function AgendaView(element, calendar, viewName) {
 	
 	hoverListener = new HoverListener(coordinateGrid);
 	
-	
-	colContentPositions = new HorizontalPositionCache(function(col) {
+	colPositions = new HorizontalPositionCache(function(col) {
 		return dayBodyCellInners.eq(col);
 	});
 	
+	colContentPositions = new HorizontalPositionCache(function(col) {
+		return dayBodyCellContentInners.eq(col);
+	});
 	
+	
+	function colLeft(col) {
+		return colPositions.left(col);
+	}
+
+
 	function colContentLeft(col) {
 		return colContentPositions.left(col);
 	}
+
+
+	function colRight(col) {
+		return colPositions.right(col);
+	}
 	
 	
 	function colContentRight(col) {
 		return colContentPositions.right(col);
 	}
-	
-	
-	
-	
-	function dateCell(date) { // "cell" terminology is now confusing
-		return {
-			row: Math.floor(dayDiff(date, t.visStart) / 7),
-			col: dayOfWeekCol(date.getDay())
-		};
+
+
+	function getIsCellAllDay(cell) {
+		return opt('allDaySlot') && !cell.row;
 	}
-	
-	
-	function cellDate(cell) {
-		var d = colDate(cell.col);
+
+
+	function realCellToDate(cell) { // ugh "real" ... but blame it on our abuse of the "cell" system
+		var d = cellToDate(0, cell.col);
 		var slotIndex = cell.row;
 		if (opt('allDaySlot')) {
 			slotIndex--;
@@ -628,23 +701,6 @@ function AgendaView(element, calendar, viewName) {
 	}
 	
 	
-	function colDate(col) { // returns dates with 00:00:00
-		return addDays(cloneDate(t.visStart), col*dis+dit);
-	}
-	
-	
-	function cellIsAllDay(cell) {
-		return opt('allDaySlot') && !cell.row;
-	}
-	
-	
-	function dayOfWeekCol(dayOfWeek) {
-		return ((dayOfWeek - Math.max(firstDay, nwe) + colCnt) % colCnt)*dis+dit;
-	}
-	
-	
-	
-	
 	// get the Y coordinate of the given time on the given day (both Date objects)
 	function timePosition(day, time) { // both date objects. day holds 00:00 of current day
 		day = cloneDate(day, true);
@@ -667,14 +723,6 @@ function AgendaView(element, calendar, viewName) {
 	}
 	
 	
-	function allDayBounds() {
-		return {
-			left: axisWidth,
-			right: viewWidth - gutterWidth
-		}
-	}
-	
-	
 	function getAllDayRow(index) {
 		return allDayRow;
 	}
@@ -717,9 +765,9 @@ function AgendaView(element, calendar, viewName) {
 		var helperOption = opt('selectHelper');
 		coordinateGrid.build();
 		if (helperOption) {
-			var col = dayDiff(startDate, t.visStart) * dis + dit;
+			var col = dateToCell(startDate).col;
 			if (col >= 0 && col < colCnt) { // only works when times are on same day
-				var rect = coordinateGrid.rect(0, col, 0, col, slotContent); // only for horizontal coords
+				var rect = coordinateGrid.rect(0, col, 0, col, slotContainer); // only for horizontal coords
 				var top = timePosition(startDate, startDate);
 				var bottom = timePosition(startDate, endDate);
 				if (bottom > top) { // protect against selections that are entirely before or after visible range
@@ -734,7 +782,7 @@ function AgendaView(element, calendar, viewName) {
 							rect.zIndex = 8;
 							selectionHelper = $(helperRes)
 								.css(rect)
-								.appendTo(slotContent);
+								.appendTo(slotContainer);
 						}
 					}else{
 						rect.isStart = true; // conside rect a "seg" now
@@ -753,7 +801,7 @@ function AgendaView(element, calendar, viewName) {
 					}
 					if (selectionHelper) {
 						slotBind(selectionHelper);
-						slotContent.append(selectionHelper);
+						slotContainer.append(selectionHelper);
 						setOuterWidth(selectionHelper, rect.width, true); // needs to be after appended
 						setOuterHeight(selectionHelper, rect.height, true);
 					}
@@ -780,15 +828,15 @@ function AgendaView(element, calendar, viewName) {
 			var dates;
 			hoverListener.start(function(cell, origCell) {
 				clearSelection();
-				if (cell && cell.col == origCell.col && !cellIsAllDay(cell)) {
-					var d1 = cellDate(origCell);
-					var d2 = cellDate(cell);
+				if (cell && cell.col == origCell.col && !getIsCellAllDay(cell)) {
+					var d1 = realCellToDate(origCell);
+					var d2 = realCellToDate(cell);
 					dates = [
 						d1,
 						addMinutes(cloneDate(d1), snapMinutes), // calculate minutes depending on selection slot minutes 
 						d2,
 						addMinutes(cloneDate(d2), snapMinutes)
-					].sort(cmp);
+					].sort(dateCompare);
 					renderSlotSelection(dates[0], dates[3]);
 				}else{
 					dates = null;
@@ -805,10 +853,10 @@ function AgendaView(element, calendar, viewName) {
 			});
 		}
 	}
-	
-	
+
+
 	function reportDayClick(date, allDay, ev) {
-		trigger('dayClick', dayBodyCells[dayOfWeekCol(date.getDay())], date, allDay, ev);
+		trigger('dayClick', dayBodyCells[dateToCell(date).col], date, allDay, ev);
 	}
 	
 	
@@ -821,10 +869,10 @@ function AgendaView(element, calendar, viewName) {
 		hoverListener.start(function(cell) {
 			clearOverlays();
 			if (cell) {
-				if (cellIsAllDay(cell)) {
+				if (getIsCellAllDay(cell)) {
 					renderCellOverlay(cell.row, cell.col, cell.row, cell.col);
 				}else{
-					var d1 = cellDate(cell);
+					var d1 = realCellToDate(cell);
 					var d2 = addMinutes(cloneDate(d1), opt('defaultEventMinutes'));
 					renderSlotOverlay(d1, d2);
 				}
@@ -837,9 +885,9 @@ function AgendaView(element, calendar, viewName) {
 		var cell = hoverListener.stop();
 		clearOverlays();
 		if (cell) {
-			trigger('drop', _dragElement, cellDate(cell), cellIsAllDay(cell), ev, ui);
+			trigger('drop', _dragElement, realCellToDate(cell), getIsCellAllDay(cell), ev, ui);
 		}
 	}
-
+	
 
 }
diff --git a/src/agenda/AgendaWeekView.js b/src/agenda/AgendaWeekView.js
index 03d0f7e..3352cc5 100644
--- a/src/agenda/AgendaWeekView.js
+++ b/src/agenda/AgendaWeekView.js
@@ -13,34 +13,40 @@ function AgendaWeekView(element, calendar) {
 	AgendaView.call(t, element, calendar, 'agendaWeek');
 	var opt = t.opt;
 	var renderAgenda = t.renderAgenda;
+	var skipHiddenDays = t.skipHiddenDays;
+	var getCellsPerWeek = t.getCellsPerWeek;
 	var formatDates = calendar.formatDates;
-	
-	
+
 	
 	function render(date, delta) {
+
 		if (delta) {
 			addDays(date, delta * 7);
 		}
+
 		var start = addDays(cloneDate(date), -((date.getDay() - opt('firstDay') + 7) % 7));
 		var end = addDays(cloneDate(start), 7);
+
 		var visStart = cloneDate(start);
+		skipHiddenDays(visStart);
+
 		var visEnd = cloneDate(end);
-		var weekends = opt('weekends');
-		if (!weekends) {
-			skipWeekend(visStart);
-			skipWeekend(visEnd, -1, true);
-		}
+		skipHiddenDays(visEnd, -1, true);
+
+		var colCnt = getCellsPerWeek();
+
 		t.title = formatDates(
 			visStart,
 			addDays(cloneDate(visEnd), -1),
 			opt('titleFormat')
 		);
+
 		t.start = start;
 		t.end = end;
 		t.visStart = visStart;
 		t.visEnd = visEnd;
-		renderAgenda(weekends ? 7 : 5);
+
+		renderAgenda(colCnt);
 	}
-	
 
 }
diff --git a/src/basic/BasicDayView.js b/src/basic/BasicDayView.js
index 1f49c84..2c94d8c 100644
--- a/src/basic/BasicDayView.js
+++ b/src/basic/BasicDayView.js
@@ -1,8 +1,6 @@
 
 fcViews.basicDay = BasicDayView;
 
-//TODO: when calendar's date starts out on a weekend, shouldn't happen
-
 
 function BasicDayView(element, calendar) {
 	var t = this;
@@ -16,20 +14,25 @@ function BasicDayView(element, calendar) {
 	BasicView.call(t, element, calendar, 'basicDay');
 	var opt = t.opt;
 	var renderBasic = t.renderBasic;
+	var skipHiddenDays = t.skipHiddenDays;
 	var formatDate = calendar.formatDate;
 	
 	
-	
 	function render(date, delta) {
+
 		if (delta) {
 			addDays(date, delta);
-			if (!opt('weekends')) {
-				skipWeekend(date, delta < 0 ? -1 : 1);
-			}
 		}
+		skipHiddenDays(date, delta < 0 ? -1 : 1);
+
+		var start = cloneDate(date, true);
+		var end = addDays(cloneDate(start), 1);
+
 		t.title = formatDate(date, opt('titleFormat'));
-		t.start = t.visStart = cloneDate(date, true);
-		t.end = t.visEnd = addDays(cloneDate(t.start), 1);
+
+		t.start = t.visStart = start;
+		t.end = t.visEnd = end;
+
 		renderBasic(1, 1, false);
 	}
 	
diff --git a/src/basic/BasicEventRenderer.js b/src/basic/BasicEventRenderer.js
index 1ad3786..342e1de 100644
--- a/src/basic/BasicEventRenderer.js
+++ b/src/basic/BasicEventRenderer.js
@@ -5,138 +5,26 @@ function BasicEventRenderer() {
 	
 	// exports
 	t.renderEvents = renderEvents;
-	t.compileDaySegs = compileSegs; // for DayEventRenderer
 	t.clearEvents = clearEvents;
-	t.bindDaySeg = bindDaySeg;
-	
 	
+
 	// imports
 	DayEventRenderer.call(t);
-	var opt = t.opt;
-	var trigger = t.trigger;
-	//var setOverflowHidden = t.setOverflowHidden;
-	var isEventDraggable = t.isEventDraggable;
-	var isEventResizable = t.isEventResizable;
-	var reportEvents = t.reportEvents;
-	var reportEventClear = t.reportEventClear;
-	var eventElementHandlers = t.eventElementHandlers;
-	var showEvents = t.showEvents;
-	var hideEvents = t.hideEvents;
-	var eventDrop = t.eventDrop;
-	var getDaySegmentContainer = t.getDaySegmentContainer;
-	var getHoverListener = t.getHoverListener;
-	var renderDayOverlay = t.renderDayOverlay;
-	var clearOverlays = t.clearOverlays;
-	var getRowCnt = t.getRowCnt;
-	var getColCnt = t.getColCnt;
-	var renderDaySegs = t.renderDaySegs;
-	var resizableDayEvent = t.resizableDayEvent;
-	
-	
-	
-	/* Rendering
-	--------------------------------------------------------------------*/
-	
+
 	
 	function renderEvents(events, modifiedEventId) {
-		reportEvents(events);
-		renderDaySegs(compileSegs(events), modifiedEventId);
-		trigger('eventAfterAllRender');
+		t.reportEvents(events);
+		t.renderDayEvents(events, modifiedEventId);
+		t.trigger('eventAfterAllRender');
 	}
 	
 	
 	function clearEvents() {
-		reportEventClear();
-		getDaySegmentContainer().empty();
-	}
-	
-	
-	function compileSegs(events) {
-		var rowCnt = getRowCnt(),
-			colCnt = getColCnt(),
-			d1 = cloneDate(t.visStart),
-			d2 = addDays(cloneDate(d1), colCnt),
-			visEventsEnds = $.map(events, exclEndDay),
-			i, row,
-			j, level,
-			k, seg,
-			segs=[];
-		for (i=0; i<rowCnt; i++) {
-			row = stackSegs(sliceSegs(events, visEventsEnds, d1, d2));
-			for (j=0; j<row.length; j++) {
-				level = row[j];
-				for (k=0; k<level.length; k++) {
-					seg = level[k];
-					seg.row = i;
-					seg.level = j; // not needed anymore
-					segs.push(seg);
-				}
-			}
-			addDays(d1, 7);
-			addDays(d2, 7);
-		}
-		return segs;
-	}
-	
-	
-	function bindDaySeg(event, eventElement, seg) {
-		if (isEventDraggable(event)) {
-			draggableDayEvent(event, eventElement);
-		}
-		if (seg.isEnd && isEventResizable(event)) {
-			resizableDayEvent(event, eventElement, seg);
-		}
-		eventElementHandlers(event, eventElement);
-			// needs to be after, because resizableDayEvent might stopImmediatePropagation on click
-	}
-	
-	
-	
-	/* Dragging
-	----------------------------------------------------------------------------*/
-	
-	
-	function draggableDayEvent(event, eventElement) {
-		var hoverListener = getHoverListener();
-		var dayDelta;
-		eventElement.draggable({
-			zIndex: 9,
-			delay: 50,
-			opacity: opt('dragOpacity'),
-			revertDuration: opt('dragRevertDuration'),
-			start: function(ev, ui) {
-				trigger('eventDragStart', eventElement, event, ev, ui);
-				hideEvents(event, eventElement);
-				hoverListener.start(function(cell, origCell, rowDelta, colDelta) {
-					eventElement.draggable('option', 'revert', !cell || !rowDelta && !colDelta);
-					clearOverlays();
-					if (cell) {
-						//setOverflowHidden(true);
-						dayDelta = rowDelta*7 + colDelta * (opt('isRTL') ? -1 : 1);
-						renderDayOverlay(
-							addDays(cloneDate(event.start), dayDelta),
-							addDays(exclEndDay(event), dayDelta)
-						);
-					}else{
-						//setOverflowHidden(false);
-						dayDelta = 0;
-					}
-				}, ev, 'drag');
-			},
-			stop: function(ev, ui) {
-				hoverListener.stop();
-				clearOverlays();
-				trigger('eventDragStop', eventElement, event, ev, ui);
-				if (dayDelta) {
-					eventDrop(this, event, dayDelta, 0, event.allDay, ev, ui);
-				}else{
-					eventElement.css('filter', ''); // clear IE opacity side-effects
-					showEvents(event, eventElement);
-				}
-				//setOverflowHidden(false);
-			}
-		});
+		t.reportEventClear();
+		t.getDaySegmentContainer().empty();
 	}
 
 
+	// TODO: have this class (and AgendaEventRenderer) be responsible for creating the event container div
+
 }
diff --git a/src/basic/BasicView.js b/src/basic/BasicView.js
index 2e9acc2..94b8065 100644
--- a/src/basic/BasicView.js
+++ b/src/basic/BasicView.js
@@ -21,14 +21,12 @@ function BasicView(element, calendar, viewName) {
 	t.dragStop = dragStop;
 	t.defaultEventEnd = defaultEventEnd;
 	t.getHoverListener = function() { return hoverListener };
+	t.colLeft = colLeft;
+	t.colRight = colRight;
 	t.colContentLeft = colContentLeft;
 	t.colContentRight = colContentRight;
-	t.dayOfWeekCol = dayOfWeekCol;
-	t.dateCell = dateCell;
-	t.cellDate = cellDate;
-	t.cellIsAllDay = function() { return true };
+	t.getIsCellAllDay = function() { return true };
 	t.allDayRow = allDayRow;
-	t.allDayBounds = allDayBounds;
 	t.getRowCnt = function() { return rowCnt };
 	t.getColCnt = function() { return colCnt };
 	t.getColWidth = function() { return colWidth };
@@ -46,6 +44,9 @@ function BasicView(element, calendar, viewName) {
 	var renderOverlay = t.renderOverlay;
 	var clearOverlays = t.clearOverlays;
 	var daySelectionMousedown = t.daySelectionMousedown;
+	var cellToDate = t.cellToDate;
+	var dateToCell = t.dateToCell;
+	var rangeToSegments = t.rangeToSegments;
 	var formatDate = calendar.formatDate;
 	
 	
@@ -58,7 +59,8 @@ function BasicView(element, calendar, viewName) {
 	var bodyRows;
 	var bodyCells;
 	var bodyFirstCells;
-	var bodyCellTopInners;
+	var firstRowCellInners;
+	var firstRowCellContentInners;
 	var daySegmentContainer;
 	
 	var viewWidth;
@@ -67,13 +69,12 @@ function BasicView(element, calendar, viewName) {
 	var weekNumberWidth;
 	
 	var rowCnt, colCnt;
+	var showNumbers;
 	var coordinateGrid;
 	var hoverListener;
+	var colPositions;
 	var colContentPositions;
 	
-	var rtl, dis, dit;
-	var firstDay;
-	var nwe; // no weekends? a 0 or 1 for easy computations
 	var tm;
 	var colFormat;
 	var showWeekNumbers;
@@ -89,9 +90,10 @@ function BasicView(element, calendar, viewName) {
 	disableTextSelection(element.addClass('fc-grid'));
 	
 	
-	function renderBasic(r, c, showNumbers) {
-		rowCnt = r;
-		colCnt = c;
+	function renderBasic(_rowCnt, _colCnt, _showNumbers) {
+		rowCnt = _rowCnt;
+		colCnt = _colCnt;
+		showNumbers = _showNumbers;
 		updateOptions();
 		var firstTime = !body;
 		if (firstTime) {
@@ -99,22 +101,11 @@ function BasicView(element, calendar, viewName) {
 		}else{
 			clearEvents();
 		}
-		buildTable(showNumbers);
+		buildTable();
 	}
 	
 	
-	
 	function updateOptions() {
-		rtl = opt('isRTL');
-		if (rtl) {
-			dis = -1;
-			dit = colCnt - 1;
-		}else{
-			dis = 1;
-			dit = 0;
-		}
-		firstDay = opt('firstDay');
-		nwe = opt('weekends') ? 0 : 1;
 		tm = opt('theme') ? 'ui' : 'fc';
 		colFormat = opt('columnFormat');
 
@@ -130,7 +121,6 @@ function BasicView(element, calendar, viewName) {
 	}
 	
 	
-	
 	function buildEventContainer() {
 		daySegmentContainer =
 			$("<div style='position:absolute;z-index:8;top:0;left:0'/>")
@@ -138,79 +128,8 @@ function BasicView(element, calendar, viewName) {
 	}
 	
 	
-	
-	function buildTable(showNumbers) {
-		var html = '';
-		var i, j;
-		var headerClass = tm + "-widget-header";
-		var contentClass = tm + "-widget-content";
-		var month = t.start.getMonth();
-		var today = clearTime(new Date());
-		var cellDate; // not to be confused with local function. TODO: better names
-		var cellClasses;
-		var cell;
-
-		html += "<table class='fc-border-separate' style='width:100%' cellspacing='0'>" +
-		        "<thead>" +
-		        "<tr>";
-
-		if (showWeekNumbers) {
-			html += "<th class='fc-week-number " + headerClass + "'/>";
-		}
-
-		for (i=0; i<colCnt; i++) {
-			cellDate = _cellDate(0, i); // a little confusing. cellDate is local variable. _cellDate is private function
-			html += "<th class='fc-day-header fc-" + dayIDs[cellDate.getDay()] + " " + headerClass + "'/>";
-		}
-
-		html += "</tr>" +
-		        "</thead>" +
-		        "<tbody>";
-
-		for (i=0; i<rowCnt; i++) {
-			html += "<tr class='fc-week'>";
-
-			if (showWeekNumbers) {
-				html += "<td class='fc-week-number " + contentClass + "'>" +
-				        "<div/>" +
-				        "</td>";
-			}
-
-			for (j=0; j<colCnt; j++) {
-				cellDate = _cellDate(i, j); // a little confusing. cellDate is local variable. _cellDate is private function
-
-				cellClasses = [
-					'fc-day',
-					'fc-' + dayIDs[cellDate.getDay()],
-					contentClass
-				];
-				if (cellDate.getMonth() != month) {
-					cellClasses.push('fc-other-month');
-				}
-				if (+cellDate == +today) {
-					cellClasses.push('fc-today');
-					cellClasses.push(tm + '-state-highlight');
-				}
-
-				html += "<td" +
-				        " class='" + cellClasses.join(' ') + "'" +
-				        " data-date='" + formatDate(cellDate, 'yyyy-MM-dd') + "'" +
-				        ">" + 
-				        "<div>";
-				if (showNumbers) {
-					html += "<div class='fc-day-number'>" + cellDate.getDate() + "</div>";
-				}
-				html += "<div class='fc-day-content'>" +
-				        "<div style='position:relative'>&nbsp;</div>" +
-				        "</div>" +
-				        "</div>" +
-				        "</td>";
-			}
-
-			html += "</tr>";
-		}
-		html += "</tbody>" +
-		        "</table>";
+	function buildTable() {
+		var html = buildTableHTML();
 
 		lockHeight(); // the unlock happens later, in setHeight()...
 		if (table) {
@@ -224,37 +143,155 @@ function BasicView(element, calendar, viewName) {
 		bodyRows = body.find('tr');
 		bodyCells = body.find('.fc-day');
 		bodyFirstCells = bodyRows.find('td:first-child');
-		bodyCellTopInners = bodyRows.eq(0).find('.fc-day-content > div');
+
+		firstRowCellInners = bodyRows.eq(0).find('.fc-day > div');
+		firstRowCellContentInners = bodyRows.eq(0).find('.fc-day-content > div');
 		
 		markFirstLast(head.add(head.find('tr'))); // marks first+last tr/th's
 		markFirstLast(bodyRows); // marks first+last td's
 		bodyRows.eq(0).addClass('fc-first');
 		bodyRows.filter(':last').addClass('fc-last');
-	
-		if (showWeekNumbers) {
-			head.find('.fc-week-number').text(weekNumberTitle);
-		}
 
-		headCells.each(function(i, _cell) {
-			var date = indexDate(i);
-			$(_cell).text(formatDate(date, colFormat));
-		});
-
-		if (showWeekNumbers) {
-			body.find('.fc-week-number > div').each(function(i, _cell) {
-				var weekStart = _cellDate(i, 0);
-				$(_cell).text(formatDate(weekStart, weekNumberFormat));
-			});
-		}
-		
 		bodyCells.each(function(i, _cell) {
-			var date = indexDate(i);
+			var date = cellToDate(
+				Math.floor(i / colCnt),
+				i % colCnt
+			);
 			trigger('dayRender', t, date, $(_cell));
 		});
 
 		dayBind(bodyCells);
 	}
-	
+
+
+
+	/* HTML Building
+	-----------------------------------------------------------*/
+
+
+	function buildTableHTML() {
+		var html =
+			"<table class='fc-border-separate' style='width:100%' cellspacing='0'>" +
+			buildHeadHTML() +
+			buildBodyHTML() +
+			"</table>";
+
+		return html;
+	}
+
+
+	function buildHeadHTML() {
+		var headerClass = tm + "-widget-header";
+		var html = '';
+		var col;
+		var date;
+
+		html += "<thead><tr>";
+
+		if (showWeekNumbers) {
+			html +=
+				"<th class='fc-week-number " + headerClass + "'>" +
+				htmlEscape(weekNumberTitle) +
+				"</th>";
+		}
+
+		for (col=0; col<colCnt; col++) {
+			date = cellToDate(0, col);
+			html +=
+				"<th class='fc-day-header fc-" + dayIDs[date.getDay()] + " " + headerClass + "'>" +
+				htmlEscape(formatDate(date, colFormat)) +
+				"</th>";
+		}
+
+		html += "</tr></thead>";
+
+		return html;
+	}
+
+
+	function buildBodyHTML() {
+		var contentClass = tm + "-widget-content";
+		var html = '';
+		var row;
+		var col;
+		var date;
+
+		html += "<tbody>";
+
+		for (row=0; row<rowCnt; row++) {
+
+			html += "<tr class='fc-week'>";
+
+			if (showWeekNumbers) {
+				date = cellToDate(row, 0);
+				html +=
+					"<td class='fc-week-number " + contentClass + "'>" +
+					"<div>" +
+					htmlEscape(formatDate(date, weekNumberFormat)) +
+					"</div>" +
+					"</td>";
+			}
+
+			for (col=0; col<colCnt; col++) {
+				date = cellToDate(row, col);
+				html += buildCellHTML(date);
+			}
+
+			html += "</tr>";
+		}
+
+		html += "</tbody>";
+
+		return html;
+	}
+
+
+	function buildCellHTML(date) {
+		var contentClass = tm + "-widget-content";
+		var month = t.start.getMonth();
+		var today = clearTime(new Date());
+		var html = '';
+		var classNames = [
+			'fc-day',
+			'fc-' + dayIDs[date.getDay()],
+			contentClass
+		];
+
+		if (date.getMonth() != month) {
+			classNames.push('fc-other-month');
+		}
+		if (+date == +today) {
+			classNames.push(
+				'fc-today',
+				tm + '-state-highlight'
+			);
+		}
+
+		html +=
+			"<td" +
+			" class='" + classNames.join(' ') + "'" +
+			" data-date='" + formatDate(date, 'yyyy-MM-dd') + "'" +
+			">" +
+			"<div>";
+
+		if (showNumbers) {
+			html += "<div class='fc-day-number'>" + date.getDate() + "</div>";
+		}
+
+		html +=
+			"<div class='fc-day-content'>" +
+			"<div style='position:relative'>&nbsp;</div>" +
+			"</div>" +
+			"</div>" +
+			"</td>";
+
+		return html;
+	}
+
+
+
+	/* Dimensions
+	-----------------------------------------------------------*/
 	
 	
 	function setHeight(height) {
@@ -288,6 +325,7 @@ function BasicView(element, calendar, viewName) {
 	
 	function setWidth(width) {
 		viewWidth = width;
+		colPositions.clear();
 		colContentPositions.clear();
 
 		weekNumberWidth = 0;
@@ -322,35 +360,30 @@ function BasicView(element, calendar, viewName) {
 	
 	/* Semi-transparent Overlay Helpers
 	------------------------------------------------------*/
-	
-	
+	// TODO: should be consolidated with AgendaView's methods
+
+
 	function renderDayOverlay(overlayStart, overlayEnd, refreshCoordinateGrid) { // overlayEnd is exclusive
+
 		if (refreshCoordinateGrid) {
 			coordinateGrid.build();
 		}
-		var rowStart = cloneDate(t.visStart);
-		var rowEnd = addDays(cloneDate(rowStart), colCnt);
-		for (var i=0; i<rowCnt; i++) {
-			var stretchStart = new Date(Math.max(rowStart, overlayStart));
-			var stretchEnd = new Date(Math.min(rowEnd, overlayEnd));
-			if (stretchStart < stretchEnd) {
-				var colStart, colEnd;
-				if (rtl) {
-					colStart = dayDiff(stretchEnd, rowStart)*dis+dit+1;
-					colEnd = dayDiff(stretchStart, rowStart)*dis+dit+1;
-				}else{
-					colStart = dayDiff(stretchStart, rowStart);
-					colEnd = dayDiff(stretchEnd, rowStart);
-				}
-				dayBind(
-					renderCellOverlay(i, colStart, i, colEnd-1)
-				);
-			}
-			addDays(rowStart, 7);
-			addDays(rowEnd, 7);
+
+		var segments = rangeToSegments(overlayStart, overlayEnd);
+
+		for (var i=0; i<segments.length; i++) {
+			var segment = segments[i];
+			dayBind(
+				renderCellOverlay(
+					segment.row,
+					segment.leftCol,
+					segment.row,
+					segment.rightCol
+				)
+			);
 		}
 	}
-	
+
 	
 	function renderCellOverlay(row0, col0, row1, col1) { // row1,col1 is inclusive
 		var rect = coordinateGrid.rect(row0, col0, row1, col1, element);
@@ -379,7 +412,7 @@ function BasicView(element, calendar, viewName) {
 	
 	
 	function reportDayClick(date, allDay, ev) {
-		var cell = dateCell(date);
+		var cell = dateToCell(date);
 		var _element = bodyCells[cell.row*colCnt + cell.col];
 		trigger('dayClick', _element, date, allDay, ev);
 	}
@@ -404,7 +437,7 @@ function BasicView(element, calendar, viewName) {
 		var cell = hoverListener.stop();
 		clearOverlays();
 		if (cell) {
-			var d = cellDate(cell);
+			var d = cellToDate(cell);
 			trigger('drop', _dragElement, d, true, ev, ui);
 		}
 	}
@@ -449,10 +482,23 @@ function BasicView(element, calendar, viewName) {
 	
 	hoverListener = new HoverListener(coordinateGrid);
 	
-	
-	colContentPositions = new HorizontalPositionCache(function(col) {
-		return bodyCellTopInners.eq(col);
+	colPositions = new HorizontalPositionCache(function(col) {
+		return firstRowCellInners.eq(col);
 	});
+
+	colContentPositions = new HorizontalPositionCache(function(col) {
+		return firstRowCellContentInners.eq(col);
+	});
+
+
+	function colLeft(col) {
+		return colPositions.left(col);
+	}
+
+
+	function colRight(col) {
+		return colPositions.right(col);
+	}
 	
 	
 	function colContentLeft(col) {
@@ -465,54 +511,9 @@ function BasicView(element, calendar, viewName) {
 	}
 	
 	
-	
-	
-	function dateCell(date) {
-		return {
-			row: Math.floor(dayDiff(date, t.visStart) / 7),
-			col: dayOfWeekCol(date.getDay())
-		};
-	}
-	
-	
-	function cellDate(cell) {
-		return _cellDate(cell.row, cell.col);
-	}
-	
-	
-	function _cellDate(row, col) {
-		return addDays(cloneDate(t.visStart), row*7 + col*dis+dit);
-		// what about weekends in middle of week?
-	}
-	
-	
-	function indexDate(index) {
-		return _cellDate(Math.floor(index/colCnt), index%colCnt);
-	}
-	
-	
-	function dayOfWeekCol(dayOfWeek) {
-		return ((dayOfWeek - Math.max(firstDay, nwe) + colCnt) % colCnt) * dis + dit;
-	}
-	
-	
-	
-	
 	function allDayRow(i) {
 		return bodyRows.eq(i);
 	}
-	
-	
-	function allDayBounds(i) {
-		var left = 0;
-		if (showWeekNumbers) {
-			left += weekNumberWidth;
-		}
-		return {
-			left: left,
-			right: viewWidth
-		};
-	}
 
 
 
diff --git a/src/basic/BasicWeekView.js b/src/basic/BasicWeekView.js
index 07ee63f..241be0c 100644
--- a/src/basic/BasicWeekView.js
+++ b/src/basic/BasicWeekView.js
@@ -13,33 +13,40 @@ function BasicWeekView(element, calendar) {
 	BasicView.call(t, element, calendar, 'basicWeek');
 	var opt = t.opt;
 	var renderBasic = t.renderBasic;
+	var skipHiddenDays = t.skipHiddenDays;
+	var getCellsPerWeek = t.getCellsPerWeek;
 	var formatDates = calendar.formatDates;
 	
 	
-	
 	function render(date, delta) {
+
 		if (delta) {
 			addDays(date, delta * 7);
 		}
+
 		var start = addDays(cloneDate(date), -((date.getDay() - opt('firstDay') + 7) % 7));
 		var end = addDays(cloneDate(start), 7);
+
 		var visStart = cloneDate(start);
+		skipHiddenDays(visStart);
+
 		var visEnd = cloneDate(end);
-		var weekends = opt('weekends');
-		if (!weekends) {
-			skipWeekend(visStart);
-			skipWeekend(visEnd, -1, true);
-		}
+		skipHiddenDays(visEnd, -1, true);
+
+		var colCnt = getCellsPerWeek();
+
+		t.start = start;
+		t.end = end;
+		t.visStart = visStart;
+		t.visEnd = visEnd;
+
 		t.title = formatDates(
 			visStart,
 			addDays(cloneDate(visEnd), -1),
 			opt('titleFormat')
 		);
-		t.start = start;
-		t.end = end;
-		t.visStart = visStart;
-		t.visEnd = visEnd;
-		renderBasic(1, weekends ? 7 : 5, false);
+
+		renderBasic(1, colCnt, false);
 	}
 	
 	
diff --git a/src/basic/MonthView.js b/src/basic/MonthView.js
index 6fd7cd1..bad09b1 100644
--- a/src/basic/MonthView.js
+++ b/src/basic/MonthView.js
@@ -13,39 +13,49 @@ function MonthView(element, calendar) {
 	BasicView.call(t, element, calendar, 'month');
 	var opt = t.opt;
 	var renderBasic = t.renderBasic;
+	var skipHiddenDays = t.skipHiddenDays;
+	var getCellsPerWeek = t.getCellsPerWeek;
 	var formatDate = calendar.formatDate;
 	
 	
-	
 	function render(date, delta) {
+
 		if (delta) {
 			addMonths(date, delta);
 			date.setDate(1);
 		}
+
+		var firstDay = opt('firstDay');
+
 		var start = cloneDate(date, true);
 		start.setDate(1);
+
 		var end = addMonths(cloneDate(start), 1);
+
 		var visStart = cloneDate(start);
+		addDays(visStart, -((visStart.getDay() - firstDay + 7) % 7));
+		skipHiddenDays(visStart);
+
 		var visEnd = cloneDate(end);
-		var firstDay = opt('firstDay');
-		var nwe = opt('weekends') ? 0 : 1;
-		if (nwe) {
-			skipWeekend(visStart);
-			skipWeekend(visEnd, -1, true);
-		}
-		addDays(visStart, -((visStart.getDay() - Math.max(firstDay, nwe) + 7) % 7));
-		addDays(visEnd, (7 - visEnd.getDay() + Math.max(firstDay, nwe)) % 7);
-		var rowCnt = Math.round((visEnd - visStart) / (DAY_MS * 7));
+		addDays(visEnd, (7 - visEnd.getDay() + firstDay) % 7);
+		skipHiddenDays(visEnd, -1, true);
+
+		var colCnt = getCellsPerWeek();
+		var rowCnt = Math.round(dayDiff(visEnd, visStart) / 7); // should be no need for Math.round
+
 		if (opt('weekMode') == 'fixed') {
-			addDays(visEnd, (6 - rowCnt) * 7);
+			addDays(visEnd, (6 - rowCnt) * 7); // add weeks to make up for it
 			rowCnt = 6;
 		}
+
 		t.title = formatDate(start, opt('titleFormat'));
+
 		t.start = start;
 		t.end = end;
 		t.visStart = visStart;
 		t.visEnd = visEnd;
-		renderBasic(rowCnt, nwe ? 5 : 7, true);
+
+		renderBasic(rowCnt, colCnt, true);
 	}
 	
 	
diff --git a/src/common/DayEventRenderer.js b/src/common/DayEventRenderer.js
index ff41b12..cc76bf7 100644
--- a/src/common/DayEventRenderer.js
+++ b/src/common/DayEventRenderer.js
@@ -4,8 +4,9 @@ function DayEventRenderer() {
 
 	
 	// exports
-	t.renderDaySegs = renderDaySegs;
-	t.resizableDayEvent = resizableDayEvent;
+	t.renderDayEvents = renderDayEvents;
+	t.draggableDayEvent = draggableDayEvent; // made public so that subclasses can override
+	t.resizableDayEvent = resizableDayEvent; // "
 	
 	
 	// imports
@@ -15,368 +16,602 @@ function DayEventRenderer() {
 	var isEventResizable = t.isEventResizable;
 	var eventEnd = t.eventEnd;
 	var reportEventElement = t.reportEventElement;
+	var eventElementHandlers = t.eventElementHandlers;
 	var showEvents = t.showEvents;
 	var hideEvents = t.hideEvents;
+	var eventDrop = t.eventDrop;
 	var eventResize = t.eventResize;
 	var getRowCnt = t.getRowCnt;
 	var getColCnt = t.getColCnt;
 	var getColWidth = t.getColWidth;
-	var allDayRow = t.allDayRow;
-	var allDayBounds = t.allDayBounds;
+	var allDayRow = t.allDayRow; // TODO: rename
+	var colLeft = t.colLeft;
+	var colRight = t.colRight;
 	var colContentLeft = t.colContentLeft;
 	var colContentRight = t.colContentRight;
-	var dayOfWeekCol = t.dayOfWeekCol;
-	var dateCell = t.dateCell;
-	var compileDaySegs = t.compileDaySegs;
+	var dateToCell = t.dateToCell;
 	var getDaySegmentContainer = t.getDaySegmentContainer;
-	var bindDaySeg = t.bindDaySeg; //TODO: streamline this
 	var formatDates = t.calendar.formatDates;
 	var renderDayOverlay = t.renderDayOverlay;
 	var clearOverlays = t.clearOverlays;
 	var clearSelection = t.clearSelection;
-	
-	
-	
-	/* Rendering
-	-----------------------------------------------------------------------------*/
-	
-	
-	function renderDaySegs(segs, modifiedEventId) {
-		var segmentContainer = getDaySegmentContainer();
-		var rowDivs;
-		var rowCnt = getRowCnt();
-		var colCnt = getColCnt();
-		var i = 0;
-		var rowI;
-		var levelI;
-		var colHeights;
-		var j;
-		var segCnt = segs.length;
-		var seg;
-		var top;
-		var k;
-		segmentContainer[0].innerHTML = daySegHTML(segs); // faster than .html()
-		daySegElementResolve(segs, segmentContainer.children());
-		daySegElementReport(segs);
-		daySegHandlers(segs, segmentContainer, modifiedEventId);
-		daySegCalcHSides(segs);
-		daySegSetWidths(segs);
-		daySegCalcHeights(segs);
-		rowDivs = getRowDivs();
-		// set row heights, calculate event tops (in relation to row top)
-		for (rowI=0; rowI<rowCnt; rowI++) {
-			levelI = 0;
-			colHeights = [];
-			for (j=0; j<colCnt; j++) {
-				colHeights[j] = 0;
-			}
-			while (i<segCnt && (seg = segs[i]).row == rowI) {
-				// loop through segs in a row
-				top = arrayMax(colHeights.slice(seg.startCol, seg.endCol));
-				seg.top = top;
-				top += seg.outerHeight;
-				for (k=seg.startCol; k<seg.endCol; k++) {
-					colHeights[k] = top;
-				}
-				i++;
-			}
-			rowDivs[rowI].height(arrayMax(colHeights));
-		}
-		daySegSetTops(segs, getRowTops(rowDivs));
+	var getHoverListener = t.getHoverListener;
+	var rangeToSegments = t.rangeToSegments;
+	var segmentCompare = t.segmentCompare;
+	var cellToDate = t.cellToDate;
+	var cellToCellOffset = t.cellToCellOffset;
+	var cellOffsetToDayOffset = t.cellOffsetToDayOffset;
+	var dateToDayOffset = t.dateToDayOffset;
+	var dayOffsetToCellOffset = t.dayOffsetToCellOffset;
+
+
+	// Render `events` onto the calendar, attach mouse event handlers, and call the `eventAfterRender` callback for each.
+	// Mouse event will be lazily applied, except if the event has an ID of `modifiedEventId`.
+	// Can only be called when the event container is empty (because it wipes out all innerHTML).
+	function renderDayEvents(events, modifiedEventId) {
+
+		// do the actual rendering. Receive the intermediate "segment" data structures.
+		var segments = _renderDayEvents(
+			events,
+			false, // don't append event elements
+			true // set the heights of the rows
+		);
+
+		// report the elements to the View, for general drag/resize utilities
+		segmentElementEach(segments, function(segment, element) {
+			reportEventElement(segment.event, element);
+		});
+
+		// attach mouse handlers
+		attachHandlers(segments, modifiedEventId);
+
+		// call `eventAfterRender` callback for each event
+		segmentElementEach(segments, function(segment, element) {
+			trigger('eventAfterRender', segment.event, segment.event, element);
+		});
 	}
-	
-	
-	function renderTempDaySegs(segs, adjustRow, adjustTop) {
-		var tempContainer = $("<div/>");
+
+
+	// Render an event on the calendar, but don't report them anywhere, and don't attach mouse handlers.
+	// Append this event element to the event container, which might already be populated with events.
+	// If an event's segment will have row equal to `adjustRow`, then explicitly set its top coordinate to `adjustTop`.
+	// This hack is used to maintain continuity when user is manually resizing an event.
+	// Returns an array of DOM elements for the event.
+	function renderTempDayEvent(event, adjustRow, adjustTop) {
+
+		// actually render the event. `true` for appending element to container.
+		// Recieve the intermediate "segment" data structures.
+		var segments = _renderDayEvents(
+			[ event ],
+			true, // append event elements
+			false // don't set the heights of the rows
+		);
+
+		var elements = [];
+
+		// Adjust certain elements' top coordinates
+		segmentElementEach(segments, function(segment, element) {
+			if (segment.row === adjustRow) {
+				element.css('top', adjustTop);
+			}
+			elements.push(element[0]); // accumulate DOM nodes
+		});
+
+		return elements;
+	}
+
+
+	// Render events onto the calendar. Only responsible for the VISUAL aspect.
+	// Not responsible for attaching handlers or calling callbacks.
+	// Set `doAppend` to `true` for rendering elements without clearing the existing container.
+	// Set `doRowHeights` to allow setting the height of each row, to compensate for vertical event overflow.
+	function _renderDayEvents(events, doAppend, doRowHeights) {
+
+		// where the DOM nodes will eventually end up
+		var finalContainer = getDaySegmentContainer();
+
+		// the container where the initial HTML will be rendered.
+		// If `doAppend`==true, uses a temporary container.
+		var renderContainer = doAppend ? $("<div/>") : finalContainer;
+
+		var segments = buildSegments(events);
+		var html;
 		var elements;
-		var segmentContainer = getDaySegmentContainer();
-		var i;
-		var segCnt = segs.length;
-		var element;
-		tempContainer[0].innerHTML = daySegHTML(segs); // faster than .html()
-		elements = tempContainer.children();
-		segmentContainer.append(elements);
-		daySegElementResolve(segs, elements);
-		daySegCalcHSides(segs);
-		daySegSetWidths(segs);
-		daySegCalcHeights(segs);
-		daySegSetTops(segs, getRowTops(getRowDivs()));
-		elements = [];
-		for (i=0; i<segCnt; i++) {
-			element = segs[i].element;
-			if (element) {
-				if (segs[i].row === adjustRow) {
-					element.css('top', adjustTop);
-				}
-				elements.push(element[0]);
-			}
+
+		// calculate the desired `left` and `width` properties on each segment object
+		calculateHorizontals(segments);
+
+		// build the HTML string. relies on `left` property
+		html = buildHTML(segments);
+
+		// render the HTML. innerHTML is considerably faster than jQuery's .html()
+		renderContainer[0].innerHTML = html;
+
+		// retrieve the individual elements
+		elements = renderContainer.children();
+
+		// if we were appending, and thus using a temporary container,
+		// re-attach elements to the real container.
+		if (doAppend) {
+			finalContainer.append(elements);
 		}
-		return $(elements);
+
+		// assigns each element to `segment.event`, after filtering them through user callbacks
+		resolveElements(segments, elements);
+
+		// Calculate the left and right padding+margin for each element.
+		// We need this for setting each element's desired outer width, because of the W3C box model.
+		// It's important we do this in a separate pass from acually setting the width on the DOM elements
+		// because alternating reading/writing dimensions causes reflow for every iteration.
+		segmentElementEach(segments, function(segment, element) {
+			segment.hsides = hsides(element, true); // include margins = `true`
+		});
+
+		// Set the width of each element
+		segmentElementEach(segments, function(segment, element) {
+			element.width(
+				Math.max(0, segment.outerWidth - segment.hsides)
+			);
+		});
+
+		// Grab each element's outerHeight (setVerticals uses this).
+		// To get an accurate reading, it's important to have each element's width explicitly set already.
+		segmentElementEach(segments, function(segment, element) {
+			segment.outerHeight = element.outerHeight(true); // include margins = `true`
+		});
+
+		// Set the top coordinate on each element (requires segment.outerHeight)
+		setVerticals(segments, doRowHeights);
+
+		return segments;
 	}
-	
-	
-	function daySegHTML(segs) { // also sets seg.left and seg.outerWidth
-		var rtl = opt('isRTL');
-		var i;
-		var segCnt=segs.length;
-		var seg;
-		var event;
-		var url;
-		var classes;
-		var bounds = allDayBounds();
-		var minLeft = bounds.left;
-		var maxLeft = bounds.right;
-		var leftCol;
-		var rightCol;
-		var left;
-		var right;
-		var skinCss;
+
+
+	// Generate an array of "segments" for all events.
+	function buildSegments(events) {
+		var segments = [];
+		for (var i=0; i<events.length; i++) {
+			var eventSegments = buildSegmentsForEvent(events[i]);
+			segments.push.apply(segments, eventSegments); // append an array to an array
+		}
+		return segments;
+	}
+
+
+	// Generate an array of segments for a single event.
+	// A "segment" is the same data structure that View.rangeToSegments produces,
+	// with the addition of the `event` property being set to reference the original event.
+	function buildSegmentsForEvent(event) {
+		var startDate = event.start;
+		var endDate = exclEndDay(event);
+		var segments = rangeToSegments(startDate, endDate);
+		for (var i=0; i<segments.length; i++) {
+			segments[i].event = event;
+		}
+		return segments;
+	}
+
+
+	// Sets the `left` and `outerWidth` property of each segment.
+	// These values are the desired dimensions for the eventual DOM elements.
+	function calculateHorizontals(segments) {
+		var isRTL = opt('isRTL');
+		for (var i=0; i<segments.length; i++) {
+			var segment = segments[i];
+
+			// Determine functions used for calulating the elements left/right coordinates,
+			// depending on whether the view is RTL or not.
+			// NOTE:
+			// colLeft/colRight returns the coordinate butting up the edge of the cell.
+			// colContentLeft/colContentRight is indented a little bit from the edge.
+			var leftFunc = (isRTL ? segment.isEnd : segment.isStart) ? colContentLeft : colLeft;
+			var rightFunc = (isRTL ? segment.isStart : segment.isEnd) ? colContentRight : colRight;
+
+			var left = leftFunc(segment.leftCol);
+			var right = rightFunc(segment.rightCol);
+			segment.left = left;
+			segment.outerWidth = right - left;
+		}
+	}
+
+
+	// Build a concatenated HTML string for an array of segments
+	function buildHTML(segments) {
 		var html = '';
-		// calculate desired position/dimensions, create html
-		for (i=0; i<segCnt; i++) {
-			seg = segs[i];
-			event = seg.event;
-			classes = ['fc-event', 'fc-event-hori'];
-			if (isEventDraggable(event)) {
-				classes.push('fc-event-draggable');
-			}
-			if (seg.isStart) {
-				classes.push('fc-event-start');
-			}
-			if (seg.isEnd) {
-				classes.push('fc-event-end');
-			}
-			if (rtl) {
-				leftCol = dayOfWeekCol(seg.end.getDay()-1);
-				rightCol = dayOfWeekCol(seg.start.getDay());
-				left = seg.isEnd ? colContentLeft(leftCol) : minLeft;
-				right = seg.isStart ? colContentRight(rightCol) : maxLeft;
-			}else{
-				leftCol = dayOfWeekCol(seg.start.getDay());
-				rightCol = dayOfWeekCol(seg.end.getDay()-1);
-				left = seg.isStart ? colContentLeft(leftCol) : minLeft;
-				right = seg.isEnd ? colContentRight(rightCol) : maxLeft;
-			}
-			classes = classes.concat(event.className);
-			if (event.source) {
-				classes = classes.concat(event.source.className || []);
-			}
-			url = event.url;
-			skinCss = getSkinCss(event, opt);
-			if (url) {
-				html += "<a href='" + htmlEscape(url) + "'";
-			}else{
-				html += "<div";
-			}
-			html +=
-				" class='" + classes.join(' ') + "'" +
-				" style='position:absolute;z-index:8;left:"+left+"px;" + skinCss + "'" +
-				">" +
-				"<div class='fc-event-inner'>";
-			if (!event.allDay && seg.isStart) {
-				html +=
-					"<span class='fc-event-time'>" +
-					htmlEscape(formatDates(event.start, event.end, opt('timeFormat'))) +
-					"</span>";
-			}
-			html +=
-				"<span class='fc-event-title'>" + htmlEscape(event.title) + "</span>" +
-				"</div>";
-			if (seg.isEnd && isEventResizable(event)) {
-				html +=
-					"<div class='ui-resizable-handle ui-resizable-" + (rtl ? 'w' : 'e') + "'>" +
-					"&nbsp;&nbsp;&nbsp;" + // makes hit area a lot better for IE6/7
-					"</div>";
-			}
-			html +=
-				"</" + (url ? "a" : "div" ) + ">";
-			seg.left = left;
-			seg.outerWidth = right - left;
-			seg.startCol = leftCol;
-			seg.endCol = rightCol + 1; // needs to be exclusive
+		for (var i=0; i<segments.length; i++) {
+			html += buildHTMLForSegment(segments[i]);
 		}
 		return html;
 	}
-	
-	
-	function daySegElementResolve(segs, elements) { // sets seg.element
-		var i;
-		var segCnt = segs.length;
-		var seg;
-		var event;
-		var element;
-		var triggerRes;
-		for (i=0; i<segCnt; i++) {
-			seg = segs[i];
-			event = seg.event;
-			element = $(elements[i]); // faster than .eq()
-			triggerRes = trigger('eventRender', event, event, element);
+
+
+	// Build an HTML string for a single segment.
+	// Relies on the following properties:
+	// - `segment.event` (from `buildSegmentsForEvent`)
+	// - `segment.left` (from `calculateHorizontals`)
+	function buildHTMLForSegment(segment) {
+		var html = '';
+		var isRTL = opt('isRTL');
+		var event = segment.event;
+		var url = event.url;
+
+		// generate the list of CSS classNames
+		var classNames = [ 'fc-event', 'fc-event-hori' ];
+		if (isEventDraggable(event)) {
+			classNames.push('fc-event-draggable');
+		}
+		if (segment.isStart) {
+			classNames.push('fc-event-start');
+		}
+		if (segment.isEnd) {
+			classNames.push('fc-event-end');
+		}
+		// use the event's configured classNames
+		// guaranteed to be an array via `normalizeEvent`
+		classNames = classNames.concat(event.className);
+		if (event.source) {
+			// use the event's source's classNames, if specified
+			classNames = classNames.concat(event.source.className || []);
+		}
+
+		// generate a semicolon delimited CSS string for any of the "skin" properties
+		// of the event object (`backgroundColor`, `borderColor` and such)
+		var skinCss = getSkinCss(event, opt);
+
+		if (url) {
+			html += "<a href='" + htmlEscape(url) + "'";
+		}else{
+			html += "<div";
+		}
+		html +=
+			" class='" + classNames.join(' ') + "'" +
+			" style=" +
+				"'" +
+				"position:absolute;" +
+				"z-index:8;" + // TODO: move this into a constant or put it in the stylesheet
+				"left:" + segment.left + "px;" +
+				skinCss +
+				"'" +
+			">" +
+			"<div class='fc-event-inner'>";
+		if (!event.allDay && segment.isStart) {
+			html +=
+				"<span class='fc-event-time'>" +
+				htmlEscape(
+					formatDates(event.start, event.end, opt('timeFormat'))
+				) +
+				"</span>";
+		}
+		html +=
+			"<span class='fc-event-title'>" + htmlEscape(event.title) + "</span>" +
+			"</div>";
+		if (segment.isEnd && isEventResizable(event)) {
+			html +=
+				"<div class='ui-resizable-handle ui-resizable-" + (isRTL ? 'w' : 'e') + "'>" +
+				"&nbsp;&nbsp;&nbsp;" + // makes hit area a lot better for IE6/7
+				"</div>";
+		}
+		html += "</" + (url ? "a" : "div") + ">";
+
+		// TODO:
+		// When these elements are initially rendered, they will be briefly visibile on the screen,
+		// even though their widths/heights are not set.
+		// SOLUTION: initially set them as visibility:hidden ?
+
+		return html;
+	}
+
+
+	// Associate each segment (an object) with an element (a jQuery object),
+	// by setting each `segment.element`.
+	// Run each element through the `eventRender` filter, which allows developers to
+	// modify an existing element, supply a new one, or cancel rendering.
+	function resolveElements(segments, elements) {
+		for (var i=0; i<segments.length; i++) {
+			var segment = segments[i];
+			var event = segment.event;
+			var element = elements.eq(i);
+
+			// call the trigger with the original element
+			var triggerRes = trigger('eventRender', event, event, element);
+
 			if (triggerRes === false) {
+				// if `false`, remove the event from the DOM and don't assign it to `segment.event`
 				element.remove();
-			}else{
+			}
+			else {
 				if (triggerRes && triggerRes !== true) {
+					// the trigger returned a new element, but not `true` (which means keep the existing element)
+
+					// re-assign the important CSS dimension properties that were already assigned in `buildHTMLForSegment`
 					triggerRes = $(triggerRes)
 						.css({
 							position: 'absolute',
-							left: seg.left
+							zIndex: 8, // TODO: move this into a constant or put it in the stylesheet
+							left: segment.left
 						});
+
 					element.replaceWith(triggerRes);
 					element = triggerRes;
 				}
-				seg.element = element;
+
+				segment.element = element;
 			}
 		}
 	}
-	
-	
-	function daySegElementReport(segs) {
-		var i;
-		var segCnt = segs.length;
-		var seg;
-		var element;
-		for (i=0; i<segCnt; i++) {
-			seg = segs[i];
-			element = seg.element;
-			if (element) {
-				reportEventElement(seg.event, element);
+
+
+
+	/* Top-coordinate Methods
+	-------------------------------------------------------------------------------------------------*/
+
+
+	// Sets the "top" CSS property for each element.
+	// If `doRowHeights` is `true`, also sets each row's first cell to an explicit height,
+	// so that if elements vertically overflow, the cell expands vertically to compensate.
+	function setVerticals(segments, doRowHeights) {
+		var rowContentHeights = calculateVerticals(segments); // also sets segment.top
+		var rowContentElements = getRowContentElements(); // returns 1 inner div per row
+		var rowContentTops = [];
+
+		// Set each row's height by setting height of first inner div
+		if (doRowHeights) {
+			for (var i=0; i<rowContentElements.length; i++) {
+				rowContentElements[i].height(rowContentHeights[i]);
 			}
 		}
+
+		// Get each row's top, relative to the views's origin.
+		// Important to do this after setting each row's height.
+		for (var i=0; i<rowContentElements.length; i++) {
+			rowContentTops.push(
+				rowContentElements[i].position().top
+			);
+		}
+
+		// Set each segment element's CSS "top" property.
+		// Each segment object has a "top" property, which is relative to the row's top, but...
+		segmentElementEach(segments, function(segment, element) {
+			element.css(
+				'top',
+				rowContentTops[segment.row] + segment.top // ...now, relative to views's origin
+			);
+		});
 	}
-	
-	
-	function daySegHandlers(segs, segmentContainer, modifiedEventId) {
-		var i;
-		var segCnt = segs.length;
-		var seg;
-		var element;
-		var event;
-		// retrieve elements, run through eventRender callback, bind handlers
-		for (i=0; i<segCnt; i++) {
-			seg = segs[i];
-			element = seg.element;
-			if (element) {
-				event = seg.event;
-				if (event._id === modifiedEventId) {
-					bindDaySeg(event, element, seg);
-				}else{
-					element[0]._fci = i; // for lazySegBind
+
+
+	// Calculate the "top" coordinate for each segment, relative to the "top" of the row.
+	// Also, return an array that contains the "content" height for each row
+	// (the height displaced by the vertically stacked events in the row).
+	// Requires segments to have their `outerHeight` property already set.
+	function calculateVerticals(segments) {
+		var rowCnt = getRowCnt();
+		var colCnt = getColCnt();
+		var rowContentHeights = []; // content height for each row
+		var segmentRows = buildSegmentRows(segments); // an array of segment arrays, one for each row
+
+		for (var rowI=0; rowI<rowCnt; rowI++) {
+			var segmentRow = segmentRows[rowI];
+
+			// an array of running total heights for each column.
+			// initialize with all zeros.
+			var colHeights = [];
+			for (var colI=0; colI<colCnt; colI++) {
+				colHeights.push(0);
+			}
+
+			// loop through every segment
+			for (var segmentI=0; segmentI<segmentRow.length; segmentI++) {
+				var segment = segmentRow[segmentI];
+
+				// find the segment's top coordinate by looking at the max height
+				// of all the columns the segment will be in.
+				segment.top = arrayMax(
+					colHeights.slice(
+						segment.leftCol,
+						segment.rightCol + 1 // make exclusive for slice
+					)
+				);
+
+				// adjust the columns to account for the segment's height
+				for (var colI=segment.leftCol; colI<=segment.rightCol; colI++) {
+					colHeights[colI] = segment.top + segment.outerHeight;
+				}
+			}
+
+			// the tallest column in the row should be the "content height"
+			rowContentHeights.push(arrayMax(colHeights));
+		}
+
+		return rowContentHeights;
+	}
+
+
+	// Build an array of segment arrays, each representing the segments that will
+	// be in a row of the grid, sorted by which event should be closest to the top.
+	function buildSegmentRows(segments) {
+		var rowCnt = getRowCnt();
+		var segmentRows = [];
+		var segmentI;
+		var segment;
+		var rowI;
+
+		// group segments by row
+		for (segmentI=0; segmentI<segments.length; segmentI++) {
+			segment = segments[segmentI];
+			rowI = segment.row;
+			if (segment.element) { // was rendered?
+				if (segmentRows[rowI]) {
+					// already other segments. append to array
+					segmentRows[rowI].push(segment);
+				}
+				else {
+					// first segment in row. create new array
+					segmentRows[rowI] = [ segment ];
 				}
 			}
 		}
-		lazySegBind(segmentContainer, segs, bindDaySeg);
+
+		// sort each row
+		for (rowI=0; rowI<rowCnt; rowI++) {
+			segmentRows[rowI] = sortSegmentRow(
+				segmentRows[rowI] || [] // guarantee an array, even if no segments
+			);
+		}
+
+		return segmentRows;
 	}
-	
-	
-	function daySegCalcHSides(segs) { // also sets seg.key
-		var i;
-		var segCnt = segs.length;
-		var seg;
-		var element;
-		var key, val;
-		var hsideCache = {};
-		// record event horizontal sides
-		for (i=0; i<segCnt; i++) {
-			seg = segs[i];
-			element = seg.element;
-			if (element) {
-				key = seg.key = cssKey(element[0]);
-				val = hsideCache[key];
-				if (val === undefined) {
-					val = hsideCache[key] = hsides(element, true);
+
+
+	// Sort an array of segments according to which segment should appear closest to the top
+	function sortSegmentRow(segments) {
+		var sortedSegments = [];
+
+		// build the subrow array
+		var subrows = buildSegmentSubrows(segments);
+
+		// flatten it
+		for (var i=0; i<subrows.length; i++) {
+			sortedSegments.push.apply(sortedSegments, subrows[i]); // append an array to an array
+		}
+
+		return sortedSegments;
+	}
+
+
+	// Take an array of segments, which are all assumed to be in the same row,
+	// and sort into subrows.
+	function buildSegmentSubrows(segments) {
+
+		// Give preference to elements with certain criteria, so they have
+		// a chance to be closer to the top.
+		segments.sort(segmentCompare);
+
+		var subrows = [];
+		for (var i=0; i<segments.length; i++) {
+			var segment = segments[i];
+
+			// loop through subrows, starting with the topmost, until the segment
+			// doesn't collide with other segments.
+			for (var j=0; j<subrows.length; j++) {
+				if (!isDaySegmentCollision(segment, subrows[j])) {
+					break;
 				}
-				seg.hsides = val;
+			}
+			// `j` now holds the desired subrow index
+			if (subrows[j]) {
+				subrows[j].push(segment);
+			}
+			else {
+				subrows[j] = [ segment ];
 			}
 		}
+
+		return subrows;
 	}
-	
-	
-	function daySegSetWidths(segs) {
-		var i;
-		var segCnt = segs.length;
-		var seg;
-		var element;
-		for (i=0; i<segCnt; i++) {
-			seg = segs[i];
-			element = seg.element;
-			if (element) {
-				element[0].style.width = Math.max(0, seg.outerWidth - seg.hsides) + 'px';
-			}
-		}
-	}
-	
-	
-	function daySegCalcHeights(segs) {
-		var i;
-		var segCnt = segs.length;
-		var seg;
-		var element;
-		var key, val;
-		var vmarginCache = {};
-		// record event heights
-		for (i=0; i<segCnt; i++) {
-			seg = segs[i];
-			element = seg.element;
-			if (element) {
-				key = seg.key; // created in daySegCalcHSides
-				val = vmarginCache[key];
-				if (val === undefined) {
-					val = vmarginCache[key] = vmargins(element);
-				}
-				seg.outerHeight = element[0].offsetHeight + val;
-			}
-		}
-	}
-	
-	
-	function getRowDivs() {
+
+
+	// Return an array of jQuery objects for the placeholder content containers of each row.
+	// The content containers don't actually contain anything, but their dimensions should match
+	// the events that are overlaid on top.
+	function getRowContentElements() {
 		var i;
 		var rowCnt = getRowCnt();
 		var rowDivs = [];
 		for (i=0; i<rowCnt; i++) {
 			rowDivs[i] = allDayRow(i)
-				.find('div.fc-day-content > div'); // optimal selector?
+				.find('div.fc-day-content > div');
 		}
 		return rowDivs;
 	}
-	
-	
-	function getRowTops(rowDivs) {
-		var i;
-		var rowCnt = rowDivs.length;
-		var tops = [];
-		for (i=0; i<rowCnt; i++) {
-			tops[i] = rowDivs[i][0].offsetTop; // !!?? but this means the element needs position:relative if in a table cell!!!!
-		}
-		return tops;
-	}
-	
-	
-	function daySegSetTops(segs, rowTops) { // also triggers eventAfterRender
-		var i;
-		var segCnt = segs.length;
-		var seg;
-		var element;
-		var event;
-		for (i=0; i<segCnt; i++) {
-			seg = segs[i];
-			element = seg.element;
-			if (element) {
-				element[0].style.top = rowTops[seg.row] + (seg.top||0) + 'px';
-				event = seg.event;
-				trigger('eventAfterRender', event, event, element);
+
+
+
+	/* Mouse Handlers
+	---------------------------------------------------------------------------------------------------*/
+	// TODO: better documentation!
+
+
+	function attachHandlers(segments, modifiedEventId) {
+		var segmentContainer = getDaySegmentContainer();
+
+		segmentElementEach(segments, function(segment, element, i) {
+			var event = segment.event;
+			if (event._id === modifiedEventId) {
+				bindDaySeg(event, element, segment);
+			}else{
+				element[0]._fci = i; // for lazySegBind
 			}
-		}
+		});
+
+		lazySegBind(segmentContainer, segments, bindDaySeg);
 	}
+
+
+	function bindDaySeg(event, eventElement, segment) {
+
+		if (isEventDraggable(event)) {
+			t.draggableDayEvent(event, eventElement, segment); // use `t` so subclasses can override
+		}
+
+		if (
+			segment.isEnd && // only allow resizing on the final segment for an event
+			isEventResizable(event)
+		) {
+			t.resizableDayEvent(event, eventElement, segment); // use `t` so subclasses can override
+		}
+
+		// attach all other handlers.
+		// needs to be after, because resizableDayEvent might stopImmediatePropagation on click
+		eventElementHandlers(event, eventElement);
+	}
+
 	
+	function draggableDayEvent(event, eventElement) {
+		var hoverListener = getHoverListener();
+		var dayDelta;
+		eventElement.draggable({
+			zIndex: 9,
+			delay: 50,
+			opacity: opt('dragOpacity'),
+			revertDuration: opt('dragRevertDuration'),
+			start: function(ev, ui) {
+				trigger('eventDragStart', eventElement, event, ev, ui);
+				hideEvents(event, eventElement);
+				hoverListener.start(function(cell, origCell, rowDelta, colDelta) {
+					eventElement.draggable('option', 'revert', !cell || !rowDelta && !colDelta);
+					clearOverlays();
+					if (cell) {
+						var origDate = cellToDate(origCell);
+						var date = cellToDate(cell);
+						dayDelta = dayDiff(date, origDate);
+						renderDayOverlay(
+							addDays(cloneDate(event.start), dayDelta),
+							addDays(exclEndDay(event), dayDelta)
+						);
+					}else{
+						dayDelta = 0;
+					}
+				}, ev, 'drag');
+			},
+			stop: function(ev, ui) {
+				hoverListener.stop();
+				clearOverlays();
+				trigger('eventDragStop', eventElement, event, ev, ui);
+				if (dayDelta) {
+					eventDrop(this, event, dayDelta, 0, event.allDay, ev, ui);
+				}else{
+					eventElement.css('filter', ''); // clear IE opacity side-effects
+					showEvents(event, eventElement);
+				}
+			}
+		});
+	}
+
 	
-	
-	/* Resizing
-	-----------------------------------------------------------------------------------*/
-	
-	
-	function resizableDayEvent(event, element, seg) {
-		var rtl = opt('isRTL');
-		var direction = rtl ? 'w' : 'e';
+	function resizableDayEvent(event, element, segment) {
+		var isRTL = opt('isRTL');
+		var direction = isRTL ? 'w' : 'e';
 		var handle = element.find('.ui-resizable-' + direction); // TODO: stop using this class because we aren't using jqui for this
 		var isResizing = false;
 		
@@ -399,16 +634,14 @@ function DayEventRenderer() {
 				return; // needs to be left mouse button
 			}
 			isResizing = true;
-			var hoverListener = t.getHoverListener();
+			var hoverListener = getHoverListener();
 			var rowCnt = getRowCnt();
 			var colCnt = getColCnt();
-			var dis = rtl ? -1 : 1;
-			var dit = rtl ? colCnt-1 : 0;
 			var elementTop = element.css('top');
 			var dayDelta;
 			var helpers;
 			var eventCopy = $.extend({}, event);
-			var minCell = dateCell(event.start);
+			var minCellOffset = dayOffsetToCellOffset( dateToDayOffset(event.start) );
 			clearSelection();
 			$('body')
 				.css('cursor', direction + '-resize')
@@ -416,30 +649,32 @@ function DayEventRenderer() {
 			trigger('eventResizeStart', this, event, ev);
 			hoverListener.start(function(cell, origCell) {
 				if (cell) {
-					var r = Math.max(minCell.row, cell.row);
-					var c = cell.col;
-					if (rowCnt == 1) {
-						r = 0; // hack for all-day area in agenda views
-					}
-					if (r == minCell.row) {
-						if (rtl) {
-							c = Math.min(minCell.col, c);
-						}else{
-							c = Math.max(minCell.col, c);
-						}
-					}
-					dayDelta = (r*7 + c*dis+dit) - (origCell.row*7 + origCell.col*dis+dit);
-					var newEnd = addDays(eventEnd(event), dayDelta, true);
+
+					var origCellOffset = cellToCellOffset(origCell);
+					var cellOffset = cellToCellOffset(cell);
+
+					// don't let resizing move earlier than start date cell
+					cellOffset = Math.max(cellOffset, minCellOffset);
+
+					dayDelta =
+						cellOffsetToDayOffset(cellOffset) -
+						cellOffsetToDayOffset(origCellOffset);
+
 					if (dayDelta) {
-						eventCopy.end = newEnd;
+						eventCopy.end = addDays(eventEnd(event), dayDelta, true);
 						var oldHelpers = helpers;
-						helpers = renderTempDaySegs(compileDaySegs([eventCopy]), seg.row, elementTop);
+
+						helpers = renderTempDayEvent(eventCopy, segment.row, elementTop);
+						helpers = $(helpers); // turn array into a jQuery object
+
 						helpers.find('*').css('cursor', direction + '-resize');
 						if (oldHelpers) {
 							oldHelpers.remove();
 						}
+
 						hideEvents(event);
-					}else{
+					}
+					else {
 						if (helpers) {
 							showEvents(event);
 							helpers.remove();
@@ -447,7 +682,12 @@ function DayEventRenderer() {
 						}
 					}
 					clearOverlays();
-					renderDayOverlay(event.start, addDays(cloneDate(newEnd), 1)); // coordinate grid already rebuild at hoverListener.start
+					renderDayOverlay( // coordinate grid already rebuilt with hoverListener.start()
+						event.start,
+						addDays( exclEndDay(event), dayDelta )
+						// TODO: instead of calling renderDayOverlay() with dates,
+						// call _renderDayOverlay (or whatever) with cell offsets.
+					);
 				}
 			}, ev);
 			
@@ -466,9 +706,38 @@ function DayEventRenderer() {
 					isResizing = false;
 				},0);
 			}
-			
 		});
 	}
 	
 
 }
+
+
+
+/* Generalized Segment Utilities
+-------------------------------------------------------------------------------------------------*/
+
+
+function isDaySegmentCollision(segment, otherSegments) {
+	for (var i=0; i<otherSegments.length; i++) {
+		var otherSegment = otherSegments[i];
+		if (
+			otherSegment.leftCol <= segment.rightCol &&
+			otherSegment.rightCol >= segment.leftCol
+		) {
+			return true;
+		}
+	}
+	return false;
+}
+
+
+function segmentElementEach(segments, callback) { // TODO: use in AgendaView?
+	for (var i=0; i<segments.length; i++) {
+		var segment = segments[i];
+		var element = segment.element;
+		if (element) {
+			callback(segment, element, i);
+		}
+	}
+}
diff --git a/src/common/SelectionManager.js b/src/common/SelectionManager.js
index 9231805..d7b4e97 100644
--- a/src/common/SelectionManager.js
+++ b/src/common/SelectionManager.js
@@ -65,18 +65,18 @@ function SelectionManager() {
 	
 	
 	function daySelectionMousedown(ev) { // not really a generic manager method, oh well
-		var cellDate = t.cellDate;
-		var cellIsAllDay = t.cellIsAllDay;
+		var cellToDate = t.cellToDate;
+		var getIsCellAllDay = t.getIsCellAllDay;
 		var hoverListener = t.getHoverListener();
 		var reportDayClick = t.reportDayClick; // this is hacky and sort of weird
 		if (ev.which == 1 && opt('selectable')) { // which==1 means left mouse button
 			unselect(ev);
 			var _mousedownElement = this;
 			var dates;
-			hoverListener.start(function(cell, origCell) { // TODO: maybe put cellDate/cellIsAllDay info in cell
+			hoverListener.start(function(cell, origCell) { // TODO: maybe put cellToDate/getIsCellAllDay info in cell
 				clearSelection();
-				if (cell && cellIsAllDay(cell)) {
-					dates = [ cellDate(origCell), cellDate(cell) ].sort(cmp);
+				if (cell && getIsCellAllDay(cell)) {
+					dates = [ cellToDate(origCell), cellToDate(cell) ].sort(dateCompare);
 					renderSelection(dates[0], dates[1], true);
 				}else{
 					dates = null;
diff --git a/src/common/View.js b/src/common/View.js
index e245acf..7df978a 100644
--- a/src/common/View.js
+++ b/src/common/View.js
@@ -10,7 +10,6 @@ function View(element, calendar, viewName) {
 	t.name = viewName;
 	t.opt = opt;
 	t.trigger = trigger;
-	//t.setOverflowHidden = setOverflowHidden;
 	t.isEventDraggable = isEventDraggable;
 	t.isEventResizable = isEventResizable;
 	t.reportEvents = reportEvents;
@@ -43,7 +42,7 @@ function View(element, calendar, viewName) {
 	
 	function opt(name, viewNameOverride) {
 		var v = options[name];
-		if (typeof v == 'object') {
+		if ($.isPlainObject(v)) {
 			return smartProperty(v, viewNameOverride || viewName);
 		}
 		return v;
@@ -57,13 +56,11 @@ function View(element, calendar, viewName) {
 		);
 	}
 	
-	
-	/*
-	function setOverflowHidden(bool) {
-		element.css('overflow', bool ? 'hidden' : '');
-	}
-	*/
-	
+
+
+	/* Event Editable Boolean Calculations
+
+	------------------------------------------------------------------------------*/
 	
 	function isEventDraggable(event) {
 		return isEventEditable(event) && !opt('disableDragging');
@@ -249,6 +246,297 @@ function View(element, calendar, viewName) {
 			normalizeEvent(e, options);
 		}
 	}
+
+
+
+	// ====================================================================================================
+	// Utilities for day "cells"
+	// ====================================================================================================
+	// The "basic" views are completely made up of day cells.
+	// The "agenda" views have day cells at the top "all day" slot.
+	// This was the obvious common place to put these utilities, but they should be abstracted out into
+	// a more meaningful class (like DayEventRenderer).
+	// ====================================================================================================
+
+
+	// For determining how a given "cell" translates into a "date":
+	//
+	// 1. Convert the "cell" (row and column) into a "cell offset" (the # of the cell, cronologically from the first).
+	//    Keep in mind that column indices are inverted with isRTL. This is taken into account.
+	//
+	// 2. Convert the "cell offset" to a "day offset" (the # of days since the first visible day in the view).
+	//
+	// 3. Convert the "day offset" into a "date" (a JavaScript Date object).
+	//
+	// The reverse transformation happens when transforming a date into a cell.
+
+
+	// exports
+	t.isHiddenDay = isHiddenDay;
+	t.skipHiddenDays = skipHiddenDays;
+	t.getCellsPerWeek = getCellsPerWeek;
+	t.dateToCell = dateToCell;
+	t.dateToDayOffset = dateToDayOffset;
+	t.dayOffsetToCellOffset = dayOffsetToCellOffset;
+	t.cellOffsetToCell = cellOffsetToCell;
+	t.cellToDate = cellToDate;
+	t.cellToCellOffset = cellToCellOffset;
+	t.cellOffsetToDayOffset = cellOffsetToDayOffset;
+	t.dayOffsetToDate = dayOffsetToDate;
+	t.rangeToSegments = rangeToSegments;
+	t.segmentCompare = segmentCompare;
+
+
+	// internals
+	var hiddenDays = opt('hiddenDays') || []; // array of day-of-week indices that are hidden
+	var isHiddenDayHash = []; // is the day-of-week hidden? (hash with day-of-week-index -> bool)
+	var cellsPerWeek;
+	var dayToCellMap = []; // hash from dayIndex -> cellIndex, for one week
+	var cellToDayMap = []; // hash from cellIndex -> dayIndex, for one week
+	var isRTL = opt('isRTL');
+
+
+	// initialize important internal variables
+	(function() {
+
+		if (opt('weekends') === false) {
+			hiddenDays.push(0, 6); // 0=sunday, 6=saturday
+		}
+
+		// Loop through a hypothetical week and determine which
+		// days-of-week are hidden. Record in both hashes (one is the reverse of the other).
+		for (var dayIndex=0, cellIndex=0; dayIndex<7; dayIndex++) {
+			dayToCellMap[dayIndex] = cellIndex;
+			isHiddenDayHash[dayIndex] = $.inArray(dayIndex, hiddenDays) != -1;
+			if (!isHiddenDayHash[dayIndex]) {
+				cellToDayMap[cellIndex] = dayIndex;
+				cellIndex++;
+			}
+		}
+
+		cellsPerWeek = cellIndex;
+		if (!cellsPerWeek) {
+			throw 'invalid hiddenDays'; // all days were hidden? bad.
+		}
+
+	})();
+
+
+	// Is the current day hidden?
+	// `day` is a day-of-week index (0-6), or a Date object
+	function isHiddenDay(day) {
+		if (typeof day == 'object') {
+			day = day.getDay();
+		}
+		return isHiddenDayHash[day];
+	}
+
+
+	function getCellsPerWeek() {
+		return cellsPerWeek;
+	}
+
+
+	// Keep incrementing the current day until it is no longer a hidden day.
+	// If the initial value of `date` is not a hidden day, don't do anything.
+	// Pass `isExclusive` as `true` if you are dealing with an end date.
+	// `inc` defaults to `1` (increment one day forward each time)
+	function skipHiddenDays(date, inc, isExclusive) {
+		inc = inc || 1;
+		while (
+			isHiddenDayHash[ ( date.getDay() + (isExclusive ? inc : 0) + 7 ) % 7 ]
+		) {
+			addDays(date, inc);
+		}
+	}
+
+
+	//
+	// TRANSFORMATIONS: cell -> cell offset -> day offset -> date
+	//
+
+	// cell -> date (combines all transformations)
+	// Possible arguments:
+	// - row, col
+	// - { row:#, col: # }
+	function cellToDate() {
+		var cellOffset = cellToCellOffset.apply(null, arguments);
+		var dayOffset = cellOffsetToDayOffset(cellOffset);
+		var date = dayOffsetToDate(dayOffset);
+		return date;
+	}
+
+	// cell -> cell offset
+	// Possible arguments:
+	// - row, col
+	// - { row:#, col:# }
+	function cellToCellOffset(row, col) {
+		var colCnt = t.getColCnt();
+
+		// rtl variables. wish we could pre-populate these. but where?
+		var dis = isRTL ? -1 : 1;
+		var dit = isRTL ? colCnt - 1 : 0;
+
+		if (typeof row == 'object') {
+			col = row.col;
+			row = row.row;
+		}
+		var cellOffset = row * colCnt + (col * dis + dit); // column, adjusted for RTL (dis & dit)
+
+		return cellOffset;
+	}
+
+	// cell offset -> day offset
+	function cellOffsetToDayOffset(cellOffset) {
+		var day0 = t.visStart.getDay(); // first date's day of week
+		cellOffset += dayToCellMap[day0]; // normlize cellOffset to beginning-of-week
+		return Math.floor(cellOffset / cellsPerWeek) * 7 // # of days from full weeks
+			+ cellToDayMap[ // # of days from partial last week
+				(cellOffset % cellsPerWeek + cellsPerWeek) % cellsPerWeek // crazy math to handle negative cellOffsets
+			]
+			- day0; // adjustment for beginning-of-week normalization
+	}
+
+	// day offset -> date (JavaScript Date object)
+	function dayOffsetToDate(dayOffset) {
+		var date = cloneDate(t.visStart);
+		addDays(date, dayOffset);
+		return date;
+	}
+
+
+	//
+	// TRANSFORMATIONS: date -> day offset -> cell offset -> cell
+	//
+
+	// date -> cell (combines all transformations)
+	function dateToCell(date) {
+		var dayOffset = dateToDayOffset(date);
+		var cellOffset = dayOffsetToCellOffset(dayOffset);
+		var cell = cellOffsetToCell(cellOffset);
+		return cell;
+	}
+
+	// date -> day offset
+	function dateToDayOffset(date) {
+		return dayDiff(date, t.visStart);
+	}
+
+	// day offset -> cell offset
+	function dayOffsetToCellOffset(dayOffset) {
+		var day0 = t.visStart.getDay(); // first date's day of week
+		dayOffset += day0; // normalize dayOffset to beginning-of-week
+		return Math.floor(dayOffset / 7) * cellsPerWeek // # of cells from full weeks
+			+ dayToCellMap[ // # of cells from partial last week
+				(dayOffset % 7 + 7) % 7 // crazy math to handle negative dayOffsets
+			]
+			- dayToCellMap[day0]; // adjustment for beginning-of-week normalization
+	}
+
+	// cell offset -> cell (object with row & col keys)
+	function cellOffsetToCell(cellOffset) {
+		var colCnt = t.getColCnt();
+
+		// rtl variables. wish we could pre-populate these. but where?
+		var dis = isRTL ? -1 : 1;
+		var dit = isRTL ? colCnt - 1 : 0;
+
+		var row = Math.floor(cellOffset / colCnt);
+		var col = ((cellOffset % colCnt + colCnt) % colCnt) * dis + dit; // column, adjusted for RTL (dis & dit)
+		return {
+			row: row,
+			col: col
+		};
+	}
+
+
+	//
+	// Converts a date range into an array of segment objects.
+	// "Segments" are horizontal stretches of time, sliced up by row.
+	// A segment object has the following properties:
+	// - row
+	// - cols
+	// - isStart
+	// - isEnd
+	//
+	function rangeToSegments(startDate, endDate) {
+		var rowCnt = t.getRowCnt();
+		var colCnt = t.getColCnt();
+		var segments = []; // array of segments to return
+
+		// day offset for given date range
+		var rangeDayOffsetStart = dateToDayOffset(startDate);
+		var rangeDayOffsetEnd = dateToDayOffset(endDate); // exclusive
+
+		// first and last cell offset for the given date range
+		// "last" implies inclusivity
+		var rangeCellOffsetFirst = dayOffsetToCellOffset(rangeDayOffsetStart);
+		var rangeCellOffsetLast = dayOffsetToCellOffset(rangeDayOffsetEnd) - 1;
+
+		// loop through all the rows in the view
+		for (var row=0; row<rowCnt; row++) {
+
+			// first and last cell offset for the row
+			var rowCellOffsetFirst = row * colCnt;
+			var rowCellOffsetLast = rowCellOffsetFirst + colCnt - 1;
+
+			// get the segment's cell offsets by constraining the range's cell offsets to the bounds of the row
+			var segmentCellOffsetFirst = Math.max(rangeCellOffsetFirst, rowCellOffsetFirst);
+			var segmentCellOffsetLast = Math.min(rangeCellOffsetLast, rowCellOffsetLast);
+
+			// make sure segment's offsets are valid and in view
+			if (segmentCellOffsetFirst <= segmentCellOffsetLast) {
+
+				// translate to cells
+				var segmentCellFirst = cellOffsetToCell(segmentCellOffsetFirst);
+				var segmentCellLast = cellOffsetToCell(segmentCellOffsetLast);
+
+				// view might be RTL, so order by leftmost column
+				var cols = [ segmentCellFirst.col, segmentCellLast.col ].sort();
+
+				// Determine if segment's first/last cell is the beginning/end of the date range.
+				// We need to compare "day offset" because "cell offsets" are often ambiguous and
+				// can translate to multiple days, and an edge case reveals itself when we the
+				// range's first cell is hidden (we don't want isStart to be true).
+				var isStart = cellOffsetToDayOffset(segmentCellOffsetFirst) == rangeDayOffsetStart;
+				var isEnd = cellOffsetToDayOffset(segmentCellOffsetLast) + 1 == rangeDayOffsetEnd; // +1 for comparing exclusively
+
+				segments.push({
+					row: row,
+					leftCol: cols[0],
+					rightCol: cols[1],
+					isStart: isStart,
+					isEnd: isEnd
+				});
+			}
+		}
+
+		return segments;
+	}
+
+
+	// Compare two event segments and determine which one takes priority (ex: rendered topmost/leftmost)
+	// NOTE: only works with segments that have `event` properties!
+	//
+	// Returns a negative value if `a` should be first.
+	// Returns a positive value of `b` should be first.
+	function segmentCompare(a, b) {
+		return _segmentCompare(a, b) // sort by dimension
+			|| (a.event.start - b.event.start) // if a tie, sort by event start date
+			|| (a.event.title || "").localeCompare(b.event.title) // if a tie, sort by event title
+	}
+
+	// compare dimensions
+	// NOTE: this is not modular! depends on subclass-specific segment schemas
+	function _segmentCompare(a, b) {
+		if ('msLength' in a) {
+			// segment generated by AgendaEventRenderer
+			return b.msLength - a.msLength; // put taller events first
+		}
+		// segment generated by DayEventRenderer
+		return (b.rightCol - b.leftCol) - (a.rightCol - a.leftCol) // put wider events first
+			|| b.event.allDay - a.event.allDay; // if tie, put all-day events first (booleans cast to 0/1)
+	}
 	
 
 }
diff --git a/src/date_util.js b/src/date_util.js
index aea326f..e21bda1 100644
--- a/src/date_util.js
+++ b/src/date_util.js
@@ -103,15 +103,6 @@ function zeroDate() { // returns a Date with time 00:00:00 and dateOfMonth=1
 }
 
 
-function skipWeekend(date, inc, excl) {
-	inc = inc || 1;
-	while (!date.getDay() || (excl && date.getDay()==1 || !excl && date.getDay()==6)) {
-		addDays(date, inc);
-	}
-	return date;
-}
-
-
 function dayDiff(d1, d2) { // d1 - d2
 	return Math.round((cloneDate(d1, true) - cloneDate(d2, true)) / DAY_MS);
 }
@@ -367,8 +358,8 @@ fc.dateFormatters = dateFormatters;
 /* thanks jQuery UI (https://github.com/jquery/jquery-ui/blob/master/ui/jquery.ui.datepicker.js)
  * 
  * Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
- * @param  date  Date - the date to get the week for
- * @return  number - the number of the week within the year that contains this date
+ * `date` - the date to get the week for
+ * `number` - the number of the week within the year that contains this date
  */
 function iso8601Week(date) {
 	var time;
diff --git a/src/util.js b/src/util.js
index de44559..813d89f 100644
--- a/src/util.js
+++ b/src/util.js
@@ -18,95 +18,7 @@ function exclEndDay(event) {
 function _exclEndDay(end, allDay) {
 	end = cloneDate(end);
 	return allDay || end.getHours() || end.getMinutes() ? addDays(end, 1) : clearTime(end);
-}
-
-
-function segCmp(a, b) {
-	return (b.msLength - a.msLength) * 100 + (a.event.start - b.event.start);
-}
-
-
-function segsCollide(seg1, seg2) {
-	return seg1.end > seg2.start && seg1.start < seg2.end;
-}
-
-
-
-/* Event Sorting
------------------------------------------------------------------------------*/
-
-
-// event rendering utilities
-function sliceSegs(events, visEventEnds, start, end) {
-	var segs = [],
-		i, len=events.length, event,
-		eventStart, eventEnd,
-		segStart, segEnd,
-		isStart, isEnd;
-	for (i=0; i<len; i++) {
-		event = events[i];
-		eventStart = event.start;
-		eventEnd = visEventEnds[i];
-		if (eventEnd > start && eventStart < end) {
-			if (eventStart < start) {
-				segStart = cloneDate(start);
-				isStart = false;
-			}else{
-				segStart = eventStart;
-				isStart = true;
-			}
-			if (eventEnd > end) {
-				segEnd = cloneDate(end);
-				isEnd = false;
-			}else{
-				segEnd = eventEnd;
-				isEnd = true;
-			}
-			segs.push({
-				event: event,
-				start: segStart,
-				end: segEnd,
-				isStart: isStart,
-				isEnd: isEnd,
-				msLength: segEnd - segStart
-			});
-		}
-	}
-	return segs.sort(segCmp);
-}
-
-
-// event rendering calculation utilities
-function stackSegs(segs) {
-	var levels = [],
-		i, len = segs.length, seg,
-		j, collide, k;
-	for (i=0; i<len; i++) {
-		seg = segs[i];
-		j = 0; // the level index where seg should belong
-		while (true) {
-			collide = false;
-			if (levels[j]) {
-				for (k=0; k<levels[j].length; k++) {
-					if (segsCollide(levels[j][k], seg)) {
-						collide = true;
-						break;
-					}
-				}
-			}
-			if (collide) {
-				j++;
-			}else{
-				break;
-			}
-		}
-		if (levels[j]) {
-			levels[j].push(seg);
-		}else{
-			levels[j] = [seg];
-		}
-	}
-	return levels;
+	// why don't we check for seconds/ms too?
 }
 
 
@@ -222,7 +134,7 @@ function setMinHeight(element, height) {
 function noop() { }
 
 
-function cmp(a, b) {
+function dateCompare(a, b) {
 	return a - b;
 }
 
@@ -263,11 +175,6 @@ function htmlEscape(s) {
 }
 
 
-function cssKey(_element) {
-	return _element.id + '/' + _element.className + '/' + _element.style.cssText.replace(/(^|;)\s*(top|left|width|height)\s*:[^;]*/ig, '');
-}
-
-
 function disableTextSelection(element) {
 	element
 		.attr('unselectable', 'on')