// ---------------------------------------------------------------
// SqlCtlDialog
// ---------------------------------------------------------------
function SqlCtlDialog(wrkfolder) {
	
	require(["dojo/text!desktop/text/sqlctldialog.html",
				"dijit/layout/ContentPane",
				"dijit/Dialog", "dijit/registry", 
				"dijit/form/TextBox", "dijit/form/Button", 
				"dojo/dom-construct", "dojo/dom"], 
	function(snippet, ContentPane, Dialog, registry, TextBox, Button, domConstruct, dom) {
				
		//console.log ("SqlCtlDiqalog text: ", snippet);	
		
		if (registry.byId("sqlCtlDialog")) {
			registry.byId("sqlCtlDialog").show();
			return;
		}
			
		var sqlCtlDialog = new Dialog({
			id: "sqlCtlDialog",
			title: "SQL Controls", 
			style: "width: 1000px; height: 700px;",
			content: snippet
		});
		sqlCtlDialog.show();
		
		SqlCtlLoad(wrkfolder);

	});	
} 
// ---------------------------------------------------------------
// SqlCtlLoad: 
// ---------------------------------------------------------------
function SqlCtlLoad(wrkfolder) {
	
		
	console.log ("SqlCtlLoad wrkfolder: ", wrkfolder);

	require(["dojo/ready", "dojo/_base/json", "dojo/request/xhr", "dijit/registry"],
	function(ready, dojo, xhr, registry){
		var urlString = wrkfolder.sqlctlpath;
		xhr(urlString, {
				handleAs: "text",
				method: "GET"
			}).then(function(data){
				var jsonResponse = dojo.fromJson(data);
				console.log("SqlCtlLoad jsonResponse: ", jsonResponse);
				SqlCtlNav(registry, jsonResponse);
			}, function(err){
				// Handle the error condition
			}, function(evt){
				// XHR2 events
		});	
	});	
					
} 

// -----------------------------------------------------------
// 
// -----------------------------------------------------------
function SqlCtlNav(registry, jsonResponse) {

	var sql = jsonResponse;
	hugmarSettings.sql = sql;
	//console.log ("SqlCtl sql", sql);
	
	require(["dojo/dom", "dojo/dom-construct"],
	function(dom, domConstruct){
		
		if (sql.env.cltype == "SUBFILE") {
			domConstruct.destroy("hdmSqlCtlGrpBy");
			domConstruct.destroy("hdmSqlCtlHaving");
			SqlCtlWhere(sql);		// Where
			SqlCtlOrdBy(sql);		// Order By
			SqlCtlButtons(sql);
		}
		
		if (sql.env.cltype == "SUBFGROUP") {
			SqlCtlWhere(sql);		// Where
			SqlCtlGrpBy(sql);		// Group By
			SqlCtlOrdBy(sql);		// Order By
			SqlCtlHaving(sql);		// Having
			SqlCtlButtons(sql);
		}
	
		return;
	});									       	
} 
// -----------------------------------------------------------
//  
// -----------------------------------------------------------
function SqlCtlButtons(sql) {
	
	//console.log ("SqlCtlButtons I am here: ");
	
	require(["dojo/dom", "dojo/dom-construct", "dijit/registry"],
	function(dom, domConstruct, registry){
		
		var sqlButton = registry.byId("hdmSqlCtlBut0");
		if (sqlButton) {
			sqlButton.destroyRecursive(true);
		}
		
		var sqlButton = registry.byId("hdmSqlCtlBut1");
		if (sqlButton) {
			sqlButton.destroyRecursive(true);
		}
		
		var sqlButton = registry.byId("hdmSqlCtlBut2");
		if (sqlButton) {
			sqlButton.destroyRecursive(true);
		}
	
		var parNode	= dom.byId("hdmSqlCtlButtons");
	
		// Confirm
		parNode.appendChild(domConstruct.create("div", {id: "hdmSqlCtlBut0"}));
		SqlCtlOneBut("hdmSqlCtlBut0", "Confirm", "gif38", "confirm", "Confirm Sql Changes", sql);
	
		// Cancel
		parNode.appendChild(domConstruct.create("div", {id: "hdmSqlCtlBut1"}));
		SqlCtlOneBut("hdmSqlCtlBut1", "Cancel", "gif33", "cancel", "Cancel Sql Changes", sql);
		
		// Refresh
		//parNode.appendChild(domConstruct.create("div", {id: "hdmSqlCtlBut2"}));
		//SqlCtlOneBut("hdmSqlCtlBut2", "Refresh", "gif42", "refresh", "Refresh Sql Edit Panes", sql);
	
	return;
	
	});
			
} 
// -----------------------------------------------------------
//
// -----------------------------------------------------------
function SqlCtlOneBut(domID, label, icon, action, title, sql) { 

	require(["dojo/dom", "dijit/registry", "dijit/form/Button"],
	function(dom, registry, Button){
		
		//console.log ("SqlCtlOneBut I am here: ");
		
		var sqlButton = registry.byId(domID);
		if (sqlButton) {
			sqlButton.destroyRecursive(true);
		}
		var dom = dom.byId(domID);
		var sqlButton = new Button({
			label: label, 
			iconClass: icon, 
			jsId: action,
			sqlEnv: sql.env,
			onClick: function(evt) {
				var butNode = dijit.getEnclosingWidget(evt.target);
				//console.log("SqlCtlOneBut onClick butNode: ", butNode);
				
				switch (butNode.jsId) {
					case 'cancel':		SqlCtlCancel(butNode.jsId, butNode.sqlEnv); 	break;
					case 'confirm':		SqlCtlConfirm(butNode.jsId, butNode.sqlEnv); break;
					case 'refresh':		SqlCtlWhere(sql); 							break;
					}	
			},
			title: title
		}, dom); 
	
	});
}  
// -----------------------------------------------------------
// Remove Sql Tab
// -----------------------------------------------------------
function SqlCtlCancel(sqlType, sqlEnv) {
	
	require(["dojo/ready", "dojo/_base/json", "dojo/request/xhr", "dijit/registry"], 
	function(ready, dojo, xhr, registry){
		
		console.log ("SqlCtlCancel: hdmSqlCtl ", hugmarSettings);
		
		var jsCaller 	= "SqlCtlCancel"; 
		var jsonObj  	= SqlCtlSetJsonObj(jsCaller,"HWEBNAFB2","sqlcancel", hugmarSettings);
		jsonObj.procparm 	= sqlType;
		jsonObj.sqlrow.type = sqlType;
	
		var jsonString  = dojo.toJson(jsonObj);
		var urlString 	= hugmarSettings.host.pgmdir + "/hwebhtp120.pgm?json=" + jsonString;
		
		dojo.xhrGet({
			url: urlString, handleAs: "json",
			load: function(jsonResponse, ioArgs) {
				console.log("SqlCtlCancel  jsonResponse: ", jsonResponse);
				if (registry.byId("sqlCtlDialog")) {
					registry.byId("sqlCtlDialog").destroyRecursive(false);
					return jsonResponse;
				}			
				return jsonResponse; },
			error: function(jsonResponse, ioArgs) {
				SqlCtlXhrGetError("SqlCtlCancel", ioArgs);
				return jsonResponse; }
			});
		
		return;	
	
	});
	
	return;
}
// -----------------------------------------------------------
// SqlCtlConfirm: function to Confirm Sql Control Change 
// -----------------------------------------------------------
function SqlCtlConfirm(sqlType, sqlEnv) {
	
	require(["dojo/ready", "dojo/dom", "dojo/_base/json", "dojo/request/xhr", "dijit/registry"], 
	function(ready, dom, dojo, xhr, registry){
		
		console.log ("SqlCtlConfirm: hdmSqlCtl ", hugmarSettings);
		
		var jsCaller 	= "SqlCtlConfirm"; 
		var jsonObj  	= SqlCtlSetJsonObj(jsCaller,"HWEBNAFB2","sqlconfirm", hugmarSettings);
		jsonObj.gridenv	 	= sqlEnv;
		jsonObj.procparm 	= "sqlconfirm";
		jsonObj.sqlrow.type = sqlType;
	
		var jsonString  = dojo.toJson(jsonObj);
		var urlString 	= hugmarSettings.host.pgmdir + "/hwebhtp120.pgm?json=" + jsonString;
		
		if (registry.byId("sqlCtlDialog")) {
			registry.byId("sqlCtlDialog").destroyRecursive(false);
		}
		registry.byId("hdmMainStandby").show();
		
		dojo.xhrGet({
			url: urlString, handleAs: "json",
			load: function(jsonResponse, ioArgs) {
				//console.log("SqlCtlConfirm  jsonResponse: ", jsonResponse);
				SqlCtlConfirmRsp(registry, dom, jsonResponse, sqlEnv);		
				return jsonResponse; },
			error: function(jsonResponse, ioArgs) {
				SqlCtlXhrGetError("SqlCtlConfirm", ioArgs);
				return jsonResponse; }
			});
		
		return;	
	
	});
	
}
// -----------------------------------------------------------
// Sql Control Confirm Response
// -----------------------------------------------------------
function SqlCtlConfirmRsp(registry, dom, jsonResponse, sqlEnv) {
	
	
	console.log ("SqlCtlConfirmRsp: jsonResponse ", jsonResponse);
	//alert("Send Refresh Here")
	
	jsonResponse.javascript = "hdfTopToolServer";
	hdfiServerRsp(jsonResponse)
	
	return;
}

