bugfixes to table, new events

WebWidgets/ExtJS/include/Poco/WebWidgets/ExtJS/TableRenderer.h

@@ -74,6 +74,8 @@ public:
 	static const std::string EV_MOUSEDOWN;
 	static const std::string EV_KEYDOWN;
 	static const std::string EV_KEYPRESSED;
+	static const std::string EV_ROWSELECTED;
+	static const std::string EV_CELLSELECTED;
 	static const std::string HIDDEN_INDEX_ROW;
 	
 	TableRenderer();
@@ -98,6 +100,16 @@ public:
 		/// containing members (grid, record, column, row, value, cancel)!
 		/// obj.cancel must be set to false to forbid the edit
 		
+	static Poco::WebWidgets::JSDelegate createCellSelectedServerCallback(const Table* pTable);
+		/// Adds a javascript callback to inform the WebServer that the client has selected a cell
+		/// The Extjs handler offers a method signature of
+		///    cellselect : ( SelectionModel this, Number rowIndex, Number colIndex )
+		
+	static Poco::WebWidgets::JSDelegate createRowSelectedServerCallback(const Table* pTable);
+		/// Adds a javascript callback to inform the WebServer that the client has selected a row
+		/// The Extjs handler offers a method signature of
+		///    rowselect : ( SelectionModel this, Number rowIndex, Ext.data.Record r )
+		
 	static Poco::WebWidgets::JSDelegate createCellClickedServerCallback(const Table* pTable);
 		/// Adds a javascript callback to inform the WebServer that the client has clicked on a cell in the Table
 		/// Method signature is cellclick : ( Grid this, Number rowIndex, Number columnIndex, Ext.EventObject e )
@@ -106,7 +118,7 @@ public:
 		/// Adds a javascript callback to inform the WebServer that the client has clicke don a row
 		/// This event will only be added if the Table uses a Row selection model!
 		/// Single cell selection will trigger an exception!
-		/// Method signature is rowselect : ( SelectionModel this, Number rowIndex, Ext.Data.Record r )
+		/// Method signature is rowclick : ( Grid this, Number rowIndex, Ext.EventObject e )
 		
 	static Poco::WebWidgets::JSDelegate createBeforeCellClickedServerCallback(const Table* pTable);
 		/// Adds a javascript callback to inform the WebServer that the client has clicked on a cell in the Table

WebWidgets/ExtJS/src/PageRenderer.cpp

@@ -177,7 +177,8 @@ void PageRenderer::renderHead(const Renderable* pRenderable, const RenderContext
 		}
 		//close the panel
 		ostr << "]});";
-		
+		if (!pPage->getPostRenderCode().empty())
+			ostr << pPage->getPostRenderCode();
 		//close onReady
 		ostr << "});";
 		//close inline JS block

WebWidgets/ExtJS/src/TableRenderer.cpp

