extended events to allow grouping+delay

WebWidgets/ExtJS/include/Poco/WebWidgets/ExtJS/Utility.h

@@ -105,11 +105,28 @@ public:
 	static std::string convertPocoDateToPHPDate(const std::string& dateTimeFmt);
 		/// Converts a poco date time format string to its PHP/extjs equivalent
 	
-	static bool writeJSEvent(std::ostream& out, const std::string& eventName, const std::list<JSDelegate>& delegates);
+	template <typename T, typename CreateServerCallbackFct, typename Param>
+	static bool writeJSEvent(std::ostream& out, const std::string& eventName, const JavaScriptEvent<T>& ev, CreateServerCallbackFct fct, const Param* p)
+	{
+		if (!ev.hasJavaScriptCode())
+			return false;
+		if (ev.willDoServerCallback())
+			return writeJSEvent(out, eventName, ev.jsDelegates(), (*fct)(p), ev.getServerCallbackPos(), ev.getDelayTime(), ev.getGroupEvents());
+		return  writeJSEvent(out, eventName, ev.jsDelegates(), ev.getDelayTime(), ev.getGroupEvents());
+	}
+
+
+	static bool writeJSEvent(std::ostream& out, const std::string& eventName, const std::list<JSDelegate>& delegates, int delayTime, bool group);
 		/// writes all JS Delegates for a single named JSEvent. 
 		/// Returns true if data was written, false if no delegates were present and no event handler was written.
 		
-	static bool writeJSEvent(std::ostream& out, const std::string& eventName, const std::list<JSDelegate>& delegates, const Poco::WebWidgets::JSDelegate& serverCallback, std::size_t serverCallPos);
+	static bool writeJSEvent(std::ostream& out, 
+							const std::string& eventName, 
+							const std::list<JSDelegate>& delegates, 
+							const Poco::WebWidgets::JSDelegate& serverCallback, 
+							std::size_t serverCallPos,
+							int delayTime, 
+							bool group);
 		/// writes all JS Delegates for a single named JSEvent. plus the server callbacb, Always returns true.
 		
 	static std::string createURI(const std::map<std::string, std::string>& addParams, Renderable::ID id);

WebWidgets/ExtJS/src/ButtonCellRenderer.cpp

@@ -113,11 +113,13 @@ void ButtonCellRenderer::renderProperties(const ButtonCell* pButtonCell, const s
 		if (pOwner->buttonClicked.hasJavaScriptCode())
 		{
 			ostr << ",listeners:{";
+			Utility::writeJSEvent(ostr, EV_CLICK, pOwner->buttonClicked, &ButtonCellRenderer::createClickServerCallback, pOwner);
+			/*
 			if (pOwner->buttonClicked.willDoServerCallback())
 				Utility::writeJSEvent(ostr, EV_CLICK, pOwner->buttonClicked.jsDelegates(),
 										createClickServerCallback(pOwner), pOwner->buttonClicked.getServerCallbackPos());
 			else
-				Utility::writeJSEvent(ostr, EV_CLICK, pOwner->buttonClicked.jsDelegates());
+				Utility::writeJSEvent(ostr, EV_CLICK, pOwner->buttonClicked.jsDelegates());*/
 			ostr << "}";
 		}
 	}

WebWidgets/ExtJS/src/ComboBoxCellRenderer.cpp

