SF Bug# 1017270

This started out as a "simple" bug, and ended up being a complete rewrite of overlapping_events. The changes to template.php are to fix a minor rendering bug that was part of the overlap issue, and the changes to ical_parser are because the api to checkOverlap changed.

3 files changed, 267 insertions, 158 deletions

diff --git a/functions/ical_parser.php b/functions/ical_parser.php
index 8872461..5b1ddc0 100644
--- a/functions/ical_parser.php
+++ b/functions/ical_parser.php
@@ -328,8 +328,8 @@ foreach ($cal_filelist as $filename) {
 								$display_end_tmp = $end_time;
 							}
 							
-							$nbrOfOverlaps = checkOverlap($start_date_tmp, $start_time_tmp, $end_time_tmp, $uid);
-							$master_array[$start_date_tmp][$time_tmp][$uid] = array ('event_start' => $start_time_tmp, 'event_end' => $end_time_tmp, 'display_end' => $display_end_tmp, 'start_unixtime' => $start_unixtime, 'end_unixtime' => $end_unixtime, 'event_text' => $summary, 'event_length' => $length, 'event_overlap' => $nbrOfOverlaps, 'description' => $description, 'status' => $status, 'class' => $class, 'spans_day' => true, 'location' => $location, 'organizer' => serialize($organizer), 'attendee' => serialize($attendee), 'calnumber' => $calnumber, 'calname' => $actual_calname, 'url' => $url );
+							$master_array[$start_date_tmp][$time_tmp][$uid] = array ('event_start' => $start_time_tmp, 'event_end' => $end_time_tmp, 'display_end' => $display_end_tmp, 'start_unixtime' => $start_unixtime, 'end_unixtime' => $end_unixtime, 'event_text' => $summary, 'event_length' => $length, 'event_overlap' => 0, 'description' => $description, 'status' => $status, 'class' => $class, 'spans_day' => true, 'location' => $location, 'organizer' => serialize($organizer), 'attendee' => serialize($attendee), 'calnumber' => $calnumber, 'calname' => $actual_calname, 'url' => $url );
+							checkOverlap($start_date_tmp, $time_tmp, $uid);
 							$start_tmp = strtotime('+1 day',$start_tmp);
 						}
 						if (!$write_processed) $master_array[$start_date][($hour.$minute)][$uid]['exception'] = true;
@@ -343,8 +343,8 @@ foreach ($cal_filelist as $filename) {
 					
 						// This if statement should prevent writing of an excluded date if its the first recurrance - CL
 						if (!in_array($start_date, $except_dates)) {
-							$nbrOfOverlaps = checkOverlap($start_date, $start_time, $end_time_tmp1, $uid);
-							$master_array[($start_date)][($hour.$minute)][$uid] = array ('event_start' => $start_time, 'event_end' => $end_time_tmp1, 'display_end' => $display_end_tmp, 'start_unixtime' => $start_unixtime, 'end_unixtime' => $end_unixtime, 'event_text' => $summary, 'event_length' => $length, 'event_overlap' => $nbrOfOverlaps, 'description' => $description, 'status' => $status, 'class' => $class, 'spans_day' => false, 'location' => $location, 'organizer' => serialize($organizer), 'attendee' => serialize($attendee), 'calnumber' => $calnumber, 'calname' => $actual_calname, 'url' => $url );
+							$master_array[($start_date)][($hour.$minute)][$uid] = array ('event_start' => $start_time, 'event_end' => $end_time_tmp1, 'display_end' => $display_end_tmp, 'start_unixtime' => $start_unixtime, 'end_unixtime' => $end_unixtime, 'event_text' => $summary, 'event_length' => $length, 'event_overlap' => 0, 'description' => $description, 'status' => $status, 'class' => $class, 'spans_day' => false, 'location' => $location, 'organizer' => serialize($organizer), 'attendee' => serialize($attendee), 'calnumber' => $calnumber, 'calname' => $actual_calname, 'url' => $url );
+							checkOverlap($start_date, ($hour.$minute), $uid);
 							if (!$write_processed) $master_array[($start_date)][($hour.$minute)][$uid]['exception'] = true;
 						}
 					}
@@ -706,8 +706,8 @@ foreach ($cal_filelist as $filename) {
 															// Let's double check the until to not write past it
 															$until_check = $start_date_tmp.$time_tmp.'00';
 															if ($abs_until > $until_check) {
-																$nbrOfOverlaps = checkOverlap($start_date_tmp, $start_time_tmp, $end_time_tmp, $uid);
-																$master_array[$start_date_tmp][$time_tmp][$uid] = array ('event_start' => $start_time_tmp, 'event_end' => $end_time_tmp, 'display_end' => $display_end_tmp, 'start_unixtime' => $start_unixtime_tmp, 'end_unixtime' => $end_unixtime_tmp, 'event_text' => $summary, 'event_length' => $length, 'event_overlap' => $nbrOfOverlaps, 'description' => $description, 'status' => $status, 'class' => $class, 'spans_day' => true, 'location' => $location, 'organizer' => serialize($organizer), 'attendee' => serialize($attendee), 'calnumber' => $calnumber, 'calname' => $actual_calname, 'url' => $url) ;
+																$master_array[$start_date_tmp][$time_tmp][$uid] = array ('event_start' => $start_time_tmp, 'event_end' => $end_time_tmp, 'display_end' => $display_end_tmp, 'start_unixtime' => $start_unixtime_tmp, 'end_unixtime' => $end_unixtime_tmp, 'event_text' => $summary, 'event_length' => $length, 'event_overlap' => 0, 'description' => $description, 'status' => $status, 'class' => $class, 'spans_day' => true, 'location' => $location, 'organizer' => serialize($organizer), 'attendee' => serialize($attendee), 'calnumber' => $calnumber, 'calname' => $actual_calname, 'url' => $url) ;
+																checkOverlap($start_date_tmp, $time_tmp, $uid);
 															}
 															$start_tmp = strtotime('+1 day',$start_tmp);
 														}
