I have been working on extending QueryReadStore to use a dojo.rpc.JsonService for data retrieval and wanted to provide this information for discussion.

Goals:
1. Have Grid with scrollable paging as described here: http://dojotoolkit.org/book/dojo-book-0-9-1-0/part-2-dijit-dojo-widget-l...
2. Retrieve data via JSON-RPC from services implemented with IBM's RPCAdapter, as described here: http://publib.boulder.ibm.com/infocenter/wasinfo/v6r0/index.jsp?topic=/c...

Approach:
1. Extend QueryReadStore to retrieve data via dojo.rpc.JsonService

Rational:
I choose to extend QueryReadStore because because It seemed like the most logical choice for me. It has all of the capabilities to support scrollable paging (as described above) and few changes were needed to add the call to the JsonService.

Here is my extension of QueryReadStore:

dojo.provide("emory.data.JSONRPCQueryReadStore_05");
dojo.require("dojox.data.QueryReadStore");
dojo.require("dojo.rpc.JsonService")
dojo.declare("emory.data.JSONRPCQueryReadStore", dojox.data.QueryReadStore, {
  
    /*
    // Extends dojox.data.QueryReadStore to use dojo.rpc.JsonService
    // for retrieving Items from an IBM RPCAdapter.
    */
    
    /*
    // creates service (dojo.rpc.JsonService) from params.url
    // and introspects the serviceMethod to build array of argument 
    // names for invoking serviceMethod
    // All of this only needs to be done once so constructor makes good choice.
    */
    constructor: function(/* Object */ params){
    
        // create dojo.rpc.JsonService
        // JsonService is called to get SMD
    	this.service = new dojo.rpc.JsonService(params.url);

    	// set service method that will be invoked
    	this.serviceMethod = params.serviceMethod;
    	
    	// set service method argument names
    	this.serviceArgNames = []
    	
    	// introspect service method to get argument names
    	var smdMethodArray = this.service.smd.methods
    	for (var i in smdMethodArray) {
    		var smdMethod = smdMethodArray[i]
    		if (smdMethod.name == this.serviceMethod) {
    		    var paramArray = smdMethod.parameters
    		    for (var j in paramArray) {
		    		this.serviceArgNames[j] = paramArray[j].name;	
		    	}
    			break;
    		}
    	}
	},
		
	/*
    // overrides superclass method to call JsonService for fetching items
    */ 
    _fetchItems: function(request, fetchHandler, errorHandler){
		var serverQuery = typeof request["serverQuery"]=="undefined" ? request.query : request.serverQuery;
		//Need to add start and count
		if(!this.doClientPaging){
			serverQuery = serverQuery||{};
			serverQuery.start = request.start?request.start:0;
			// Count might not be sent if not given.
			if (request.count) {
				serverQuery.count = request.count;
			}
		}
		// Compare the last query and the current query by simply json-encoding them,
		// so we dont have to do any deep object compare ... is there some dojo.areObjectsEqual()???
		if(this.doClientPaging && this._lastServerQuery!==null &&
			dojo.toJson(serverQuery)==dojo.toJson(this._lastServerQuery)
			){
			fetchHandler(this._items, request);
		}else{
		
		    // invokeJSONService(request)
		    var serviceHandler = this.invokeJSONService(request)

            // Add Callbacks to JsonService
			serviceHandler.addCallback(dojo.hitch(this, function(result){
				this._items = [];

                // ** customized data translation **
                // Modified to work with Json result expected from IBM RPCAdapter.
                // Result returned is very similar to the format of items but 
                // different enough I had to make this change.
				for(var i in result){
					this._items.push({i:result[i], r:this});
				}
				
				// The identifier is not provided in the result from RPCAdapter
				// May address this later, setting to result.identifier for now.
				var identifier = result.identifier;
				
				this._itemsByIdentity = {};
				if(identifier){
					this._identifier = identifier;
					for(i = 0; i < this._items.length; ++i){
						var item = this._items[i].i;
						var identity = item[identifier];
						if(!this._itemsByIdentity[identity]){
							this._itemsByIdentity[identity] = item;
						}else{
							throw new Error("dojo.data.QueryReadStore:  The json data as specified by: [" + this._url + "] is malformed.  Items within the list have identifier: [" + identifier + "].  Value collided: [" + identity + "]");
						}
					}
				}else{
					this._identifier = Number;
					for(i = 0; i < this._items.length; ++i){
						this._items[i].n = i;
					}
				}
				
				// TODO actually we should do the same as dojo.data.ItemFileReadStore._getItemsFromLoadedData() to sanitize
				// (does it really sanititze them) and store the data optimal. should we? for security reasons???
				fetchHandler(this._items, request);
			}));
			serviceHandler.addErrback(function(error){
				errorHandler(error, request);
			});
			
			// Generate the hash using the time in milliseconds and a randon number.
			// Since Math.randon() returns something like: 0.23453463, we just remove the "0."
			// probably just for esthetic reasons :-).
			this.lastRequestHash = new Date().getTime()+"-"+String(Math.random()).substring(2);
			this._lastServerQuery = serverQuery;
		}
	},
    
    /*
    // invokes service by retrieving serviceMethod parameters from the serverQuery by name
    */
    invokeJSONService: function(request){
        // hold serviceMethod arguments in array
    	var serviceArgValues = [];
    	
    	// get serviceMethod arguments from serverQuery by name defined in SMD
    	for (var i in this.serviceArgNames) {
    		serviceArgValues[i] = request.serverQuery[this.serviceArgNames[i]];
    	}
		
		// call service method    	
		return this.service[this.serviceMethod].apply(this, serviceArgValues);
    }
    
});