// -----------------------------------------------------------
// Set Standard JSON URL Parameters
// -----------------------------------------------------------
function SqlCtlSetJsonObj(jsCaller, procId, docName, hugmarSettings) {
	
	var jsonObj = {
		javascript:	jsCaller,
		procid:     procId,
		procparm:   " ",
		handle: 	hugmarSettings.host.handle,
		userid: 	hugmarSettings.nav.username,
		usercls: 	hugmarSettings.host.userclass,
		docfolder: 	hugmarSettings.host.wrkfolder,
		docname:	docName + ".json",
		format:		"json",
		sqlrow: 	{},
		sqlenv: 	{},
		gridenv: 	{},
		webid:		new Date().getTime()	
	};
					
	return jsonObj;
}
// -----------------------------------------------------------
// SqlCtl HTTP Error
// -----------------------------------------------------------
function SqlCtlXhrGetError(origin, ioArgs) {
	
	var message = "";
	switch(ioArgs.xhr.status){
		case 200:
			message = origin + ": The IBM server responded normally, but an error occurred on the JavaScript client";
			break;
		case 404:
			message = origin + ": The requested page on the IBM server was not found";
			break;
		case 500:
			message = origin + ": The IBM server reported an error.";
			break;
		case 407:
			message = origin + ": You need to authenticate with a proxy.";
			break;
		default:
			message = origin + ": Unknown error.";
	}

	require(["dojo/ready", "dijit/Dialog"], 
	function(ready, Dialog){
		var dialog = new Dialog({
			title: "SqlCtlXhrGet HTTP Server Error: ", 
			style: "width: 400px",
			content: message + " " + "Please Contact IT"});
		dialog.show();
	});
	return;
	
}