@@ -55,7 +55,7 @@ namespace ExtJS {
 
 
 const std::string TableRenderer::EV_CELLCLICKED("cellclick");
-const std::string TableRenderer::EV_ROWCLICKED("rowselect");
+const std::string TableRenderer::EV_ROWCLICKED("rowclick");
 const std::string TableRenderer::EV_BEFORECELLCLICKED("cellmousedown");
 const std::string TableRenderer::EV_BEFOREROWCLICKED("rowmousedown");
 const std::string TableRenderer::EV_BEFORECELLVALUECHANGED("validateedit");
@@ -66,6 +66,8 @@ const std::string TableRenderer::EV_MOUSEUP("mouseup");
 const std::string TableRenderer::EV_MOUSEDOWN("mousedown");
 const std::string TableRenderer::EV_KEYDOWN("keydown");
 const std::string TableRenderer::EV_KEYPRESSED("keypress");
+const std::string TableRenderer::EV_ROWSELECTED("rowselect");
+const std::string TableRenderer::EV_CELLSELECTED("cellselect");
 const std::string TableRenderer::HIDDEN_INDEX_ROW("hidIdx");
 
 
@@ -172,6 +174,40 @@ Poco::WebWidgets::JSDelegate TableRenderer::createRenderServerCallback(const Tab
 }
 
 
+
+Poco::WebWidgets::JSDelegate TableRenderer::createCellSelectedServerCallback(const Table* pTable)
+{
+	// cellselect : ( SelectionModel this, Number rowIndex, Number colIndex )
+	poco_check_ptr (pTable);
+	static const std::string signature("function(selMod,row,col)");
+	//extract the true row index from the last column!
+	std::string origRow("+selMode.getSelectedCell().record.get('");
+	origRow.append(Poco::NumberFormatter::format(static_cast<Poco::UInt32>(pTable->getColumnCount())));
+	origRow.append("')");
+	std::map<std::string, std::string> addParams;
+	addParams.insert(std::make_pair(Table::FIELD_COL, "+col"));
+	addParams.insert(std::make_pair(Table::FIELD_ROW, origRow));
+	addParams.insert(std::make_pair(RequestHandler::KEY_EVID, Table::EV_CELLSELECTED));
+	return Utility::createServerCallback(signature, addParams, pTable->id(), pTable->cellSelected.getOnSuccess(), pTable->cellSelected.getOnFailure());
+}
+
+
+Poco::WebWidgets::JSDelegate TableRenderer::createRowSelectedServerCallback(const Table* pTable)
+{
+	// rowselect : ( SelectionModel this, Number rowIndex, Ext.data.Record r )
+	poco_check_ptr (pTable);
+	static const std::string signature("function(selMod,row,rec)");
+	//extract the true row index from the last column!
+	std::string origRow("+rec.get('");
+	origRow.append(Poco::NumberFormatter::format(static_cast<Poco::UInt32>(pTable->getColumnCount())));
+	origRow.append("')");
+	std::map<std::string, std::string> addParams;
+	addParams.insert(std::make_pair(Table::FIELD_ROW, origRow));
+	addParams.insert(std::make_pair(RequestHandler::KEY_EVID, Table::EV_ROWSELECTED));
+	return Utility::createServerCallback(signature, addParams, pTable->id(), pTable->rowSelected.getOnSuccess(), pTable->rowSelected.getOnFailure());
+}
+
+
 Poco::WebWidgets::JSDelegate TableRenderer::createCellClickedServerCallback(const Table* pTable)
 {
 	poco_check_ptr (pTable);
@@ -207,9 +243,8 @@ Poco::WebWidgets::JSDelegate TableRenderer::createBeforeCellClickedServerCallbac
 Poco::WebWidgets::JSDelegate TableRenderer::createRowClickedServerCallback(const Table* pTable)
 {
 	poco_check_ptr (pTable);
-	poco_assert (pTable->getSelectionModel() != Table::SM_CELL);
 	
-	/// Method signature is rowselect : ( SelectionModel this, Number rowIndex, Ext.Data.Record r )
+	/// Method signature is rowclick : ( Grid this, Number rowIndex, Ext.EventObject e )
 	static const std::string signature("function(sm,row,r)");
 	//extract the true row index from the last column!
 	std::string origRow("+r.get('");
@@ -297,33 +332,28 @@ void TableRenderer::renderProperties(const Table* pTable, const RenderContext& c
 	bool written = false;
 	if (editable)
 	{
-		JSDelegate jsDel("function(obj){obj.grid.getStore().commitChanges();}");
+		if (pTable->cellValueChanged.hasJavaScriptCode())
-		std::list<JSDelegate> modList(pTable->cellValueChanged.jsDelegates());
+			written = Utility::writeJSEvent(ostr, EV_AFTEREDIT, pTable->cellValueChanged, &TableRenderer::createCellValueChangedServerCallback, pTable);
-		modList.push_back(jsDel);
+			
-		if (pTable->cellValueChanged.willDoServerCallback())
-			written = Utility::writeJSEvent(ostr, EV_AFTEREDIT, modList, 
-					TableRenderer::createCellValueChangedServerCallback(pTable), 
-					pTable->cellValueChanged.getServerCallbackPos(), pTable->cellValueChanged.getDelayTime(), pTable->cellValueChanged.getGroupEvents());
-		else					
-			written = Utility::writeJSEvent(ostr, EV_AFTEREDIT, modList, pTable->cellValueChanged.getDelayTime(), pTable->cellValueChanged.getGroupEvents());
 		if (pTable->beforeCellValueChanged.hasJavaScriptCode())
 		{	
 			if (written) ostr << ",";
 			written = Utility::writeJSEvent(ostr, EV_BEFORECELLVALUECHANGED, pTable->beforeCellValueChanged, 
 						&TableRenderer::createBeforeCellValueChangedServerCallback, pTable);
 		}
-		if (pTable->keyDown.hasJavaScriptCode())
+	}
-		{
+	
-			if (written) ostr << ",";
+	if (pTable->keyDown.hasJavaScriptCode())
-			written = Utility::writeJSEvent(ostr, EV_KEYDOWN, pTable->keyDown,
+	{
-						&TableRenderer::createKeyDownServerCallback, pTable);
+		if (written) ostr << ",";
-		}
+		written = Utility::writeJSEvent(ostr, EV_KEYDOWN, pTable->keyDown,
-		if (pTable->keyPressed.hasJavaScriptCode())
+					&TableRenderer::createKeyDownServerCallback, pTable);
-		{
+	}
-			if (written) ostr << ",";
+	if (pTable->keyPressed.hasJavaScriptCode())
-			written = Utility::writeJSEvent(ostr, EV_KEYPRESSED, pTable->keyPressed,
+	{
-						&TableRenderer::createKeyPressedServerCallback, pTable);
+		if (written) ostr << ",";
-		}
+		written = Utility::writeJSEvent(ostr, EV_KEYPRESSED, pTable->keyPressed,
+					&TableRenderer::createKeyPressedServerCallback, pTable);
 	}
 	
 	if (pTable->cellClicked.hasJavaScriptCode())
@@ -340,6 +370,20 @@ void TableRenderer::renderProperties(const Table* pTable, const RenderContext& c
 										&TableRenderer::createBeforeCellClickedServerCallback ,pTable);
 	}
 	
+	if (pTable->rowClicked.hasJavaScriptCode())
+	{
+		if (written) ostr << ",";
+		written = Utility::writeJSEvent(ostr, EV_CELLCLICKED, pTable->rowClicked,
+										&TableRenderer::createRowClickedServerCallback, pTable);
+	}
+	
+	if (pTable->beforeRowClicked.hasJavaScriptCode())
+	{
+		if (written) ostr << ",";
+		written = Utility::writeJSEvent(ostr, EV_BEFORECELLCLICKED, pTable->beforeRowClicked,
+										&TableRenderer::createBeforeRowClickedServerCallback ,pTable);
+	}
+	
 	if (pTable->afterRender.hasJavaScriptCode())
 	{
 		if (written) ostr << ",";
@@ -376,18 +420,25 @@ void TableRenderer::renderProperties(const Table* pTable, const RenderContext& c
 			ostr << ",selModel:new Ext.grid.RowSelectionModel({singleSelect:true";
 		else if (pTable->getSelectionModel() == Table::SM_MULTIROW)
 			ostr << ",selModel:new Ext.grid.RowSelectionModel({singleSelect:false";
-		if (pTable->rowClicked.hasJavaScriptCode() || pTable->beforeRowClicked.hasJavaScriptCode())
+		if (pTable->rowSelected.hasJavaScriptCode())
 		{
 			ostr << ",listeners:{";
-			written = Utility::writeJSEvent(ostr, EV_ROWCLICKED, pTable->rowClicked,
+			written = Utility::writeJSEvent(ostr, EV_ROWSELECTED, pTable->rowSelected,
-										&TableRenderer::createRowClickedServerCallback, pTable);
+										&TableRenderer::createRowSelectedServerCallback, pTable);
-				
+			ostr << "}";
-			if (pTable->beforeRowClicked.hasJavaScriptCode())
+		}
-			{
+		ostr << "})"; //close selModel
-				if (written) ostr << ",";
+	}
-				written = Utility::writeJSEvent(ostr, EV_BEFOREROWCLICKED, pTable->beforeRowClicked,
+	else
-										&TableRenderer::createBeforeRowClickedServerCallback, pTable);	
+	{
-			}
+		// a cell selection model is the default but if we want to add js listeners we have to 
+		// define it
+		ostr << ",selModel:new Ext.grid.CellSelectionModel({";
+		if (pTable->cellSelected.hasJavaScriptCode())
+		{
+			ostr << "listeners:{";
+			written = Utility::writeJSEvent(ostr, EV_CELLSELECTED, pTable->cellSelected,
+										&TableRenderer::createCellSelectedServerCallback, pTable);
 			ostr << "}";
 		}
 		ostr << "})"; //close selModel

WebWidgets/include/Poco/WebWidgets/Page.h

@@ -104,6 +104,16 @@ public:
 		
 	const std::vector<std::string>& dynamicFunctions() const;
 		/// Returns all dynamic functions
+		
+	void setPostRenderCode(const std::string& js);
+		/// Adds Javascript code that should be executed after the page code was written. The difference to afterRender
+		/// is that afterRender is a JS Event executed from within the rendering pipeline of the browser
+		/// (ie. changes to the GUI might block the browser indefinitely) whereas
+		/// post render code is executed immediately after the JS code that generates the GUI
+		/// (ie. it is not necessarily rendered, no data loaded but thread-safe!)
+		
+	const std::string& getPostRenderCode() const;
+		/// Returns post rnedre code. Can be an empty string
 	
 protected:
 	Page(const std::string& name, const std::type_info& type);
@@ -119,6 +129,7 @@ private:
 	std::string     _text;
 	ResourceManager _rm;
 	std::vector<std::string> _jsCode;
+	std::string     _postRenderCode;
 };
 
 
@@ -155,6 +166,18 @@ inline const std::vector<std::string>& Page::dynamicFunctions() const
 }
 
 
+inline void Page::setPostRenderCode(const std::string& js)
+{
+	_postRenderCode = js;
+}
+
+		
+inline const std::string& Page::getPostRenderCode() const
+{
+	return _postRenderCode;
+}
+
+
 } } // namespace Poco::WebWidgets
 
 

WebWidgets/include/Poco/WebWidgets/Table.h

@@ -79,6 +79,8 @@ public:
 	static const std::string EV_MOUSEDOWN;
 	static const std::string EV_KEYDOWN;
 	static const std::string EV_KEYPRESSED;
+	static const std::string EV_ROWSELECTED;
+	static const std::string EV_CELLSELECTED;
 	
 	struct WebWidgets_API CellClick
 	{
@@ -107,6 +109,10 @@ public:
 		LoadData(Poco::Net::HTTPServerResponse* pResponse, Table* pTable, int firstRow, int rowCnt);
 	};
 	
+	JavaScriptEvent<std::size_t> rowSelected; /// fires the row selected event
+	
+	JavaScriptEvent<Table::CellClick> cellSelected; /// fires the cell selected event
+	
 	JavaScriptEvent<std::size_t> rowClicked; /// fires the row clicked event
 	
 	JavaScriptEvent<std::size_t> beforeRowClicked; /// fires the before row clicked event

WebWidgets/src/Table.cpp

@@ -61,6 +61,8 @@ const std::string Table::EV_MOUSEUP("mouseup");
 const std::string Table::EV_MOUSEDOWN("mousedown");
 const std::string Table::EV_KEYDOWN("keydown");
 const std::string Table::EV_KEYPRESSED("keypressed");
+const std::string Table::EV_ROWSELECTED("rowselected");
+const std::string Table::EV_CELLSELECTED("cellselected");
 
 
 Table::Table(const TableColumns& tc, TableModel::Ptr pModel):
@@ -219,25 +221,85 @@ void Table::handleAjaxRequest(const Poco::Net::NameValueCollection& args, Poco::
 			setValue(Poco::Any(val), row, col);
 		response.send();
 	}
+	else if (ev == EV_BEFORECELLVALUECHANGED)
+	{
+		const std::string& val = args.get(FIELD_VAL);
+		Poco::Any oldValue;
+		if (getColumnCount() > col)
+			oldValue = getValue(row, col);
+			
+		Cell::Ptr pCell = getColumns()[col]->getCell();
+		Formatter::Ptr pForm;
+		if (pCell)
+			pForm = pCell->getFormatter();
+		
+		if (pForm)
+		{
+			Poco::Any newValue = pForm->parse(val);
+			CellValueChange cvc(row, col, oldValue, newValue);	
+			beforeCellValueChanged(this, cvc);
+		}
+		else
+		{
+			Poco::Any newValue(val);
+			CellValueChange cvc(row, col, oldValue, newValue);	
+			beforeCellValueChanged(this, cvc);
+		}
+		response.send();
+	}
 	else if (ev == EV_AFTERLOAD)
 	{
 		Table* pTable = this;
 		afterLoad(this, pTable);
+		response.send();
 	}
 	else if (ev == EV_RENDER)
 	{
 		Table* pTable = this;
 		afterRender(this, pTable);
+		response.send();
 	}
 	else if (ev == EV_MOUSEUP)
 	{
 		Table* pTable = this;
 		mouseUp(this, pTable);
+		response.send();
 	}
 	else if (ev == EV_MOUSEDOWN)
 	{
 		Table* pTable = this;
 		mouseDown(this, pTable);
+		response.send();
+	}
+	else if (ev == EV_KEYDOWN)
+	{
+		Table* pTable = this;
+		keyDown(this, pTable);
+		response.send();
+	}
+	else if (ev == EV_KEYPRESSED)
+	{
+		Table* pTable = this;
+		keyPressed(this, pTable);
+		response.send();
+	}
+	else if (ev == EV_CELLSELECTED)
+	{
+		if (col < 0 || row < 0 || col >= getColumnCount())
+			throw InvalidArgumentException("col/row out of range");
+
+		CellClick ev(row, col);
+		cellSelected(this, ev);
+		response.send();
+	}
+	else if (ev == EV_ROWSELECTED)
+	{
+		if (row < 0 )
+			throw InvalidArgumentException("row out of range");
+
+		std::size_t theRow(row);
+		rowSelected(this, theRow);
+		response.send();
 	}
 }
 
@@ -248,7 +310,8 @@ void Table::setValue(const Poco::Any& val, std::size_t row, std::size_t col)
 	if (getRowCount() > row)
 		oldValue = getValue(row, col); 
 	CellValueChange ev(row, col, oldValue, val);
-	_pModel->setValue(val, row, col);
+	beforeCellValueChanged(this,ev);
+	_pModel->setValue(ev.newValue, row, col);
 	cellValueChanged(this, ev);
 }