Here is an example of a new instance being created programmatically.

        Test dojox.Grid Basic
        
        
		        @import "dojox/grid/_grid/tundraGrid.css";
		        @import "dijit/themes/tundra/tundra.css";
		        @import "dojo/resources/dojo.css"
                body {
                        font-size: 0.9em;
                        font-family: Geneva, Arial, Helvetica, sans-serif;
                }
                .heading {
                        font-weight: bold;
                        padding-bottom: 0.25em;
                }
                #grid, #grid2 {
						width: 65em;
						height: 25em;
						padding: 1px;
				}
        
        
        
        


Query Read Store Paging Grid

		
             
        		// creates serverQuery-parameter
		        var row  = inRowIndex || 0;
		        var params = {
        		    start: row,
		            count: inCount || this.rowsPerPage,
        		    serverQuery: dojo.mixin(
		              { start: row,
        		        count: inCount || this.rowsPerPage,
                		sort:(this.sortColumn || '')
		              },
        		      this.query
		            ),
        		    query: this.query,
		            // onBegin: dojo.hitch(this, "beginReturn"),
        		    onComplete: dojo.hitch(this, "processRows")
		        }
        		this.store.fetch(params);
		    
    		
	        	// should return total count (fetch from server), not "rowsPerPage"
    		    return 15000;
		    
	    	
		        // clears old data to force loading of new, then requests new rows
        		this.clearData();
		        this.sortColumn = colIndex;
        		this.requestRows();
		    
	    	
		        // edited not to reset the store
		        this.data = [];
		        this.allChange();
		    
	    	
		        // always true
		        return true;
		    
		
        
             
        

             
        	
                var grid = dijit.byId('grid');
				// Debug the Event
                console.debug(event);

				// Get the Row
                console.debug("getting rowIndex(" + event.rowIndex + ")");
				thisRow = myModel.getRow(event.rowIndex);
				console.debug(thisRow);

                // Get the EventId from the Row Object
                //eventId = thisRow.eventId;
                //console.debug('eventId: ' + eventId);
			
			
        

I would appreciate any feedback on this approach.

Thanks,
Tom