// -----------------------------------------------------------
// SqlCtlWhere: 
// ----------------------------------------------------------
function SqlCtlWhere(sql) {
	
	//console.log("SqlCtlWhere sql.whedata: ", sql.whedata);
	
	require(["dojo/dom", "dojo/dom-construct", "dijit/layout/ContentPane", "dijit/registry"],
	function(dom, domConstruct, ContentPane, registry){
		
		if (registry.byId("hdmSqlCtlWhereGrid")) {
			registry.byId("hdmSqlCtlWhereGrid").destroyRecursive(true);
		}
		
		var dgridDomNode = domConstruct.create("div", {id: "hdmSqlCtlWhereGrid"});	
		domConstruct.place(dgridDomNode, "hdmSqlCtlWherePane");
		SqlCtlWhereGrid(sql);		// Grid
	
	});
	
	return;
}
// ----------------------------------------------------------
// SqlCtlWhereGrid: 
// ----------------------------------------------------------
function SqlCtlWhereGrid(sql) {
	
	//console.log("SqlCtlWhereGrid sql: ", sql);
	
	require(["dgrid/OnDemandGrid", 
			"dgrid/Selection", 
			"dgrid/Keyboard",
			"dgrid/selector", 
			"dgrid/Editor", 
			"dgrid/extensions/ColumnHider", 
			"dgrid/extensions/DijitRegistry",  
			"dijit/form/FilteringSelect", 
			"dijit/registry",
			"dstore/Memory", "dstore/Trackable",
			"dojo/store/Memory", "dojo/store/Observable", 
			"dojo/data/ObjectStore", "dojo/dom", 
			"dojo/dom-style", "dojo/_base/declare", 
			"dojo/_base/lang", "dojo/domReady!"],
	function(Grid,  
			Selection,
			Keyboard,
			selector,  
			Editor, 
			ColumnHider, 
			DijitRegistry, 
			FilteringSelect, 
			registry,
			Memory, Trackable,
			DojoMemory, Observable, 
			ObjectStore, dom, 
			domStyle, declare, lang){
				
			var whereCol = SqlCtlWhereCol(sql);
			
			var TrackableMemory = declare([Memory, Trackable]);
			whereStore = new TrackableMemory({
				data: sql.whedata, 
				idProperty: 'id'
			});
				
			if (registry.byId("hdmSqlCtlWhereGrid")) {
				grid = registry.byId("hdmSqlCtlWhereGrid");
				//console.log("grid.refresh: " + grid);
				grid.refresh();
				return;
			}
			else {
				var grid = new (declare([Grid, Selection, Editor, DijitRegistry, Keyboard]))({
					id : "hdmSqlCtlWhereGrid",
					collection: whereStore,
					columns: whereCol,
					selectionMode: "none"
				}, "hdmSqlCtlWhereGrid"); 
			}
			
			//console.log("SqlCtlWhereGrid grid: ", grid);
			
			grid.on("dgrid-datachange", function(evt){
				var rowid  = grid.cell(evt).row.data.id;
				var colid = grid.cell(evt).column.id;
				
				var rowInt = parseInt(rowid);
				var wheData = hugmarSettings.sql.whedata[rowInt-1];
				switch (colid) {
					case 'andor':	wheData.andor	=	evt.value; 	break;
					case 'brck1':	wheData.brck1	=	evt.value; 	break;
					case 'fldname': wheData.fldname	=	evt.value; 	break;
					case 'oper':	wheData.oper	=	evt.value; 	break;
					case 'opand':	wheData.opand	=	evt.value; 	break;
					case 'brck2':	wheData.brck2	=	evt.value; 	break;
					default: console.log("SqlCtlWhereEdit Unknown Column ID: ", colid);
				}
				wheData.confirm = 'x';
				hugmarSettings.sql.whedata[rowInt-1] = wheData;
				SqlCtlWhereGrid(hugmarSettings.sql);
				return;
			});	
				
			
			
			grid.on(".dgrid-cell:click", function(evt) {
				evt.preventDefault(); // prevent default browser context menu
				var selectedRow  = grid.cell(evt).row.data;
				var selectedCell = grid.cell(evt).column;
				var rowId  		 = selectedRow.id;
				if (selectedCell.field == "confirm" && selectedRow.confirm == "x") {
					//console.log("cell clicked: evt: ", evt);
					//console.log("cell clicked: selectedCell.field: ", selectedCell.field);
					console.log("cell clicked: selectedRow: ", selectedRow);
					SqlCtlWhereEdit("where", selectedRow, sql.env);
					return;
				}
			});
			
		});
		
	return;
}