@@ -103,10 +103,7 @@ void ComboBoxCellRenderer::renderHead(const Renderable* pRenderable, const Rende
 	if (pComboOwner && pComboOwner->selected.hasJavaScriptCode())
 	{
 		ostr << ",listeners:{";
-		if (pComboOwner->selected.willDoServerCallback())
+		Utility::writeJSEvent(ostr, EV_SELECTED, pComboOwner->selected, &ComboBoxCellRenderer::createSelectedServerCallback, pComboOwner);
-			Utility::writeJSEvent(ostr, EV_SELECTED, pComboOwner->selected.jsDelegates(), createSelectedServerCallback(pComboOwner), pComboOwner->selected.getServerCallbackPos());
-		else
-			Utility::writeJSEvent(ostr, EV_SELECTED, pComboOwner->selected.jsDelegates());
 		if (!tooltip.empty())
 			ostr << ",render:function(c){Ext.QuickTips.register({target:c.getEl(),text:'" << Utility::safe(tooltip) << "'});}";
 		ostr << "}";

WebWidgets/ExtJS/src/PageRenderer.cpp

@@ -145,17 +145,13 @@ void PageRenderer::renderHead(const Renderable* pRenderable, const RenderContext
 		if (pPage->beforeRender.hasJavaScriptCode() || pPage->afterRender.hasJavaScriptCode())
 		{
 			ostr << ",listeners:{";
-			bool written = false;
+			bool written = Utility::writeJSEvent(ostr, EV_BEFORERENDER, pPage->beforeRender, &PageRenderer::createBeforeRenderCallback, pPage);
-			if (pPage->beforeRender.willDoServerCallback())
+			if (pPage->afterRender.hasJavaScriptCode())
-				written = Utility::writeJSEvent(ostr, EV_BEFORERENDER, pPage->beforeRender.jsDelegates(), createBeforeRenderCallback(pPage), pPage->beforeRender.getServerCallbackPos());
+			{
-			else
-				written = Utility::writeJSEvent(ostr, EV_BEFORERENDER, pPage->beforeRender.jsDelegates());
 				if (written)
 					ostr << ",";
-			if (pPage->afterRender.willDoServerCallback())
+				Utility::writeJSEvent(ostr, EV_AFTERRENDER, pPage->afterRender, &PageRenderer::createAfterRenderCallback, pPage);
-				Utility::writeJSEvent(ostr, EV_AFTERRENDER, pPage->afterRender.jsDelegates(), createAfterRenderCallback(pPage), pPage->afterRender.getServerCallbackPos());
+			}
-			else
-				Utility::writeJSEvent(ostr, EV_AFTERRENDER, pPage->afterRender.jsDelegates());
 			ostr << "}";
 		}
 		if (pPage->getHeight() > 0)

WebWidgets/ExtJS/src/TableRenderer.cpp

@@ -303,100 +303,62 @@ void TableRenderer::renderProperties(const Table* pTable, const RenderContext& c
 		if (pTable->cellValueChanged.willDoServerCallback())
 			written = Utility::writeJSEvent(ostr, EV_AFTEREDIT, modList, 
 					TableRenderer::createCellValueChangedServerCallback(pTable), 
-					pTable->cellValueChanged.getServerCallbackPos());
+					pTable->cellValueChanged.getServerCallbackPos(), pTable->cellValueChanged.getDelayTime(), pTable->cellValueChanged.getGroupEvents());
 		else					
-			written = Utility::writeJSEvent(ostr, EV_AFTEREDIT, modList);
+			written = Utility::writeJSEvent(ostr, EV_AFTEREDIT, modList, pTable->cellValueChanged.getDelayTime(), pTable->cellValueChanged.getGroupEvents());
 		if (pTable->beforeCellValueChanged.hasJavaScriptCode())
 		{	
-			if (written)
+			if (written) ostr << ",";
-				ostr << ",";
+			written = Utility::writeJSEvent(ostr, EV_BEFORECELLVALUECHANGED, pTable->beforeCellValueChanged, 
-			if (pTable->beforeCellValueChanged.willDoServerCallback())
+						&TableRenderer::createBeforeCellValueChangedServerCallback, pTable);
-				written = Utility::writeJSEvent(ostr, EV_BEFORECELLVALUECHANGED, pTable->beforeCellValueChanged.jsDelegates(), 
-						TableRenderer::createBeforeCellValueChangedServerCallback(pTable), 
-						pTable->beforeCellValueChanged.getServerCallbackPos());
-			else					
-				written = Utility::writeJSEvent(ostr, EV_BEFORECELLVALUECHANGED, pTable->beforeCellValueChanged.jsDelegates());	
 		}
 		if (pTable->keyDown.hasJavaScriptCode())
 		{
 			if (written) ostr << ",";
-			if (pTable->keyDown.willDoServerCallback())
+			written = Utility::writeJSEvent(ostr, EV_KEYDOWN, pTable->keyDown,
-				written = Utility::writeJSEvent(ostr, EV_KEYDOWN, pTable->keyDown.jsDelegates(), 
+						&TableRenderer::createKeyDownServerCallback, pTable);
-						TableRenderer::createKeyDownServerCallback(pTable), 
-						pTable->keyDown.getServerCallbackPos());
-			else					
-				written = Utility::writeJSEvent(ostr, EV_KEYDOWN, pTable->keyDown.jsDelegates());	
 		}
 		if (pTable->keyPressed.hasJavaScriptCode())
 		{
 			if (written) ostr << ",";
-			if (pTable->keyPressed.willDoServerCallback())
+			written = Utility::writeJSEvent(ostr, EV_KEYPRESSED, pTable->keyPressed,
-				written = Utility::writeJSEvent(ostr, EV_KEYPRESSED, pTable->keyPressed.jsDelegates(), 
+						&TableRenderer::createKeyPressedServerCallback, pTable);
-						TableRenderer::createKeyPressedServerCallback(pTable), 
-						pTable->keyPressed.getServerCallbackPos());
-			else					
-				written = Utility::writeJSEvent(ostr, EV_KEYPRESSED, pTable->keyPressed.jsDelegates());	
 		}
 	}
 	
 	if (pTable->cellClicked.hasJavaScriptCode())
 	{
-		if (written)
+		if (written) ostr << ",";
-			ostr << ",";
+		written = Utility::writeJSEvent(ostr, EV_CELLCLICKED, pTable->cellClicked,
-		if (pTable->cellClicked.willDoServerCallback())
+										&TableRenderer::createCellClickedServerCallback, pTable);
-			written = Utility::writeJSEvent(ostr, EV_CELLCLICKED, pTable->cellClicked.jsDelegates(),
-										TableRenderer::createCellClickedServerCallback(pTable),
-										pTable->cellClicked.getServerCallbackPos());
-		else
-			written = Utility::writeJSEvent(ostr, EV_CELLCLICKED, pTable->cellClicked.jsDelegates());
 	}
 	
 	if (pTable->beforeCellClicked.hasJavaScriptCode())
 	{
-		if (written)
+		if (written) ostr << ",";
-			ostr << ",";
+		written = Utility::writeJSEvent(ostr, EV_BEFORECELLCLICKED, pTable->beforeCellClicked,
-		if (pTable->beforeCellClicked.willDoServerCallback())
+										&TableRenderer::createBeforeCellClickedServerCallback ,pTable);
-			written = Utility::writeJSEvent(ostr, EV_BEFORECELLCLICKED, pTable->beforeCellClicked.jsDelegates(),
-										TableRenderer::createBeforeCellClickedServerCallback(pTable),
-										pTable->beforeCellClicked.getServerCallbackPos());
-		else
-			written = Utility::writeJSEvent(ostr, EV_BEFORECELLCLICKED, pTable->beforeCellClicked.jsDelegates());
 	}
 	
 	if (pTable->afterRender.hasJavaScriptCode())
 	{
-		if (written)
+		if (written) ostr << ",";
-			ostr << ",";
+		written = Utility::writeJSEvent(ostr, EV_RENDER, pTable->afterRender,
-		if (pTable->afterRender.willDoServerCallback())
+										&TableRenderer::createRenderServerCallback, pTable);
-			written = Utility::writeJSEvent(ostr, EV_RENDER, pTable->afterRender.jsDelegates(),
-										TableRenderer::createRenderServerCallback(pTable),
-										pTable->afterRender.getServerCallbackPos());
-		else
-			written = Utility::writeJSEvent(ostr, EV_RENDER, pTable->afterRender.jsDelegates());
 	}
 	
 	if (pTable->mouseUp.hasJavaScriptCode())
 	{
-		if (written)
+		if (written) ostr << ",";
-			ostr << ",";
+		written = Utility::writeJSEvent(ostr, EV_MOUSEUP, pTable->mouseUp,
-		if (pTable->mouseUp.willDoServerCallback())
+										&TableRenderer::createMouseUpServerCallback, pTable);
-			written = Utility::writeJSEvent(ostr, EV_MOUSEUP, pTable->mouseUp.jsDelegates(),
-										TableRenderer::createMouseUpServerCallback(pTable),
-										pTable->mouseUp.getServerCallbackPos());
-		else
-			written = Utility::writeJSEvent(ostr, EV_MOUSEUP, pTable->mouseUp.jsDelegates());
 	}
 	
 	if (pTable->mouseDown.hasJavaScriptCode())
 	{
-		if (written)
+		if (written) ostr << ",";
-			ostr << ",";
+		written = Utility::writeJSEvent(ostr, EV_MOUSEDOWN, pTable->mouseDown,
-		if (pTable->mouseDown.willDoServerCallback())
+										&TableRenderer::createMouseDownServerCallback, pTable);
-			written = Utility::writeJSEvent(ostr, EV_MOUSEDOWN, pTable->mouseDown.jsDelegates(),
-										TableRenderer::createMouseDownServerCallback(pTable),
-										pTable->mouseDown.getServerCallbackPos());
-		else
-			written = Utility::writeJSEvent(ostr, EV_MOUSEDOWN, pTable->mouseDown.jsDelegates());
 	}
 	
 	ostr << "},"; //close listeners
@@ -417,23 +379,14 @@ void TableRenderer::renderProperties(const Table* pTable, const RenderContext& c
 		if (pTable->rowClicked.hasJavaScriptCode() || pTable->beforeRowClicked.hasJavaScriptCode())
 		{
 			ostr << ",listeners:{";
-			if (pTable->rowClicked.willDoServerCallback())
+			written = Utility::writeJSEvent(ostr, EV_ROWCLICKED, pTable->rowClicked,
-				written = Utility::writeJSEvent(ostr, EV_ROWCLICKED, pTable->rowClicked.jsDelegates(),
+										&TableRenderer::createRowClickedServerCallback, pTable);
-										TableRenderer::createRowClickedServerCallback(pTable),
-										pTable->rowClicked.getServerCallbackPos());
-			else
-				written = Utility::writeJSEvent(ostr, EV_ROWCLICKED, pTable->rowClicked.jsDelegates());
 				
 			if (pTable->beforeRowClicked.hasJavaScriptCode())
 			{
-				if (written)
+				if (written) ostr << ",";
-					ostr << ",";
+				written = Utility::writeJSEvent(ostr, EV_BEFOREROWCLICKED, pTable->beforeRowClicked,
-				if (pTable->beforeRowClicked.willDoServerCallback())
+										&TableRenderer::createBeforeRowClickedServerCallback, pTable);	
-					written = Utility::writeJSEvent(ostr, EV_BEFOREROWCLICKED, pTable->beforeRowClicked.jsDelegates(),
-										TableRenderer::createBeforeRowClickedServerCallback(pTable),
-										pTable->beforeRowClicked.getServerCallbackPos());
-				else
-					written = Utility::writeJSEvent(ostr, EV_BEFOREROWCLICKED, pTable->beforeRowClicked.jsDelegates());	
 			}
 			ostr << "}";
 		}
@@ -610,10 +563,7 @@ void TableRenderer::renderStore(const Table* pTable, std::ostream& ostr)
 	if (pTable->afterLoad.hasJavaScriptCode())
 	{
 		ostr << ",listeners:{";
-		if (pTable->afterLoad.willDoServerCallback())
+			Utility::writeJSEvent(ostr, EV_AFTERLOAD, pTable->afterLoad, &TableRenderer::createAfterLoadServerCallback, pTable);
-			Utility::writeJSEvent(ostr, EV_AFTERLOAD, pTable->afterLoad.jsDelegates(), createAfterLoadServerCallback(pTable), pTable->afterLoad.getServerCallbackPos());
-		else
-			Utility::writeJSEvent(ostr, EV_AFTERLOAD, pTable->afterLoad.jsDelegates());
 		ostr << "}";
 	}
 	

WebWidgets/ExtJS/src/Utility.cpp

@@ -414,7 +414,7 @@ Form::Ptr Utility::insideForm(const Cell* pChild)
 }
 
 
-bool Utility::writeJSEvent(std::ostream& out, const std::string& eventName, const std::list<JSDelegate>& delegates)
+bool Utility::writeJSEvent(std::ostream& out, const std::string& eventName, const std::list<JSDelegate>& delegates, int delayTime, bool group)
 {
 	//'click' : {
 	//	fn: this.onClick,
@@ -424,17 +424,17 @@ bool Utility::writeJSEvent(std::ostream& out, const std::string& eventName, cons
 	if (delegates.empty())
 		return false;
 		
-	out << "'" << eventName << "':";
+	out << "'" << eventName << "':{";
 		
 	if (delegates.size() == 1)
-		out << "{fn:" << delegates.begin()->jsCode() << "}";
+		out << "fn:" << delegates.begin()->jsCode() << "";
 	else
 	{
 		// rather simple way to support more than one delegate
 		std::ostringstream invoke;
 		int maxParams = detectMaxParamCount(delegates);
 		std::string fct(createFunctionSignature(maxParams));
-		out << "{fn:" << fct << "{var all={";
+		out << "fn:" << fct << "{var all={";
 		// the invoke function calls all the other functions sequentially
 		invoke << "invoke:" << fct <<"{";
 		std::list<JSDelegate>::const_iterator it = delegates.begin();
@@ -480,20 +480,33 @@ bool Utility::writeJSEvent(std::ostream& out, const std::string& eventName, cons
 		
 		out << "all." << createFunctionSignature("invoke", maxParams) << ";";
 		out << "}"; //closes fn
-		out << "}"; //closes function
-	}	
 		
+	}	
+	if (delayTime > 0)
+	{
+		if (!group)
+			out << ",delay:" << delayTime;
+		else
+			out << ",buffer:" << delayTime;
+	}
+	out << "}"; //closes outer fn
 	return true;
 }
 
 
-bool Utility::writeJSEvent(std::ostream& out, const std::string& eventName, const std::list<JSDelegate>& delegates, const Poco::WebWidgets::JSDelegate& serverCallback, std::size_t serverCallPos)
+bool Utility::writeJSEvent(std::ostream& out, 
+					const std::string& eventName, 
+					const std::list<JSDelegate>& delegates, 
+					const Poco::WebWidgets::JSDelegate& serverCallback, 
+					std::size_t serverCallPos,
+					int delayTime, 
+					bool group)
 {
 	// TODO: we can optimize here a bit by avoiding the copy
 	std::list<JSDelegate> dels;
 	std::list<JSDelegate>::const_iterator it = delegates.begin();
 	bool written = false;
-	for (; it != delegates.end(); ++it, --serverCallPos)
+	for (; it != delegates.end() && !written; ++it, --serverCallPos)
 	{
 		if (serverCallPos == 0)
 		{
@@ -504,7 +517,7 @@ bool Utility::writeJSEvent(std::ostream& out, const std::string& eventName, cons
 	}
 	if (!written)
 		dels.push_back(serverCallback);
-	return writeJSEvent(out, eventName, dels);
+	return writeJSEvent(out, eventName, dels, delayTime, group);
 }
 
 

WebWidgets/ExtJS/testsuite/src/ExtJSTest.cpp

@@ -1332,7 +1332,7 @@ void ExtJSTest::testJSEvent()
 	pBut->buttonClicked.add(jsDelegate("someFunction2(obj)")); 
 	pBut->buttonClicked.add(jsDelegate("hello(obj){alert('Click');}")); //hello must get renamed to function
 	std::ostringstream out;
-	Utility::writeJSEvent(out, "clicked", pBut->buttonClicked.jsDelegates());
+	Utility::writeJSEvent(out, "clicked", pBut->buttonClicked.jsDelegates(),0, false);
 	std::string result(out.str());
 	static const std::string expected("'clicked':"
 										"{"
@@ -1363,7 +1363,7 @@ void ExtJSTest::testJSEvent2()
 	pBut->buttonClicked.add(jsDelegate("someFunction2(obj,o2)")); 
 	pBut->buttonClicked.add(jsDelegate("hello(obj){alert('Click');}")); //hello must get renamed to function
 	std::ostringstream out;
-	Utility::writeJSEvent(out, "clicked", pBut->buttonClicked.jsDelegates());
+	Utility::writeJSEvent(out, "clicked", pBut->buttonClicked.jsDelegates(),0, false);
 	std::string result(out.str());
 	static const std::string expected("'clicked':"
 										"{"

WebWidgets/include/Poco/WebWidgets/JavaScriptEvent.h

@@ -187,6 +187,33 @@ public:
 		return (willDoServerCallback() || !_jsHandlers.empty());
 	}
 	
+	void setDelayTime(int millisecs)
+		/// Sets the delay time for the javascript callback
+	{
+		_delayTime = millisecs;
+	}
+	
+	int getDelayTime() const
+		/// Returns the delay time in milliseconds for the javascript callback
+	{
+		return _delayTime;
+	}
+	
+	bool getGroupEvents() const
+		/// Returns if events should be grouped together within the given _delayTime.
+		/// Every event that occurs within the tiem frame replaces the previous scheduled event
+		/// and restart the _delayTime wait.
+	{
+		return _group;
+	}
+	
+	void setGroupEvents(bool group)
+		/// Sets if events should be grouped together within the given _delayTime.
+		/// Every event that occurs within the tiem frame replaces the previous scheduled event
+		/// and restart the _delayTime wait.
+	{
+		_group = group;
+	}
 		
 private:
 	JSDelegates    _jsHandlers;
@@ -194,6 +221,11 @@ private:
 	std::size_t    _callbackPos;    /// Sets when the server callback should happen (the number defines how many jsHandlers are executed before the server callback)
 	std::string    _onSuccess;      /// code to execute when the server callback succeeds
 	std::string    _onFailure;      /// code to execute when the server callback fails
+	int            _delayTime;		/// delay Time in millisecs
+	bool           _group;			
+		/// defines if events should be grouped together. 
+		/// Requires a _delayTime greater zero, replaces an event within the delaytime with its newer version
+		/// Only effective for Javascript side of the event!
 };