start trasmitting direct eventRangeGroups on release

src/Calendar.js

@@ -306,8 +306,8 @@ var Calendar = FC.Calendar = Class.extend(EmitterMixin, {
 	},
 
 
-	requestEventRangeGroups: function(start, end) {
-		return this.eventManager.requestEventRangeGroups(
+	requestEvents: function(start, end) {
+		return this.eventManager.requestEvents(
 			start,
 			end,
 			this.opt('timezone'),

src/agenda/AgendaView.js

@@ -297,27 +297,29 @@ var AgendaView = FC.AgendaView = View.extend({
 
 
 	// Renders events onto the view and populates the View's segment array
-	renderEventRangeGroups: function(eventRangeGroups) {
-		var dayEventRangeGroups = [];
-		var timedEventRangeGroups = [];
+	renderEvents: function(eventsPayload) {
+		var dayEventsPayload = {};
+		var timedEventsPayload = {};
 		var daySegs = [];
 		var timedSegs;
-		var i;
+		var id, eventRangeGroup;
 
 		// separate the events into all-day and timed
-		for (i = 0; i < eventRangeGroups.length; i++) {
-			if (eventRangeGroups[i].getEventInstance().dateProfile.isAllDay()) {
-				dayEventRangeGroups.push(eventRangeGroups[i]);
+		for (id in eventsPayload) {
+			eventRangeGroup = eventsPayload[id];
+
+			if (eventRangeGroup.getEventInstance().dateProfile.isAllDay()) {
+				dayEventsPayload[id] = eventRangeGroup;
 			}
 			else {
-				timedEventRangeGroups.push(eventRangeGroups[i]);
+				timedEventsPayload[id] = eventRangeGroup;
 			}
 		}
 
 		// render the events in the subcomponents
-		timedSegs = this.timeGrid.renderEventRangeGroups(timedEventRangeGroups);
+		timedSegs = this.timeGrid.renderEvents(timedEventsPayload);
 		if (this.dayGrid) {
-			daySegs = this.dayGrid.renderEventRangeGroups(dayEventRangeGroups);
+			daySegs = this.dayGrid.renderEvents(dayEventsPayload);
 		}
 
 		// the all-day area is flexible and might have a lot of events, so shift the height

src/basic/BasicView.js

@@ -253,8 +253,8 @@ var BasicView = FC.BasicView = View.extend({
 
 
 	// Renders the given events onto the view and populates the segments array
-	renderEventRangeGroups: function(eventRangeGroups) {
-		this.dayGrid.renderEventRangeGroups(eventRangeGroups);
+	renderEvents: function(eventsPayload) {
+		this.dayGrid.renderEvents(eventsPayload);
 
 		// must compensate for events that overflow the row
 		// TODO: how will ChronoComponent handle this?

src/common/ChronoComponent.js

@@ -166,17 +166,17 @@ var ChronoComponent = Model.extend({
 
 
 	// Renders the events onto the view.
-	renderEventRangeGroups: function(eventRangeGroups) {
-		this.callChildren('renderEventRangeGroups', eventRangeGroups);
+	renderEvents: function(eventsPayload) {
+		this.callChildren('renderEvents', eventsPayload);
 	},
 
 
 	// Removes event elements from the view.
-	unrenderEventRangeGroups: function() {
-		this.callChildren('unrenderEventRangeGroups');
+	unrenderEvents: function() {
+		this.callChildren('unrenderEvents');
 
 		// we DON'T need to call updateHeight() because
-		// a renderEventRangeGroups() call always happens after this, which will eventually call updateHeight()
+		// a renderEvents() call always happens after this, which will eventually call updateHeight()
 	},
 
 

src/common/Grid.events.js

@@ -15,17 +15,18 @@ Grid.mixin({
 	segs: null, // the *event* segments currently rendered in the grid. TODO: rename to `eventSegs`
 
 
-	renderEventRangeGroups: function(eventRangeGroups) {
+	renderEvents: function(eventsPayload) {
 		var unzonedRange = new UnzonedRange(this.start, this.end);
-		var i, eventRangeGroup;
+		var id, eventRangeGroup;
 		var eventRenderRanges;
 		var eventFootprints;
 		var eventSegs;
 		var bgSegs = [];
 		var fgSegs = [];
 
-		for (i = 0; i < eventRangeGroups.length; i++) {
-			eventRangeGroup = eventRangeGroups[i];
+		for (id in eventsPayload) {
+			eventRangeGroup = eventsPayload[id];
+
 			eventRenderRanges = eventRangeGroup.sliceRenderRanges(unzonedRange);
 			eventFootprints = this.eventRangesToEventFootprints(eventRenderRanges);
 			eventSegs = this.eventFootprintsToSegs(eventFootprints);
@@ -50,7 +51,7 @@ Grid.mixin({
 
 
 	// Unrenders all events currently rendered on the grid
-	unrenderEventRangeGroups: function() {
+	unrenderEvents: function() {
 		this.handleSegMouseout(); // trigger an eventMouseout if user's mouse is over an event
 		this.clearDragListeners();
 

src/common/View.js

@@ -254,8 +254,8 @@ var View = FC.View = ChronoComponent.extend({
 	// -----------------------------------------------------------------------------------------------------------------
 
 
-	fetchInitialEventRangeGroups: function(dateProfile) {
-		return this.calendar.requestEventRangeGroups(
+	fetchInitialEvents: function(dateProfile) {
+		return this.calendar.requestEvents(
 			dateProfile.activeRange.start,
 			dateProfile.activeRange.end
 		);
@@ -263,7 +263,7 @@ var View = FC.View = ChronoComponent.extend({
 
 
 	bindEventChanges: function() {
-		this.listenTo(this.calendar, 'eventsReset', this.resetEventRangeGroups);
+		this.listenTo(this.calendar, 'eventsReset', this.resetEvents);
 	},
 
 
@@ -272,22 +272,22 @@ var View = FC.View = ChronoComponent.extend({
 	},
 
 
-	setEventRangeGroups: function(eventRangeGroups) {
-		this.set('currentEventRangeGroups', eventRangeGroups);
+	setEvents: function(eventsPayload) {
+		this.set('currentEvents', eventsPayload);
 		this.set('hasEvents', true);
 	},
 
 
-	unsetEventRangeGroups: function() {
-		this.unset('currentEventRangeGroups');
+	unsetEvents: function() {
+		this.unset('currentEvents');
 		this.unset('hasEvents');
 	},
 
 
-	resetEventRangeGroups: function(eventRangeGroups) {
+	resetEvents: function(eventsPayload) {
 		this.startBatchRender();
-		this.unsetEventRangeGroups();
-		this.setEventRangeGroups(eventRangeGroups);
+		this.unsetEvents();
+		this.setEvents(eventsPayload);
 		this.stopBatchRender();
 	},
 
@@ -296,11 +296,11 @@ var View = FC.View = ChronoComponent.extend({
 	// -----------------------------------------------------------------------------------------------------------------
 
 
-	requestEventsRender: function(eventRangeGroups) {
+	requestEventsRender: function(eventsPayload) {
 		var _this = this;
 
 		this.renderQueue.queue(function() {
-			_this.executeEventsRender(eventRangeGroups);
+			_this.executeEventsRender(eventsPayload);
 		}, 'event', 'init');
 	},
 
@@ -614,9 +614,9 @@ var View = FC.View = ChronoComponent.extend({
 	// -----------------------------------------------------------------------------------------------------------------
 
 
-	executeEventsRender: function(eventRangeGroups) {
+	executeEventsRender: function(eventsPayload) {
 
-		this.renderEventRangeGroups(eventRangeGroups);
+		this.renderEvents(eventsPayload);
 		this.isEventsRendered = true;
 
 		this.onEventsRender();
@@ -630,7 +630,7 @@ var View = FC.View = ChronoComponent.extend({
 			this.destroyEvents(); // TODO: deprecate
 		}
 
-		this.unrenderEventRangeGroups();
+		this.unrenderEvents();
 		this.isEventsRendered = false;
 	},
 
@@ -933,22 +933,22 @@ View.watch('displayingDates', [ 'dateProfile' ], function(deps) {
 });
 
 
-View.watch('initialEventRangeGroups', [ 'dateProfile' ], function(deps) {
-	return this.fetchInitialEventRangeGroups(deps.dateProfile);
+View.watch('initialEvents', [ 'dateProfile' ], function(deps) {
+	return this.fetchInitialEvents(deps.dateProfile);
 });
 
 
-View.watch('bindingEvents', [ 'initialEventRangeGroups' ], function(deps) {
-	this.setEventRangeGroups(deps.initialEventRangeGroups);
+View.watch('bindingEvents', [ 'initialEvents' ], function(deps) {
+	this.setEvents(deps.initialEvents);
 	this.bindEventChanges();
 }, function() {
 	this.unbindEventChanges();
-	this.unsetEventRangeGroups();
+	this.unsetEvents();
 });
 
 
 View.watch('displayingEvents', [ 'displayingDates', 'hasEvents' ], function() {
-	this.requestEventsRender(this.get('currentEventRangeGroups')); // if there were event mutations after initialEventRangeGroups
+	this.requestEventsRender(this.get('currentEvents')); // if there were event mutations after initialEvents
 }, function() {
 	this.requestEventsUnrender();
 });

src/models/EventManager.js

@@ -13,7 +13,7 @@ var EventManager = Class.extend(EmitterMixin, ListenerMixin, {
 	},
 
 
-	requestEventRangeGroups: function(start, end, timezone, force) {
+	requestEvents: function(start, end, timezone, force) {
 		if (
 			force ||
 			!this.currentPeriod ||

src/models/EventPeriod.js

@@ -349,7 +349,7 @@ var EventPeriod = Class.extend(EmitterMixin, {
 	release: function() {
 		this.releaseCnt++;
 		// TODO: dont re-convert to rangegroups
-		this.trigger('release', Object.values(this.eventRangeGroupsById)); // TODO: payload
+		this.trigger('release', this.eventRangeGroupsById);
 	},
 
 
@@ -358,7 +358,7 @@ var EventPeriod = Class.extend(EmitterMixin, {
 
 		if (this.releaseCnt) {
 			// TODO: dont re-convert to rangegroups
-			return Promise.resolve(Object.values(this.eventRangeGroupsById)); // TODO: payload
+			return Promise.resolve(this.eventRangeGroupsById);
 		}
 		else {
 			return Promise.construct(function(onResolve) {