// -----------------------------------------------------------
// Edit and Error Check Where Cell
// -----------------------------------------------------------
function SqlCtlWhereEdit(sqlType, selectedRow, sqlEnv) {

	require(["dojo/ready", "dojo/_base/json", "dojo/request/xhr", "dijit/registry"], 
	function(ready, dojo, xhr, registry){
		
		var rowInt = parseInt(selectedRow.id);
		var wheData = hugmarSettings.sql.whedata[rowInt-1];
	
		//console.log("SqlCtlWhereEdit wheData Before Replace: ", wheData);
		wheData.opand = globalModifyCell(wheData.opand);
		//console.log("SqlCtlWhereEdit wheData After Replace: ", wheData);
		
		var jsCaller		= "SqlCtlWhereEdit";
		var jsonObj  		= SqlCtlSetJsonObj(jsCaller,"HWEBNAFB2", "SqlCtl", hugmarSettings);
		jsonObj.procparm 	= "sqlchange";
		jsonObj.sqlenv			= sqlEnv;
		jsonObj.sqlrow 			= wheData;
		jsonObj.sqlrow.sqltype 	= sqlType;
		jsonObj.sqlrow.rrn 		= selectedRow.id;
		jsonObj.sqlrow.filler 	= " ";
		
		var jsonString  = dojo.toJson(jsonObj);
		//console.log("SqlCtlWhereEdit jsonString: ", jsonString);
	
		var urlString 	= hugmarSettings.host.pgmdir + "/hwebhtp120.pgm?json=" + jsonString;
		
		dojo.xhrGet({
			url: urlString, handleAs: "json",
			load: function(jsonResponse, ioArgs) {
				hugmarSettings.sql.whedata = jsonResponse.whedata;
				console.log("SqlCtlWhereEdit  hugmarSettings.sql: ", hugmarSettings.sql);
				SqlCtlWhere(hugmarSettings.sql);		
				return jsonResponse; },
			error: function(jsonResponse, ioArgs) {
				SqlCtlXhrGetError("SqlCtlWhereEdit", ioArgs);
				return jsonResponse; }
			});
		
	});				
		
	return;          	
} 
// -----------------------------------------------------------
// Get Sql Where Columns:
// -----------------------------------------------------------
function SqlCtlWhereCol(sql) {

	var whereCol = [];
	
	require(["dgrid/Editor",
			"dijit/form/CheckBox",  
			"dijit/form/ComboBox", 
			"dijit/form/FilteringSelect", 
			"dojo/store/Memory", 
			"dojo/store/Observable" ],
	function(Editor,
			CheckBox,    
			ComboBox, 
			FilteringSelect, 
			DojoMemory, 
			Observable ){

	whereCol = [
				{field: "id", id: "id", label: "", className: ["dgsshidden"]},
				{field: "confirm", id: "confirm", label: " ", className: ["dgss40px"], sortable: false,
					formatter: function(val){
						switch (val) {
							case '1': image = '<img src="desktop/img/Toolbar/gif/16x16/1.gif" ' + ' alt="1" ' + "/>";	break;	// Blank
							case '2': image = '<img src="desktop/img/Toolbar/gif/16x16/38.gif" ' + 'alt="2" ' + "/>";	break;	// Confirmed
							case 'x': image = '<img src="desktop/img/Toolbar/gif/16x16/69.gif" ' + 'alt="x" ' + "/>";	break;	// Dirty
						}
						return image;
					}
				},
					
				{field: "andor", id: "andor", label: "and/or", className: ["dgss60px"], sortable: false,
					editor: FilteringSelect,
					editOn: 'click',
					editorArgs: {
						store: Observable(new DojoMemory({
							idProperty: "id",
							data: [
								{"id": "", "name": ""},
								{"id": "and", "name": "and"},
								{"id": "or",  "name": "or"}
							]
						})), 
						maxHeight: 120, 
						style: "width:50px;"
					}},
				
				{field: "brck1", id: "brck1",label: " ", className: ["dgss40px"], sortable: false,
					editor: FilteringSelect,
					editOn: 'click',
					editorArgs: {
						store: Observable(new DojoMemory({
							idProperty: "id",
							data: [
								{"id": "", "name": ""},
								{"id": "(", "name": "("}
							]
						})), 
						maxHeight: 120, 
						style: "width:30px;"
					}
				}, 
				
				{field: "fldname", id: "fldname", label: "field name", className: ["dgss160px"], sortable: false,
					editor: FilteringSelect,
					editorArgs: {
						store: Observable(new DojoMemory({
							idProperty: "id",
							data: sql.whefld
						})), 
						maxHeight: 400, 
						style: "width:150px;"
					}
				}, 
				
				{field: "oper", id: "oper", label: "operation", className: ["dgss110px"], sortable: false,
					editor: FilteringSelect,
					editorArgs: {
						store: Observable(new DojoMemory({
							idProperty: "id",
							data: [
								{id: "", name: ""},
								{id: "equal", name: "equal"},
								{id: "less than", name: "less than"},
								{id: "less equal", name: "less equal"},
								{id: "greater than", name: "greater than"},
								{id: "greater equal", name: "greater equal"},
								{id: "not equal", name: "not equal"},
								{id: "in", name: "in"},
								{id: "like", name: "like"},
								{id: "between", name: "between"},
								{id: "not in", name: "not in"},
								{id: "not like", name: "not like"},
								{id: "not between", name: "not between"}
							]
						})), 
						maxHeight: 210, 
						style: "width:100px;"
					}
				}, 
				
				{field: "opand", id: "opand", label: "Operand", className: ["dgss200px"], sortable: false,
					editor: "text"
				},
				
				{field: "brck2", id: "brck2", label: " ", className: ["dgss40px"], sortable: false,
					editor: FilteringSelect,
					editOn: 'click',
					editorArgs: {
						store: Observable(new DojoMemory({
							idProperty: "id",
							data: [
								{"id": "", "name": ""},
								{"id": ")", "name": ")"}
							]
						})), 
						maxHeight: 210, 
						style: "width:30px;"
					}
				}
			];
			
	});
			
	return whereCol;   
}
// -----------------------------------------------------------
// SqlCtlGrpBy: 
// ----------------------------------------------------------
function SqlCtlGrpBy(sql) {
	
	require(["dojo/dom", "dojo/dom-construct", "dijit/registry", "dojo/domReady!"],
	function(dom, domConstruct, registry){
		
		if (registry.byId("hdmSqlCtlGrpByGrid")) {
			registry.byId("hdmSqlCtlGrpByGrid").destroyRecursive(true);
		}
		
		var dgridDomNode = domConstruct.create("div", {id: "hdmSqlCtlGrpByGrid"});	
		domConstruct.place(dgridDomNode, "hdmSqlCtlGrpByPane");
		SqlCtlGrpByGrid(sql);		// Grid
	
	});
	return;
}
// -----------------------------------------------------------
// Load Group By Grid
// -----------------------------------------------------------
function SqlCtlGrpByGrid(sql) {
	
	//console.log("SqlCtlGrpBy sql: ", sql);
	
	require(["dgrid/OnDemandGrid", 
			"dgrid/Selection", 
			"dgrid/Keyboard", 
			"dgrid/selector", 
			"dgrid/Editor", 
			"dgrid/extensions/ColumnHider", 
			"dgrid/extensions/DijitRegistry",   
			"dijit/form/ComboBox", 
			"dijit/form/FilteringSelect", 
			"dijit/registry",
			"dstore/Memory", 
			"dojo/store/Memory", "dojo/store/Observable", 
			"dojo/data/ObjectStore", "dojo/dom", 
			"dojo/dom-style", "dojo/_base/declare", 
			"dojo/_base/lang", "dojo/domReady!"],
	function(Grid,  
			Selection,
			Keyboard,  
			selector, 
			Editor, 
			ColumnHider,  
			DijitRegistry,
			ComboBox, 
			FilteringSelect, 
			registry,
			Memory, 
			DojoMemory, Observable, 
			ObjectStore, dom, 
			domStyle, declare, lang){
				
			var grpByCol = SqlCtlGrpByCol(sql);
			//console.log("SqlCtlGrpBy grpByCol: ", grpByCol);
			
			//var dgridDomNode = dom.byId("hdmSqlCtlGrpByGrid");
			//console.log("SqlCtlGrpBy dgridDomNode: ", dgridDomNode);	
			
			if (registry.byId("hdmSqlCtlGrpByGrid")) {
				grid = registry.byId("hdmSqlCtlGrpByGrid");
				console.log("SqlCtlGrpBy refresh: ", grid);
				grid.refresh();
				return;
			}
			else {
				var grid = new (declare([Grid, Selection, Editor, DijitRegistry, Keyboard]))({
					id : "hdmSqlCtlGrpByGrid",
					collection: Observable(new Memory({data: sql.grpdata})),
					columns: grpByCol,
					selectionMode: "none"
				}, "hdmSqlCtlGrpByGrid"); 
			}
			
			grid.on("dgrid-datachange", function(evt){
				var rowid  = grid.cell(evt).row.data.id;
				var colid = grid.cell(evt).column.id;
				
				var rowInt = parseInt(rowid);
				var grpData = hugmarSettings.sql.grpdata[rowInt-1];
				switch (colid) {
					case 'fldname': grpData.fldname	=	evt.value; 	break;
					case 'grpflag':	grpData.grpflag	=	evt.value; 	break;
					default: console.log("SqlCtlGrpByEdit Unknown Column ID: ", colid);
				}
				grpData.confirm = 'x';
				hugmarSettings.sql.grpdata[rowInt-1] = grpData;
				SqlCtlGrpByGrid(hugmarSettings.sql);
			});	
				
			
			grid.on(".dgrid-row .dgrid-cell:click", function(evt){
				evt.preventDefault(); // prevent default browser context menu
				var selectedRow  = grid.cell(evt).row.data;
				var selectedCell = grid.cell(evt).column;
				if (selectedCell.field === "confirm" && selectedRow.confirm == "x") {
					console.log("cell clicked: selectedRow ", selectedRow);
					SqlCtlGrpByEdit("grpby", selectedRow, sql.env);
				}
			});
			
		});
	
			
} 
// -----------------------------------------------------------
// Edit and Error Check Where Cell
// -----------------------------------------------------------
function SqlCtlGrpByEdit(sqlType, selectedRow, sqlEnv) {

	require(["dojo/ready", "dojo/_base/json", "dojo/request/xhr", "dijit/registry"], 
	function(ready, dojo, xhr, registry){
		
		var rowInt = parseInt(selectedRow.id);
		var grpData = hugmarSettings.sql.grpdata[rowInt-1];
		console.log("SqlCtlGrpByEdit grpData: ", grpData);
		
		var jsCaller		= "SqlCtlGrpByEdit";
		var jsonObj  		= SqlCtlSetJsonObj(jsCaller,"HWEBNAFB2", "SqlCtl", hugmarSettings);
		jsonObj.procparm 	= "sqlchange";
		jsonObj.sqlenv			= sqlEnv;
		jsonObj.sqlrow 			= grpData;
		jsonObj.sqlrow.sqltype 	= sqlType;
		jsonObj.sqlrow.rrn 		= selectedRow.id;
		jsonObj.sqlrow.filler = " ";
		
		var jsonString  = dojo.toJson(jsonObj);
		//console.log("SqlCtlGrpByEdit jsonString: ", jsonString);
	
		var urlString 	= hugmarSettings.host.pgmdir + "/hwebhtp120.pgm?json=" + jsonString;
		
		dojo.xhrGet({
			url: urlString, handleAs: "json",
			load: function(jsonResponse, ioArgs) {
				console.log("SqlCtlGrpByEdit  jsonResponse: ", jsonResponse);
				hugmarSettings.sql.grpdata = jsonResponse.grpdata;
				hugmarSettings.sql.orddata = jsonResponse.orddata;
				hugmarSettings.sql.ordfld  = jsonResponse.ordfld;
				SqlCtlGrpBy(hugmarSettings.sql);
				SqlCtlOrdBy(hugmarSettings.sql);
				return jsonResponse; },
			error: function(jsonResponse, ioArgs) {
				SqlCtlXhrGetError("SqlCtlGrpByEdit", ioArgs);
				return jsonResponse; }
			});
		
			
	});				
		
	return;          	
} 
// -----------------------------------------------------------
// Get Sql GrpBy Columns:
// -----------------------------------------------------------
function SqlCtlGrpByCol(sql) {
	
	var grpByCol = [];
	
	require(["dgrid/Editor",
			"dijit/form/CheckBox",  
			"dijit/form/ComboBox", 
			"dijit/form/FilteringSelect", 
			"dojo/store/Memory", 
			"dojo/store/Observable" ],
	function(Editor,
			CheckBox,    
			ComboBox, 
			FilteringSelect, 
			DojoMemory, 
			Observable ){
				
		grpByCol = [
				{field: "id", id: "id", label: "", className: ["dgsshidden"]},
				{field: "confirm", id: "confirm", label: " ", className: ["dgss40px"], sortable: false, 
					formatter: function(val){
						switch (val) {
							case '1': image = '<img src="desktop/img/Toolbar/gif/16x16/1.gif" ' + ' alt="1" ' + "/>";	break;	// Blank
							case '2': image = '<img src="desktop/img/Toolbar/gif/16x16/38.gif" ' + 'alt="2" ' + "/>";	break;	// Confirmed
							case 'x': image = '<img src="desktop/img/Toolbar/gif/16x16/69.gif" ' + 'alt="x" ' + "/>";	break;	// Dirty
						}
						return image;
						}
				},
				
				{field: "fldname", id: "fldname", label: "field name", className: ["dgss180px"], sortable: false,
					editor: FilteringSelect,
					//editOn: 'click',
					editorArgs: { 
						store: Observable(new DojoMemory({
							idProperty: "id",
							data: sql.grpfld
						})), 
						maxHeight: 400, 
						style: "width:180px;"
					}
					
				},
				
				{field: "grpflag", id: "grpflag", label: "Grouping", className: ["dgss120px"], sortable: false,
					editor: FilteringSelect,
					//editOn: 'click',
					editorArgs: { 
						store: Observable(new DojoMemory({
							idProperty: "id",
							data: [
								{"id": "", "name": ""},
								{"id": "C", "name": "Combined"},
								{"id": "D", "name": "Description Only"},
								{"id": "F", "name": "Field Only"},
								{"id": "S", "name": "Split Columns"}
							]
						})), 
						maxHeight: 120, 
						style: "width:120px;"
					}
				}	
			];
		
		
	});
	return grpByCol;	

}
// -----------------------------------------------------------
// SqlCtlOrdBy: 
// ----------------------------------------------------------
function SqlCtlOrdBy(sql) {
	
	require(["dojo/dom", "dojo/dom-construct", "dijit/registry"],
	function(dom, domConstruct, registry){
		
		if (registry.byId("hdmSqlCtlOrdByGrid")) {
			registry.byId("hdmSqlCtlOrdByGrid").destroyRecursive(true);
		}
		
		var dgridDomNode = domConstruct.create("div", {id: "hdmSqlCtlOrdByGrid"});	
		domConstruct.place(dgridDomNode, "hdmSqlCtlOrdByPane");
		SqlCtlOrdByGrid(sql);		// Grid
	
	});
	return;
}
// -----------------------------------------------------------
// SqlCtlOrdBy: 
// ----------------------------------------------------------
function SqlCtlOrdByGrid(sql) {
	
	//console.log("SqlCtlOrdBy sql: ", sql);
	
	require(["dgrid/OnDemandGrid", 
			"dgrid/Selection", 
			"dgrid/Keyboard", 
			"dgrid/selector", 
			"dgrid/Editor", 
			"dgrid/extensions/ColumnHider", 
			"dgrid/extensions/DijitRegistry", 
			"dijit/form/CheckBox",  
			"dijit/form/ComboBox", 
			"dijit/form/FilteringSelect", 
			"dijit/registry",
			"dstore/Memory",  
			"dojo/store/Memory", 
			"dojo/store/Observable", 
			"dojo/data/ObjectStore", "dojo/dom", 
			"dojo/dom-style", "dojo/_base/declare", 
			"dojo/_base/lang", "dojo/domReady!"],
	function(Grid,  
			Selection,
			Keyboard,  
			selector, 
			Editor, 
			ColumnHider, 
			DijitRegistry, 
			CheckBox,
			ComboBox, 
			FilteringSelect, 
			registry,
			Memory, 
			DojoMemory, 
			Observable, 
			ObjectStore, dom, 
			domStyle, declare, lang){
			
			var ordByCol = SqlCtlOrdByCol(sql);
			//console.log("SqlCtlOrdBy ordByCol: ", ordByCol);
			
			if (registry.byId("hdmSqlCtlOrdByGrid")) {
				grid = registry.byId("hdmSqlCtlOrdByGrid");
				grid.refresh();
				return;
			}
			else {
				var grid = new (declare([Grid, Selection, Editor, DijitRegistry, Keyboard]))({
					id : "hdmSqlCtlOrdByGrid",
					collection: Observable(new Memory({data: sql.orddata})),
					columns: ordByCol,
					selectionMode: "none"
				}, "hdmSqlCtlOrdByGrid"); 
			}
			
			grid.on("dgrid-datachange", function(evt){
				var rowid  = grid.cell(evt).row.data.id;
				var colid = grid.cell(evt).column.id;
				
				var rowInt = parseInt(rowid);
				var ordData = hugmarSettings.sql.orddata[rowInt-1];
				switch (colid) {
					case 'fldname': ordData.fldname	=	evt.value; 	break;
					case 'fldsort':	ordData.fldsort	=	evt.value; 	break;
					case 'subtot':	{
						console.log("SqlCtlOrdBy subtot changed: ", evt.value);
						ordData.subtot	=	evt.value;
						} 	
						break;
					default: console.log("SqlCtlOrdByEdit Unknown Column ID: ", colid);
				}
				ordData.confirm = 'x';
				hugmarSettings.sql.orddata[rowInt-1] = ordData;
				SqlCtlOrdByGrid(hugmarSettings.sql);
			});	
				
			grid.on(".dgrid-row .dgrid-cell:click", function(evt){
				evt.preventDefault(); // prevent default browser context menu
				var selectedRow  = grid.cell(evt).row.data;
				var selectedCell = grid.cell(evt).column;
				if (selectedCell.field == "confirm" && selectedRow.confirm == "x") {
					console.log("cell clicked: selectedRow ", selectedRow);
					SqlCtlOrdByEdit("ordby", selectedRow, sql.env);
				}
			});
			
		});
	
	return;
}