@@ -722,8 +722,8 @@ foreach ($cal_filelist as $filename) {
 														// Let's double check the until to not write past it
 														$until_check = $recur_data_date.$hour.$minute.'00';
 														if ($abs_until > $until_check) {
-															$nbrOfOverlaps = checkOverlap($recur_data_date, $start_time, $end_time_tmp1, $uid);
-															$master_array[($recur_data_date)][($hour.$minute)][$uid] = array ('event_start' => $start_time, 'event_end' => $end_time_tmp1, 'display_end' => $display_end_tmp, 'start_unixtime' => $start_unixtime_tmp, 'end_unixtime' => $end_unixtime_tmp, 'event_text' => $summary, 'event_length' => $length, 'event_overlap' => $nbrOfOverlaps, 'description' => $description, 'status' => $status, 'class' => $class, 'spans_day' => false, 'location' => $location, 'organizer' => serialize($organizer), 'attendee' => serialize($attendee), 'calnumber' => $calnumber, 'calname' => $actual_calname, 'url' => $url);
+															$master_array[($recur_data_date)][($hour.$minute)][$uid] = array ('event_start' => $start_time, 'event_end' => $end_time_tmp1, 'display_end' => $display_end_tmp, 'start_unixtime' => $start_unixtime_tmp, 'end_unixtime' => $end_unixtime_tmp, 'event_text' => $summary, 'event_length' => $length, 'event_overlap' => 0, 'description' => $description, 'status' => $status, 'class' => $class, 'spans_day' => false, 'location' => $location, 'organizer' => serialize($organizer), 'attendee' => serialize($attendee), 'calnumber' => $calnumber, 'calname' => $actual_calname, 'url' => $url);
+															checkOverlap($recur_data_date, ($hour.$minute), $uid);
 														}
 													}
 												}
@@ -753,7 +753,7 @@ foreach ($cal_filelist as $filename) {
 				}
 				
 			   // Clear event data now that it's been saved.
-			   unset($start_time, $start_time_tmp, $end_time, $end_time_tmp, $start_unixtime, $start_unixtime_tmp, $end_unixtime, $end_unixtime_tmp, $summary, $length, $nbrOfOverlaps, $description, $status, $class, $location, $organizer, $attendee);
+			   unset($start_time, $start_time_tmp, $end_time, $end_time_tmp, $start_unixtime, $start_unixtime_tmp, $end_unixtime, $end_unixtime_tmp, $summary, $length, $description, $status, $class, $location, $organizer, $attendee);
 
 				break;
 			case 'END:VTODO':
diff --git a/functions/overlapping_events.php b/functions/overlapping_events.php
index 659a0cb..d5bcb9f 100644
--- a/functions/overlapping_events.php
+++ b/functions/overlapping_events.php
@@ -11,180 +11,263 @@ function kgv($a, $b) {
 	return $x;
 }
 