// -----------------------------------------------------------
// Edit and Error Check OrdBy Cell
// -----------------------------------------------------------
function SqlCtlOrdByEdit(sqlType, selectedRow, sqlEnv) {

	require(["dojo/ready", "dojo/_base/json", "dojo/request/xhr", "dijit/registry"], 
	function(ready, dojo, xhr, registry){
		
		var rowInt = parseInt(selectedRow.id);
		var ordData = hugmarSettings.sql.orddata[rowInt-1];
		console.log("SqlCtlOrdByEdit ordData: ", ordData);
		
		var jsCaller		= "SqlCtlOrdByEdit";
		var jsonObj  		= SqlCtlSetJsonObj(jsCaller,"HWEBNAFB2", "SqlCtl", hugmarSettings);
		jsonObj.procparm 	= "sqlchange";
		jsonObj.sqlenv			= sqlEnv;
		jsonObj.sqlrow 			= ordData;
		jsonObj.sqlrow.sqltype 	= sqlType;
		jsonObj.sqlrow.rrn 		= selectedRow.id;
		jsonObj.sqlrow.filler = " ";
		
		var jsonString  = dojo.toJson(jsonObj);
		console.log("SqlCtlOrdByEdit jsonString: ", jsonString);
	
		var urlString 	= hugmarSettings.host.pgmdir + "/hwebhtp120.pgm?json=" + jsonString;
		
		dojo.xhrGet({
			url: urlString, handleAs: "json",
			load: function(jsonResponse, ioArgs) {
				console.log("SqlCtlOrdByEdit  jsonResponse: ", jsonResponse);
				hugmarSettings.sql.orddata = jsonResponse.orddata;
				SqlCtlOrdBy(hugmarSettings.sql);			
				return jsonResponse; },
			error: function(jsonResponse, ioArgs) {
				SqlCtlXhrGetError("SqlCtlOrdByEdit", ioArgs);
				return jsonResponse; }
			});
		
			
	});				
		
	return;          	
} 
// -----------------------------------------------------------
// Get Sql OrdBy Columns:
// -----------------------------------------------------------
function SqlCtlOrdByCol(sql) {
	
	var ordByCol = [];
	
	require(["dgrid/Editor",
			"dijit/form/CheckBox",  
			"dijit/form/ComboBox", 
			"dijit/form/FilteringSelect", 
			"dojo/store/Memory", 
			"dojo/store/Observable" ],
	function(Editor,
			CheckBox,    
			ComboBox, 
			FilteringSelect, 
			DojoMemory, 
			Observable ){
		
		if (sql.env.cltype == "SUBFILE") {		
			ordByCol = [
				{field: "id", id: "id", label: "", className: ["dgsshidden"]},
				{field: "confirm", id: "confirm", label: " ", className: ["dgss40px"], sortable: false, 
					formatter: function(val){
						switch (val) {
							case '1': image = '<img src="desktop/img/Toolbar/gif/16x16/1.gif" ' + ' alt="1" ' + "/>";	break;	// Blank
							case '2': image = '<img src="desktop/img/Toolbar/gif/16x16/38.gif" ' + 'alt="2" ' + "/>";	break;	// Confirmed
							case 'x': image = '<img src="desktop/img/Toolbar/gif/16x16/69.gif" ' + 'alt="x" ' + "/>";	break;	// Dirty
						}
						return image;
						}
				},
				
				{field: "fldname", id: "fldname", label: "field name", className: ["dgss180px"], sortable: false,
					editor: FilteringSelect,
					editorArgs: { 
						store: Observable(new DojoMemory({
							idProperty: "id",
							data: sql.ordfld
						})), 
						maxHeight: 400, 
						style: "width:180px;"
					}
				},	
				
				{field: "fldsort", id: "fldsort", label: "Sort", className: ["dgss80px"], sortable: false,
					editor: FilteringSelect,
					editorArgs: { 
						store: Observable(new DojoMemory({
							idProperty: "id",
							data: [
								{"id": "blank", "name": ""},
								{"id": "A", "name": "Ascend"},
								{"id": "D", "name": "Descend"}
							]
						})), 
						maxHeight: 200, 
						style: "width:80px;"
					}
				}	
			];
		}
		
		if (sql.env.cltype == "SUBFGROUP") {		
			ordByCol = [
				{field: "id", id: "id", label: "", className: ["dgsshidden"]},
				{field: "confirm", id: "confirm", label: " ", className: ["dgss40px"], sortable: false, 
					formatter: function(val){
						switch (val) {
							case '1': image = '<img src="desktop/img/Toolbar/gif/16x16/1.gif" ' + ' alt="1" ' + "/>";	break;	// Blank
							case '2': image = '<img src="desktop/img/Toolbar/gif/16x16/38.gif" ' + 'alt="2" ' + "/>";	break;	// Confirmed
							case 'x': image = '<img src="desktop/img/Toolbar/gif/16x16/69.gif" ' + 'alt="x" ' + "/>";	break;	// Dirty
						}
						return image;
						}
				},
				
				{field: "fldname", id: "fldname", label: "field name", className: ["dgss180px"], sortable: false,
					editor: FilteringSelect,
					editorArgs: { 
						store: Observable(new DojoMemory({
							idProperty: "id",
							data: sql.ordfld
						})), 
						maxHeight: 400, 
						style: "width:180px;"
					}
				},	
				
				{field: "fldsort", id: "fldsort", label: "Sort", className: ["dgss60px"], sortable: false,
					editor: FilteringSelect,
					editorArgs: { 
						store: Observable(new DojoMemory({
							idProperty: "id",
							data: [
								{"id": "blank", "name": ""},
								{"id": "A", "name": "Ascend"},
								{"id": "D", "name": "Descend"}
							]
						})), 
						maxHeight: 200, 
						style: "width:80px;"
					}
				},
				
				{field: "subtot", id: "subtot", label: "Total", className: ["dgss30px"], sortable: false,
					editor: CheckBox,
					get: function(item){
						//console.log("get: ", item);
						if (item.subtot == "on") {return true;}
						else {return false;}}, 
					set: function(item){
						//console.log("set: ", item); 
						return item.subtot == false;}, 
					editorArgs: { }
				}
					
			];
		}
				
	});
	return ordByCol;	
}