+// merge a given range into $ol_ranges. Returns the merged $ol_ranges.
+// if count = -2, treat as a "delete" call (for removeOverlap)
+// Why -2? That way, there's less fudging of the math in the code.
+function merge_range($ol_ranges, $start, $end, $count = 0) {
 
-// drei 20020921: function for checking and counting overlapping events
-// drei 20020212: added parameter uid to function call
-function checkOverlap($ol_start_date, $ol_start_time, $ol_end_time, $ol_uid) {
+	foreach ($ol_ranges as $loop_range_key => $loop_range) {
+		
+		if ($start < $end) {
+			// handle ranges between $start and $loop_range['start']
+			if ($start < $loop_range['start']) {
+				$new_ol_ranges[] = array('count' => $count, 'start' => $start, 'end' => min($loop_range['start'], $end));
+				$start = $loop_range['start'];
+			}
+
+			// $start is always >= $loop_range['start'] at this point.
+			// handles ranges between $loop_range['start'] and $loop_range['end']
+			if ($loop_range['start'] < $end && $start < $loop_range['end']) {
+				// handles ranges between $loop_range['start'] and $start
+				if ($loop_range['start'] < $start) {
+					$new_ol_ranges[] = array('count' => $loop_range['count'], 'start' => $loop_range['start'], 'end' => $start);
+				}
+				// handles ranges between $start and $end (where they're between $loop_range['start'] and $loop_range['end'])
+				$new_count = $loop_range['count'] + $count + 1;
+				if ($new_count >= 0) {
+					$new_ol_ranges[] = array('count' => $new_count, 'start' => $start, 'end' => min($loop_range['end'], $end));
+				}
+				// handles ranges between $end and $loop_range['end']
+				if ($loop_range['end'] > $end) {
+					$new_ol_ranges[] = array('count' => $loop_range['count'], 'start' => $end, 'end' => $loop_range['end']);
+				}
+				$start = $loop_range['end'];
+			} else {
+				$new_ol_ranges[] = $loop_range;
+			}
+		} else {
+			$new_ol_ranges[] = $loop_range;
+		}
+	}
+
+	// Catches anything left over.
+	if ($start < $end) {
+		$new_ol_ranges[] = array('count' => $count, 'start' => $start, 'end' => $end);
+	}
+
+	return $new_ol_ranges;
+}
+
+// Finds the highest value of 'count' in $ol_ranges
+function find_max_overlap($ol_ranges) {
+
+	$count = 0;
+	foreach ($ol_ranges as $loop_range) {
+		if ($count < $loop_range['count'])
+			$count = $loop_range['count'];
+	}
+
+	return $count;
+}
+
+// Merges overlapping blocks
+function flatten_ol_blocks($event_date, $ol_blocks, $new_block_key) {
+
+	global $master_array;
+
+	// Loop block = each other block in the array, the ones we're merging into new block.
+	// New block = the changed block that caused the flatten_ol_blocks call. Everything gets merged into this.
+	$new_block = $ol_blocks[$new_block_key];
+	reset($ol_blocks);
+	while ($loop_block_array = each($ol_blocks)) {
+		$loop_block_key = $loop_block_array['key'];
+		$loop_block = $loop_block_array['value'];
+		// only compare with other blocks
+		if ($loop_block_key != $new_block_key) {
+			// check if blocks overlap
+			if (($loop_block['blockStart'] < $new_block['blockEnd']) && ($loop_block['blockEnd'] > $new_block['blockStart'])) {
+				// define start and end of merged overlap block
+				if ($new_block['blockStart'] > $loop_block['blockStart']) $ol_blocks[$new_block_key]['blockStart'] = $loop_block['blockStart'];
+				if ($new_block['blockEnd'] < $loop_block['blockEnd']) $ol_blocks[$new_block_key]['blockEnd'] = $loop_block['blockEnd'];
+				$ol_blocks[$new_block_key]['events'] = array_merge($new_block['events'], $loop_block['events']);
+				foreach ($loop_block['overlapRanges'] as $ol_range) {
+					$new_block['overlapRanges'] = merge_range($new_block['overlapRanges'], $ol_range['start'], $ol_range['end'], $ol_range['count']);
+				}
+				$ol_blocks[$new_block_key]['overlapRanges'] = $new_block['overlapRanges'];
+				$ol_blocks[$new_block_key]['maxOverlaps'] = find_max_overlap($new_block['overlapRanges']);
+				foreach ($ol_blocks[$new_block_key]['events'] as $event) {
+					$master_array[$event_date][$event['time']][$event['key']]['event_overlap'] = $ol_blocks[$new_block_key]['maxOverlaps'];
+				}
+				unset($ol_blocks[$loop_block_key]);
+				reset($ol_blocks);
+			}
+		} 
+	}
+
+	return $ol_blocks;
+}
+
+// Builds $overlap_array structure, and updates event_overlap in $master_array for the given events.
+function checkOverlap($event_date, $event_time, $uid) {
 	global $master_array, $overlap_array;
 
-		$drawTimes = drawEventTimes($ol_start_time, $ol_end_time);
-		$newMasterTime = $drawTimes["draw_start"];
-		// if (isset($master_array[($ol_start_date)][($newMasterTime)])) $newMasterEventKey = sizeof($master_array[($ol_start_date)][($newMasterTime)]);
-		// else $newMasterEventKey = 0;
-		
-		$maxOverlaps = 0;
-		$newEventAdded = FALSE;
-		if (isset($overlap_array[($ol_start_date)])) {
-			foreach ($overlap_array[($ol_start_date)] as $loopBlockKey => $loopBlock) {
-				// check for overlap with existing overlap block
-				if (($loopBlock["blockStart"] < $drawTimes["draw_end"]) and ($loopBlock["blockEnd"] > $drawTimes["draw_start"])) {
-					$newOverlapBlock = FALSE;
-					// if necessary adjust start and end times of overlap block
-					if ($loopBlock["blockStart"] > $drawTimes["draw_start"]) $overlap_array[($ol_start_date)][($loopBlockKey)]["blockStart"] = $drawTimes["draw_start"];
-					if ($loopBlock["blockEnd"] < $drawTimes["draw_end"]) $overlap_array[($ol_start_date)][($loopBlockKey)]["blockEnd"] = $drawTimes["draw_end"];
-					// add the new event to the array of events
-					// $overlap_array[($ol_start_date)][($loopBlockKey)]["events"][] = array ("time" => $newMasterTime, "key" => $newMasterEventKey);
-					$overlap_array[($ol_start_date)][($loopBlockKey)]["events"][] = array ("time" => $newMasterTime, "key" => $ol_uid);
-					// check if the adjusted overlap block must be merged with an existing overlap block
-					reset($overlap_array[($ol_start_date)]);
-					do {
-						$compBlockKey = key(current($overlap_array[($ol_start_date)]));
-						// only compare with other blocks
-						if ($compBlockKey != $loopBlockKey) {
-							// check if blocks overlap
-							if (($overlap_array[($ol_start_date)][($compBlockKey)]["blockStart"] < $overlap_array[($ol_start_date)][($loopBlockKey)]["blockEnd"]) and ($overlap_array[($ol_start_date)][($compBlockKey)]["blockEnd"] > $overlap_array[($ol_start_date)][($loopBlockKey)]["blockStart"])) {
-								// define start and end of merged overlap block
-								if ($loopBlock["blockStart"] > $overlap_array[($ol_start_date)][($compBlockKey)]["blockStart"]) $overlap_array[($ol_start_date)][($loopBlockKey)]["blockStart"] = $overlap_array[($ol_start_date)][($compBlockKey)]["blockStart"];
-								if ($loopBlock["blockEnd"] < $overlap_array[($ol_start_date)][($compBlockKey)]["blockEnd"]) $overlap_array[($ol_start_date)][($loopBlockKey)]["blockEnd"] = $overlap_array[($ol_start_date)][($compBlockKey)]["blockEnd"];
-								$overlap_array[($ol_start_date)][($loopBlockKey)]["events"] = array_merge($overlap_array[($ol_start_date)][($loopBlockKey)]["events"],$overlap_array[($ol_start_date)][($compBlockKey)]["events"]);
-								$overlap_array[($ol_start_date)][($loopBlockKey)]["overlapRanges"] = array_merge($overlap_array[($ol_start_date)][($loopBlockKey)]["overlapRanges"],$overlap_array[($ol_start_date)][($compBlockKey)]["overlapRanges"]);
-								unset($overlap_array[($ol_start_date)][($compBlockKey)]);
-								reset($overlap_array[($ol_start_date)]);
-							}
-						} 
-					} while (next($overlap_array[($ol_start_date)]));
-					// insert new event to appropriate overlap range
-
-					$newOverlapRange = TRUE;
-					foreach ($overlap_array[($ol_start_date)][($loopBlockKey)]["overlapRanges"] as $keyOverlap => $overlapRange) {
-						if (($overlapRange["start"] < $drawTimes["draw_end"]) and ($overlapRange["end"] > $drawTimes["draw_start"])) {
-							$overlap_array[($ol_start_date)][($loopBlockKey)]["overlapRanges"][($keyOverlap)]["count"]++;
-							if ($overlapRange["start"] < $drawTimes["draw_start"]) $overlap_array[($ol_start_date)][($loopBlockKey)]["overlapRanges"][($keyOverlap)]["start"] = $drawTimes["draw_start"];
-							if ($overlapRange["end"] > $drawTimes["draw_end"]) $overlap_array[($ol_start_date)][($loopBlockKey)]["overlapRanges"][($keyOverlap)]["end"] = $drawTimes["draw_end"];
-							$newOverlapRange = FALSE;
-		//					break;
-						}
-					}
-					if ($newOverlapRange) {
-						foreach ($loopBlock["events"] as $blockEvents) {
-							$eventDrawTimes = drawEventTimes($master_array[($ol_start_date)][($blockEvents["time"])][($blockEvents["key"])]["event_start"], $master_array[($ol_start_date)][($blockEvents["time"])][($blockEvents["key"])]["event_end"]);
-							if ((isset($eventDrawTimes["draw_start"]) && isset($eventDrawTimes["draw_end"]) && isset($drawTimes["draw_end"]) && isset($drawTimes["draw_start"])) && ($eventDrawTimes["draw_start"] < $drawTimes["draw_end"]) and ($eventDrawTimes["draw_end"] > $drawTimes["draw_start"])) {
-								// define start time of overlap range and overlap block
-								if ($eventDrawTimes["draw_start"] < $drawTimes["draw_start"]) $overlap_start = $drawTimes["draw_start"];
-								else $overlap_start = $eventDrawTimes["draw_start"];
-								// define end time of overlap range and overlap block
-								if ($eventDrawTimes["draw_end"] > $drawTimes["draw_end"]) $overlap_end = $drawTimes["draw_end"];
-								else $overlap_end = $eventDrawTimes["draw_end"];
-								
-								$newOverlapRange2 = TRUE;
-								foreach ($overlap_array[($ol_start_date)][($loopBlockKey)]["overlapRanges"] as $keyOverlap => $overlapRange) {
-									if (($overlapRange["start"] < $overlap_end) and ($overlapRange["end"] > $overlap_start)) {
-										$overlap_array[($ol_start_date)][($loopBlockKey)]["overlapRanges"][($keyOverlap)]["count"]++;
-										if ($overlapRange["start"] < $overlap_start) $overlap_array[($ol_start_date)][($loopBlockKey)]["overlapRanges"][($keyOverlap)]["start"] = $overlap_start;
-										if ($overlapRange["end"] > $overlap_end) $overlap_array[($ol_start_date)][($loopBlockKey)]["overlapRanges"][($keyOverlap)]["end"] = $overlap_end;
-										$newOverlapRange2 = FALSE;
-			//							break;
-									}
-								}
-								if ($newOverlapRange2) {
-									array_push($overlap_array[($ol_start_date)][($loopBlockKey)]["overlapRanges"], array ("count" => 1,"start" => $overlap_start, "end" => $overlap_end));
-								}
-							}
-						}
-					}
-					// determine the maximum overlaps for the current overlap block
-					foreach ($overlap_array[($ol_start_date)][($loopBlockKey)]["overlapRanges"] as $overlapRange) {
-						if ($overlapRange["count"] > $maxOverlaps) $maxOverlaps = $overlapRange["count"];
-					}
-					$overlap_array[($ol_start_date)][($loopBlockKey)]["maxOverlaps"] = $maxOverlaps;
-					foreach ($overlap_array[($ol_start_date)][($loopBlockKey)]["events"] as $updMasterEvent) {
-						//if (($updMasterEvent["time"] != $newMasterTime) or ($updMasterEvent["key"] != $newMasterEventKey)) {
-						if (($updMasterEvent["time"] != $newMasterTime) or ($updMasterEvent["key"] != $ol_uid)) {
-							$master_array[($ol_start_date)][($updMasterEvent["time"])][($updMasterEvent["key"])]["event_overlap"] = $maxOverlaps;
-						}
+	$event = $master_array[$event_date][$event_time][$uid];
+	// Copy out the array - we replace this at the end.
+	$ol_day_array = $overlap_array[$event_date];
+	$drawTimes = drawEventTimes($event['event_start'], $event['event_end']);
+
+	// For a given date,
+	// 	- check to see if the event's already in a block, and if so, add it.
+	//		- make sure the new block doesn't overlap another block, and if so, merge the blocks.
+	// - check that there aren't any events we already passed that we should handle.
+	//		- "flatten" the structure again, merging the blocks.
+
+	// $overlap_array structure:
+	//	array of ($event_dates)
+	//		array of unique overlap blocks (no index) -
+
+	// $overlap_block structure
+	// 'blockStart'    - $start_time of block - earliest $start_time of the events in the block. 
+	//					 Shouldn't be any overlap w/ a different overlap block in that day (as if they overlap, they get merged).
+	// 'blockEnd'      - $end_time of block - latest $end_time of the events in the block.
+	// 'maxOverlaps'   - max number of overlaps for the whole block (highest 'count' in overlapRanges)
+	// 'events'        - array of event "pointers" (no index) - each event in the block.
+	//		'time' - $start_time of event in the block
+	//		'key'  - $uid of event
+	// 'overlapRanges' - array of time ranges + overlap counts (no index) - the specific overlap info.
+	//					 Shouldn't be any overlap w/ the overlap ranges in a given overlap_block - if there is overlap, the block should be split.
+	//		'count' - number of overlaps that time range (can be zero if that range has no overlaps).
+	//		'start' - start_time for the overlap block.
+	//		'end'	- end_time for the overlap block.
+
+	$ol_day_array = $overlap_array[$event_date];
+	// Track if $event has been merged in, so we don't re-add the details to 'event' or 'overlapRanges' multiple times.
+	$already_merged_once = false;
+	// First, check the existing overlap blocks, see if the event overlaps with any.
+	if (isset($ol_day_array)) {
+		foreach ($ol_day_array as $loop_block_key => $loop_ol_block) {
+			// Should $event be in this $ol_block? If so, add it.
+			if ($loop_ol_block['blockStart'] < $drawTimes['draw_end'] && $loop_ol_block['blockEnd'] > $drawTimes['draw_start']) {
+				// ... unless it's already in the $ol_block
+				if (!in_array(array('time' => $drawTimes['draw_start'], 'key' => $uid), $loop_ol_block['events'])) {
+					$loop_ol_block['events'][] = array('time' => $drawTimes['draw_start'], 'key' => $uid);
+					if ($loop_ol_block['blockStart'] > $drawTimes['draw_start']) $loop_ol_block['blockStart'] = $drawTimes['draw_start'];
+					if ($loop_ol_block['blockEnd'] < $drawTimes['draw_end']) $loop_ol_block['blockEnd'] = $drawTimes['draw_end'];
+
+					// Merge in the new overlap range
+					$loop_ol_block['overlapRanges'] = merge_range($loop_ol_block['overlapRanges'], $drawTimes['draw_start'], $drawTimes['draw_end']);
+					$loop_ol_block['maxOverlaps'] = find_max_overlap($loop_ol_block['overlapRanges']);
+					foreach ($loop_ol_block['events'] as $max_overlap_event) {
+						$master_array[$event_date][$max_overlap_event['time']][$max_overlap_event['key']]['event_overlap'] = $loop_ol_block['maxOverlaps'];
 					}
-					$newEventAdded = TRUE;
+					$ol_day_array[$loop_block_key] = $loop_ol_block;
+					$ol_day_array = flatten_ol_blocks($event_date, $ol_day_array, $loop_block_key);
+					$already_merged_once = true;
 					break;
+				// Handle repeat calls to checkOverlap - semi-bogus since the event shouldn't be created more than once, but this makes sure we don't get an invalid event_overlap.
+				} else {
+					$master_array[$event_date][$event_time][$uid]['event_overlap'] = $loop_ol_block['maxOverlaps'];
 				}
 			}
 		}
-		if (!$newEventAdded) {
-			if (isset($master_array[($ol_start_date)])) {
-				foreach ($master_array[($ol_start_date)] as $keyTime => $eventTime) {
-					foreach ($eventTime as $keyEvent => $event) {
-						if ($keyTime != '-1') $entryDrawTimes =  drawEventTimes($event["event_start"], $event["event_end"]);
-						if ((isset($entryDrawTimes["draw_start"]) && isset($entryDrawTimes["draw_end"]) && isset($drawTimes["draw_end"]) && isset($drawTimes["draw_start"])) && ($entryDrawTimes["draw_start"] < $drawTimes["draw_end"]) and ($entryDrawTimes["draw_end"] > $drawTimes["draw_start"])) {
-							// define start time of overlap range and overlap block
-							if ($entryDrawTimes["draw_start"] < $drawTimes["draw_start"]) {
-								$overlap_start = $drawTimes["draw_start"];
-								$overlapBlock_start = $entryDrawTimes["draw_start"];
-							} else {
-								$overlap_start = $entryDrawTimes["draw_start"];
-								$overlapBlock_start = $drawTimes["draw_start"];
-							}
-							// define end time of overlap range and overlap block
-							if ($entryDrawTimes["draw_end"] > $drawTimes["draw_end"]) {
-								$overlap_end = $drawTimes["draw_end"];
-								$overlapBlock_end = $entryDrawTimes["draw_end"];
-							} else {
-								$overlap_end = $entryDrawTimes["draw_end"];
-								$overlapBlock_end = $drawTimes["draw_end"];
-							}
-							if (!isset($newBlockKey)) {
-								// $overlap_array[($ol_start_date)][] = array ("blockStart" => $overlapBlock_start, "blockEnd" => $overlapBlock_end, "maxOverlaps" => 1, "events" => array (array ("time" => $keyTime, "key" => $keyEvent), array ("time" => $newMasterTime, "key" => $newMasterEventKey)), "overlapRanges" => array (array ("count" => 1, "start" => $overlap_start, "end" => $overlap_end)));
-								$overlap_array[($ol_start_date)][] = array ("blockStart" => $overlapBlock_start, "blockEnd" => $overlapBlock_end, "maxOverlaps" => 1, "events" => array (array ("time" => $keyTime, "key" => $keyEvent), array ("time" => $newMasterTime, "key" => $ol_uid)), "overlapRanges" => array (array ("count" => 1, "start" => $overlap_start, "end" => $overlap_end)));
-								$maxOverlaps = 1;
-								end($overlap_array[($ol_start_date)]);
-								$newBlockKey = key($overlap_array[($ol_start_date)]);
-							} else {
-								if ($overlap_array[($ol_start_date)][($newBlockKey)]["blockStart"] > $overlapBlock_start) $overlap_array[($ol_start_date)][($newBlockKey)]["blockStart"] = $overlapBlock_start;
-								if ($overlap_array[($ol_start_date)][($newBlockKey)]["blockEnd"] < $overlapBlock_end) $overlap_array[($ol_start_date)][($newBlockKey)]["blockEnd"] = $overlapBlock_end;
-								$overlap_array[($ol_start_date)][($newBlockKey)]["events"][] = array ("time" => $keyTime, "key" => $keyEvent);
-								$overlap_array[($ol_start_date)][($newBlockKey)]["overlapRanges"][] = array ("count" => 1, "start" => $overlap_start, "end" => $overlap_end);
-							}
-							// update master_array
-							$master_array[($ol_start_date)][($keyTime)][($keyEvent)]["event_overlap"] = $maxOverlaps;
+	}
+
+	// Then, check all the events, make sure there isn't a new overlap that we need to create.
+	foreach ($master_array[$event_date] as $time_key => $time) {
+		// Skip all-day events for overlap purposes.
+		if ($time_key != '-1') {
+			foreach ($time as $loop_event_key => $loop_event) {
+				// Make sure we haven't already dealt with the event, and we're not checking against ourself.
+				if ($loop_event['event_overlap'] == 0 && $loop_event_key != $uid) {
+					$loopDrawTimes = drawEventTimes($loop_event['event_start'], $loop_event['event_end']);
+					if ($loopDrawTimes['draw_start'] < $drawTimes['draw_end'] && $loopDrawTimes['draw_end'] > $drawTimes['draw_start']) {
+						if ($loopDrawTimes['draw_start'] < $drawTimes['draw_start']) {
+							$block_start = $loopDrawTimes['draw_start'];
+						} else {
+							$block_start = $drawTimes['draw_start'];
+						}
+						if ($loopDrawTimes['draw_end'] > $drawTimes['draw_end']) {
+							$block_end = $loopDrawTimes['draw_end'];
+						} else {
+							$block_end = $drawTimes['draw_end'];
+						}
+						$events = array(array('time' => $loopDrawTimes['draw_start'], 'key' => $loop_event_key));
+						$overlap_ranges = array(array('count' => 0, 'start' => $loopDrawTimes['draw_start'], 'end' => $loopDrawTimes['draw_end']));
+						// Only add $event if we haven't already put it in a block
+						if (!$already_merged_once) {
+							$events[] = array('time' => $drawTimes['draw_start'], 'key' => $uid); 
+							$overlap_ranges = merge_range($overlap_ranges, $drawTimes['draw_start'], $drawTimes['draw_end']);
+							$already_merged_once = true;
+						}
+						$ol_day_array[] = array('blockStart' => $block_start, 'blockEnd' => $block_end, 'maxOverlaps' => 1, 'events' => $events, 'overlapRanges' => $overlap_ranges);
+
+						foreach ($events as $max_overlap_event) {
+							$master_array[$event_date][$max_overlap_event['time']][$max_overlap_event['key']]['event_overlap'] = 1;
 						}
+						// Make sure we pass in the key of the newly added item above.
+						end($ol_day_array);
+						$last_day_key = key($ol_day_array);
+						$ol_day_array = flatten_ol_blocks($event_date, $ol_day_array, $last_day_key);
 					}
 				}
 			}
 		}
+	}
+
+	$overlap_array[$event_date] = $ol_day_array;
 
-// for debugging the checkOverlap function
-//print 'Date: ' . $ol_start_date . ' / New Time: ' . $newMasterTime . ' / New Key: ' . $newMasterEventKey . '<br />';
+//for debugging the checkOverlap function
+//if ($event_date == '20050506') {
+//print 'Date: ' . $event_date . ' / Time: ' . $event_time . ' / Key: ' . $uid . "<br />\n";
 //print '<pre>';
-//print_r($overlap_array);
+//print_r($master_array[$event_date]);
+//print_r($overlap_array[$event_date]);
 //print '</pre>';
+//}
 
-	return $maxOverlaps;
 }
 
-// drei 20021126: function for checking and removing overlapping events
-//function removeOverlap($ol_start_date, $ol_start_time, $ol_key = 0) {
+// Remove an event from the overlap data.
+// This could be completely bogus, since overlap array is empty when this gets called in my tests, but I'm leaving it in anyways.
 function removeOverlap($ol_start_date, $ol_start_time, $ol_key) {
 	global $master_array, $overlap_array;
 	if (isset($overlap_array[$ol_start_date])) {
 		if (sizeof($overlap_array[$ol_start_date]) > 0) {
-			$ol_end_time = $master_array[$ol_start_date][$ol_start_time][$ol_key]["event_end"];
-			foreach ($overlap_array[$ol_start_date] as $keyBlock => $blockId) {
-//				if (($blockId["blockStart"] <= $ol_start_time) or ($blockId["blockEnd"] >= $ol_start_time)) {
-				if (($blockId["blockStart"] <= $ol_start_time) and ($blockId["blockEnd"] > $ol_start_time)) {
-					foreach ($blockId["events"] as $keyEvent => $ol_event) {
-						$master_array[$ol_start_date][$ol_event["time"]][$ol_event["key"]]["event_overlap"] -= 1;
-						if (($ol_event["time"] == $ol_start_time) and ($ol_event["key"] == $ol_key)) {
-							unset ($overlap_array[$ol_start_date][$keyBlock]["events"][$keyEvent]);
+			$ol_end_time = $master_array[$ol_start_date][$ol_start_time][$ol_key]['event_end'];
+			foreach ($overlap_array[$ol_start_date] as $block_key => $block) {
+				if (in_array(array('time' => $ol_start_time, 'key' => $ol_key), $block['events'])) {
+					// Check if this is a 2-event block (i.e., there's no block left when we remove $ol_key
+					// and if so, just unset it and move on.
+					if (count($block['events']) == 2) {
+						foreach ($block['events'] as $event) {
+							$master_array[$ol_start_date][$event['time']][$event['key']]['event_overlap'] = 0;
 						}
-					}
-					if ($blockId["maxOverlaps"] == 1) {
-						unset ($overlap_array[$ol_start_date][$keyBlock]);
+						unset($overlap_array[$ol_start_date][$block_key]);
 					} else {
-						$overlap_array[$ol_start_date][$keyBlock]["maxOverlaps"] -= 1;
-						//$blockId["maxOverlaps"] -= 1;
-						// SJBO: Shouldn't something be done with [overlapRanges] as well?
+						// remove $ol_key from 'events'
+						$event_key = array_search(array('time' => $ol_start_time, 'key' => $ol_key), $block['events']);
+						unset($overlap_array[$ol_start_date][$block_key]['events'][$event_key]);
+
+						// These may be bogus, since we're not using drawEventTimes.
+						// "clean up" 'overlapRanges' and calc the new maxOverlaps.
+						// use the special "-2" count to tell merge_range we're deleting.
+						$overlap_array[$ol_start_date][$block_key]['overlapRanges'] = merge_range($block['overlapRanges'], $ol_start_time, $ol_end_time, -2);
+						$overlap_array[$ol_start_date][$block_key]['maxOverlaps'] = find_max_overlap($block['overlapRanges']);
+
+						// recreate blockStart and blockEnd from the other events, and fix maxOverlap while we're at it.
+						$blockStart = $ol_end_time;
+						$blockEnd = $ol_start_time;
+						foreach ($overlap_array[$ol_start_date][$block_key]['events'] as $event) {
+							$blockStart = min($blockStart, $event['time']);
+							$blockEnd = max($blockEnd, $master_array[$ol_start_date][$event['time']][$event['key']]['event_end']);
+							$master_array[$ol_start_date][$event['time']][$event['key']]['event_overlap'] = $overlap_array[$ol_start_date][$block_key]['maxOverlaps'];
+						}
+						$overlap_array[$ol_start_date][$block_key]['blockStart'] = $blockStart;
+						$overlap_array[$ol_start_date][$block_key]['blockEnd'] = $blockEnd;
 					}
 				}
 			}
 		}
 	}
 }
-?>
\ No newline at end of file
+?>
diff --git a/functions/template.php b/functions/template.php
index 24b151b..8307529 100644
--- a/functions/template.php
+++ b/functions/template.php
@@ -423,12 +423,18 @@ class Page {
 					
 				} else {
 					$emptyWidth = $nbrGridCols[$thisday];
+					// Used to "join" ended events, so the ended case below results in one colspan'd td instead of multiple tds.
+					$ended_counter = 0;
 					for ($i=0;$i<sizeof($event_length[$thisday]);$i++) {
 					
 						$drawWidth = $nbrGridCols[$thisday] / ($event_length[$thisday][$i]["overlap"] + 1);
 						$emptyWidth = $emptyWidth - $drawWidth;
 						switch ($event_length[$thisday][$i]["state"]) {
 							case "begin":
+								if ($ended_counter) {
+									$weekdisplay .= '<td colspan="' . $ended_counter . '" '.$class.'>&nbsp;</td>';
+									$ended_counter = 0;
+								}
 								$event_length[$thisday][$i]["state"] = "started";
 								$event_start 	= $this_time_arr[($event_length[$thisday][$i]["key"])]['start_unixtime'];
 								$event_start 	= date ($timeFormat_small, $event_start);
@@ -460,9 +466,13 @@ class Page {
 						  
 								break;
 							case "started":
+								if ($ended_counter) {
+									$weekdisplay .= '<td colspan="' . $ended_counter . '" '.$class.'>&nbsp;</td>';
+									$ended_counter = 0;
+								}
 								break;
 							case "ended":
-								$weekdisplay .= '<td colspan="' . $drawWidth . '" '.$class.'>&nbsp;</td>';
+								$ended_counter += $drawWidth;
 								break;
 						}
 						$event_length[$thisday][$i]["length"]--;
@@ -470,7 +480,10 @@ class Page {
 							$event_length[$thisday][$i]["state"] = "ended";
 						}
 					}
-					//fill emtpy space on the right
+
+					// Clean up
+					$emptyWidth += $ended_counter;
+					//fill empty space on the right
 					if ($emptyWidth > 0) {
 						$weekdisplay .= "<td colspan=\"" . $emptyWidth . "\" $class>&nbsp;</td>\n";
 					}
@@ -636,11 +649,17 @@ class Page {
 				
 			} else {
 				$emptyWidth = $nbrGridCols;
+				// Used to "join" ended events, so the ended case below results in one colspan'd td instead of multiple tds.
+				$ended_counter = 0;
 				for ($i=0;$i<sizeof($event_length);$i++) {
 					$drawWidth = $nbrGridCols / ($event_length[$i]['overlap'] + 1);
 					$emptyWidth = $emptyWidth - $drawWidth;
 					switch ($event_length[$i]['state']) {
 						case 'begin':
+						  if ($ended_counter) {
+							$daydisplay .= '<td colspan="' . $ended_counter . '" '.$class.'>&nbsp;</td>';
+							$ended_counter = 0;
+						  }
 						  $event_length[$i]['state'] = 'started';
 						  $event_start 	= strtotime ($this_time_arr[($event_length[$i]['key'])]['event_start']);
 						  $event_end	= strtotime ($this_time_arr[($event_length[$i]['key'])]['event_end']);
@@ -675,6 +694,10 @@ class Page {
 						  
 						  break;
 						case 'started':
+							if ($ended_counter) {
+								$daydisplay .= '<td colspan="' . $ended_counter . '" '.$class.'>&nbsp;</td>';
+								$ended_counter = 0;
+							}
 							break;
 						case 'ended':
 							$daydisplay .= '<td colspan="' . $drawWidth . '" ' . $class . '>&nbsp;</td>'."\n";
@@ -685,7 +708,10 @@ class Page {
 						$event_length[$i]['state'] = 'ended';
 					}
 				}
-				//fill emtpy space on the right
+
+				// Clean up.
+				$emptyWidth += $ended_counter;
+				//fill empty space on the right
 				if ($emptyWidth > 0) {
 					$daydisplay .= '<td colspan="' . $emptyWidth . '" ' . $class . '>&nbsp;</td>'."\n";
 				}