// -----------------------------------------------------------
// SqlCtlHaving: 
// ----------------------------------------------------------
function SqlCtlHaving(sql) {
	
	//console.log("SqlCtlHaving sql: ", sql);
	
	require(["dojo/dom", "dojo/dom-construct", "dijit/layout/ContentPane", "dijit/registry"],
	function(dom, domConstruct, ContentPane, registry){
		
		if (registry.byId("hdmSqlCtlHavingGrid")) {
			registry.byId("hdmSqlCtlHavingGrid").destroyRecursive(true);
		}
		
		var dgridDomNode = domConstruct.create("div", {id: "hdmSqlCtlHavingGrid"});	
		domConstruct.place(dgridDomNode, "hdmSqlCtlHavingPane");
		SqlCtlHavingGrid(sql);		// Grid
	
	});
	
	return;
}
// -----------------------------------------------------------
// SqlCtlHavingGrid: 
// ----------------------------------------------------------
function SqlCtlHavingGrid(sql) {
	
	//console.log("SqlCtlHaving sql: ", sql);
	
	require(["dgrid/OnDemandGrid", 
			"dgrid/Selection", 
			"dgrid/Keyboard",
			"dgrid/selector", 
			"dgrid/Editor", 
			"dgrid/extensions/ColumnHider", 
			"dgrid/extensions/DijitRegistry",  
			"dijit/form/FilteringSelect", 
			"dijit/registry",
			"dstore/Memory", 
			"dojo/store/Memory", "dojo/store/Observable", 
			"dojo/data/ObjectStore", "dojo/dom", 
			"dojo/dom-style", "dojo/_base/declare", 
			"dojo/_base/lang", "dojo/domReady!"],
	function(Grid,  
			Selection,
			Keyboard,
			selector,  
			Editor, 
			ColumnHider, 
			DijitRegistry, 
			FilteringSelect, 
			registry,
			Memory, 
			DojoMemory, Observable, 
			ObjectStore, dom, 
			domStyle, declare, lang){
				
			//registry.byId("hdmSqlCtl").havingData = havingData;
				
			var havingCol = SqlCtlHavingCol(sql);
			//console.log("SqlCtlHaving havingCol: ", havingCol);
	
			if (registry.byId("hdmSqlCtlHavingGrid")) {
				grid = registry.byId("hdmSqlCtlHavingGrid");
				//console.log("grid.refresh: " + grid);
				grid.refresh();
				return;
			}
			else {
				var grid = new (declare([Grid, Selection, Editor, DijitRegistry, Keyboard]))({
					id : "hdmSqlCtlHavingGrid",
					collection: Observable(new Memory({data: sql.havdata})),
					columns: havingCol,
					selectionMode: "none"
				}, "hdmSqlCtlHavingGrid"); 
			} 
			
			grid.on("dgrid-datachange", function(evt){
				var rowid  = grid.cell(evt).row.data.id;
				var colid = grid.cell(evt).column.id;
				var rowInt = parseInt(rowid);
				var havData = hugmarSettings.sql.havdata[rowInt-1];
				switch (colid) {
					case 'andor':	havData.andor	=	evt.value; 	break;
					case 'brck1':	havData.brck1	=	evt.value; 	break;
					case 'fldname': havData.fldname	=	evt.value; 	break;
					case 'oper':	havData.oper	=	evt.value; 	break;
					case 'opand':	havData.opand	=	evt.value; 	break;
					case 'brck2':	wheData.brck2	=	evt.value; 	break;
					default: console.log("SqlCtlHavingEdit Unknown Column ID: ", colid);
				}
				havData.confirm = 'x';
				hugmarSettings.sql.havdata[rowInt-1] = havData;
				SqlCtlHavingGrid(hugmarSettings.sql);
			});	
				
			
			grid.on(".dgrid-row .dgrid-cell:click", function(evt){
				evt.preventDefault(); // prevent default browser context menu
				var selectedRow  = grid.cell(evt).row.data;
				var selectedCell = grid.cell(evt).column;
				if (selectedCell.field === "confirm") {
					console.log("cell clicked: selectedRow ", selectedRow);
					SqlCtlHavingEdit("having", selectedRow, sql.env);
				}
			});
			
		});
	
	
	return;
}

// -----------------------------------------------------------
// Edit and Error Check Having Cell
// -----------------------------------------------------------
function SqlCtlHavingEdit(sqlType, selectedRow, sqlEnv) {

	require(["dojo/ready", "dojo/_base/json", "dojo/request/xhr", "dijit/registry"], 
	function(ready, dojo, xhr, registry){
		
		var rowInt = parseInt(selectedRow.id);
		var havData = hugmarSettings.sql.havdata[rowInt-1];
		console.log("SqlCtlHavingEdit havData: ", havData);
		
		var jsCaller		= "SqlCtlHavingEdit";
		var jsonObj  		= SqlCtlSetJsonObj(jsCaller,"HWEBNAFB2", "SqlCtl", hugmarSettings);
		jsonObj.procparm 	= "sqlchange";
		jsonObj.sqlenv			= sqlEnv;
		jsonObj.sqlrow 			= havData;
		jsonObj.sqlrow.sqltype 	= sqlType;
		jsonObj.sqlrow.rrn 		= selectedRow.id;
		jsonObj.sqlrow.filler 	= " ";
		
		var jsonString  = dojo.toJson(jsonObj);
		console.log("SqlCtlHavingEdit jsonString: ", jsonString);
	
		var urlString 	= hugmarSettings.host.pgmdir + "/hwebhtp120.pgm?json=" + jsonString;
		
		dojo.xhrGet({
			url: urlString, handleAs: "json",
			load: function(jsonResponse, ioArgs) {
				console.log("SqlCtlHavingEdit  jsonResponse: ", jsonResponse);
				hugmarSettings.sql.havdata = jsonResponse.havdata;
				SqlCtlWhere(hugmarSettings.sql);			
				return jsonResponse; },
			error: function(jsonResponse, ioArgs) {
				SqlCtlXhrGetError("SqlCtlHavingEdit", ioArgs);
				return jsonResponse; }
			});
		
			/*
			xhr(urlString, {
				handleAs: "text",
				method: "GET"
			}).then(function(data){
				console.log("SqlCtlHavingEdit  data: ", data);
			}, function(err){
				// Handle the error condition
			}, function(evt){
				// XHR2
				console.log("SqlCtlHavingEdit XHR2 evt: ", evt);
		});	
		*/	
	});				
		
	return;          	
} 

// -----------------------------------------------------------
// Get Sql Having Columns:
// -----------------------------------------------------------
function SqlCtlHavingCol(sql) {

	var havingCol = [];
	
	require(["dgrid/Editor",
			"dijit/form/CheckBox",  
			"dijit/form/ComboBox", 
			"dijit/form/FilteringSelect", 
			"dojo/store/Memory", 
			"dojo/store/Observable" ],
	function(Editor,
			CheckBox,    
			ComboBox, 
			FilteringSelect, 
			DojoMemory, 
			Observable ){

	havingCol = [
				{field: "id", id: "id", label: "", className: ["dgsshidden"]},
				{field: "confirm", id: "confirm", label: " ", className: ["dgss40px"], sortable: false,
					formatter: function(val){
				
						switch (val) {
							case '1': image = '<img src="desktop/img/Toolbar/gif/16x16/1.gif" ' + ' alt="1" ' + "/>";	break;	// Blank
							case '2': image = '<img src="desktop/img/Toolbar/gif/16x16/38.gif" ' + 'alt="2" ' + "/>";	break;	// Confirmed
							case 'x': image = '<img src="desktop/img/Toolbar/gif/16x16/69.gif" ' + 'alt="x" ' + "/>";	break;	// Dirty
						}
						//console.log("Having Column confirm image: ", image);
						return image;
						}
				},
					
				{field: "andor", id: "andor", label: "and/or", className: ["dgss60px"], sortable: false,
					editor: FilteringSelect,
					editOn: 'click',
					editorArgs: {
						store: Observable(new DojoMemory({
							idProperty: "id",
							data: [
								{"id": "", "name": ""},
								{"id": "and", "name": "and"},
								{"id": "or",  "name": "or"}
							]
						})), 
						maxHeight: 120, 
						style: "width:50px;"
					}},
				
				{field: "brck1", id: "brck1",label: " ", className: ["dgss40px"], sortable: false,
					editor: FilteringSelect,
					editOn: 'click',
					editorArgs: {
						store: Observable(new DojoMemory({
							idProperty: "id",
							data: [
								{"id": "", "name": ""},
								{"id": "(", "name": "("}
							]
						})), 
						maxHeight: 120, 
						style: "width:30px;"
					}
				}, 
				
				{field: "fldname", id: "fldname", label: "field name", className: ["dgss160px"], sortable: false,
					editor: FilteringSelect,
					editorArgs: {
						store: Observable(new DojoMemory({
							idProperty: "id",
							data: sql.havfld
						})), 
						maxHeight: 400, 
						style: "width:150px;"
					}
				}, 
				
				{field: "oper", id: "oper", label: "operation", className: ["dgss110px"], sortable: false,
					editor: FilteringSelect,
					editorArgs: {
						store: Observable(new DojoMemory({
							idProperty: "id",
							data: [
								{id: "blank", name: ""},
								{id: "equal", name: "equal"},
								{id: "lessthan", name: "less than"},
								{id: "lessequal", name: "less equal"},
								{id: "greaterthan", name: "greater than"},
								{id: "greaterequal", name: "greater equal"},
								{id: "notequal", name: "not equal"},
								{id: "in", name: "in"},
								{id: "like", name: "like"},
								{id: "between", name: "between"},
								{id: "not in", name: "not in"},
								{id: "not like", name: "not like"},
								{id: "not between", name: "not between"}
							]
						})), 
						maxHeight: 210, 
						style: "width:100px;"
					}
				}, 
				
				{field: "opand", id: "opand", label: "Operand", className: ["dgss200px"], sortable: false,
					editor: "text"
				},
				
				{field: "brck2", id: "brck2", label: " ", className: ["dgss40px"], sortable: false,
					editor: FilteringSelect,
					editOn: 'click',
					editorArgs: {
						store: Observable(new DojoMemory({
							idProperty: "id",
							data: [
								{"id": "", "name": ""},
								{"id": ")", "name": ")"}
							]
						})), 
						maxHeight: 210, 
						style: "width:30px;"
					}
				}
			];
			
	});
			
	return havingCol;   
}