gridx-rails 1.1.0

data/app/assets/javascripts/gridx/support/QuickFilter.js

@@ -0,0 +1,138 @@
+define([
+	'dojo/_base/declare',
+	'dojo/_base/lang',
+	'dojo/_base/array',
+	'dojo/dom-class',
+	'dojo/keys',
+	'dijit/_WidgetBase',
+	'dijit/_TemplatedMixin',
+	'dijit/_WidgetsInTemplateMixin',
+	'dijit/form/TextBox',
+	'dijit/form/Button',
+	'dijit/form/ComboButton',
+	'dijit/Menu',
+	'dijit/MenuItem',
+	'../modules/Filter',
+	'dojo/i18n',
+	'dojo/text!../templates/QuickFilter.html',
+	'dojo/i18n!../nls/QuickFilter'
+], function(declare, lang, array, domClass, keys,
+	_WidgetBase, _TemplatedMixin, _WidgetsInTemplateMixin,
+	TextBox, Button, ComboButton, Menu, MenuItem,
+	F, i18n, template){
+
+/*=====
+	return declare([_WidgetBase, _TemplatedMixin, _WidgetsInTemplateMixin], {
+		// summary:
+		//		Quick filter box.
+
+		// grid: [const] gridx.Grid
+		//		The grid widget this plugin works for.
+		grid: null,
+
+		// autoApply: Boolean
+		//		If true, the filter will be applied to grid during typing in the filter box.
+		autoApply: true,
+
+		// delay: Integer
+		//		The time (in ms) delay before applying the filter after each key stroke in the filter box.
+		//		Only effective when autoApply is true, 
+		delay: 700
+	});
+=====*/
+
+	return declare([_WidgetBase, _TemplatedMixin, _WidgetsInTemplateMixin], {
+		templateString: template,
+
+		constructor: function(args){
+			lang.mixin(this, i18n.getLocalization('gridx', 'QuickFilter', args.grid.lang));
+			this._hasFilterBar = args.grid.filterBar ? 'gridxQuickFilterHasFilterBar' : 'gridxQuickFilterNoFilterBar';
+		},
+
+		postCreate: function(){
+			if(this.autoApply){
+				this.connect(this.textBox, 'onInput', '_onInput');
+			}
+		},
+
+		grid: null,
+
+		textBoxClass: 'dijit.form.TextBox',
+
+		buttonClass: 'dijit.form.Button',
+
+		comboButtonClass: 'dijit.form.ComboButton',
+
+		menuClass: 'dijit.Menu',
+
+		menuItemClass: 'dijit.MenuItem',
+
+		autoApply: true,
+
+		delay: 700,
+
+		//Private--------------------------------------------------------------------
+		_onInput: function(evt){
+			var t = this,
+				dn = t.domNode,
+				tb = t.textBox,
+				key = evt.keyCode;
+			setTimeout(function(){
+				domClass.toggle(dn, 'gridxQuickFilterActive', tb.get('value'));
+			}, 0);
+			if(key != keys.TAB){
+				clearTimeout(t._handle);
+				t._handle = setTimeout(function(){
+					t._filter();
+				}, key == keys.ENTER ? 0 : t.delay);
+			}
+		},
+
+		_onKey: function(evt){
+			if(evt.keyCode == keys.ENTER){
+				this.grid.focus.stopEvent(evt);
+				this._clear();
+				this.textBox.focus();
+			}
+		},
+
+		_clear: function(){
+			this.textBox.set('value', '');
+			domClass.remove(this.domNode, 'gridxQuickFilterActive');
+			this._filter();
+		},
+
+		_filter: function(){
+			var t = this,
+				g = t.grid,
+				v = t.textBox.get('value'),
+				cols = array.filter(g.columns(), function(col){
+					return col.filterable !== false;
+				});
+			clearTimeout(t._handle);
+			if(g.filterBar){
+				//TODO: is there a better way communicate with FilterBar?
+				if(v === ''){
+					g.filterBar.clearFilter(true);
+				}else{
+					g.filterBar.applyFilter({
+						conditions: [{
+							condition: 'contain',
+							value: v
+						}]
+					});
+				}
+			}else{
+				g.filter.setFilter(v === '' ? 0 : F.or.apply(0, array.map(cols, function(col){
+					return F.contain(F.column(col.id), F.value(v));
+				})));
+			}
+		},
+
+		_showFilterBar: function(){
+			var fb = this.grid.filterBar;
+			fb.show();
+			fb.showFilterDialog();
+		}
+	});
+});

data/app/assets/javascripts/gridx/support/Summary.js

@@ -0,0 +1,49 @@
+define([
+	"dojo/_base/declare",
+	"dojo/string",
+	"dijit/_WidgetBase",
+	"dijit/_TemplatedMixin",
+	"dojo/i18n",
+	"dojo/i18n!../nls/SummaryBar"
+], function(declare, string, _WidgetBase, _TemplatedMixin, i18n){
+
+/*=====
+	return declare([_WidgetBase, _TemplatedMixin], {
+		// summary:
+		//		Show total row count and selected row count.
+
+		// gridx: [const] gridx/Grid
+		grid: null,
+
+		refresh: function(){
+			// summary:
+			//		Update the summary text.
+		}
+	});
+=====*/
+
+	return declare([_WidgetBase, _TemplatedMixin], {
+		templateString: '<div class="gridxSummary"></div>',
+
+		grid: null,
+
+		postCreate: function(){
+			var t = this,
+				c = 'connect',
+				m = t.grid.model;
+			t[c](m, 'onSizeChange', 'refresh');
+			t[c](m, 'onMarkChange', 'refresh');
+			t._nls = i18n.getLocalization('gridx', 'SummaryBar', t.lang || t.grid.lang);
+			t.refresh();
+		},
+
+		refresh: function(){
+			var g = this.grid,
+				sr = g.select && g.select.row,
+				size = g.model.size(),
+				selected = sr ? sr.getSelected().length : 0,
+				tpl = sr ? this._nls.summaryWithSelection : this._nls.summary;
+			this.domNode.innerHTML = string.substitute(tpl, [size, selected]);
+		}
+	});
+});

data/app/assets/javascripts/gridx/support/_LinkPageBase.js

@@ -0,0 +1,92 @@
+define([
+	"dojo/_base/declare",
+	"dojo/_base/lang",
+	"dojo/_base/array",
+	"dojo/_base/sniff",
+	"dojo/dom-class",
+	"dijit/_WidgetBase",
+	"dijit/_FocusMixin",
+	"dijit/_TemplatedMixin",
+	"dojo/i18n",
+	"dojo/i18n!../nls/PaginationBar"
+], function(declare, lang, array, has, domClass, _WidgetBase, _FocusMixin, _TemplatedMixin, i18n){
+
+/*=====
+	return declare([_WidgetBase, _TemplatedMixin, _FocusMixin], {
+
+		// grid: [const] gridx.Grid
+		//		The grid widget this plugin works for.
+		grid: null
+	});
+=====*/
+
+	return declare([_WidgetBase, _TemplatedMixin, _FocusMixin], {
+		constructor: function(args){
+			var t = this;
+			lang.mixin(t, i18n.getLocalization('gridx', 'PaginationBar'));
+			if(has('ie')){
+				//IE does not support inline-block, so have to set tabIndex
+				var gridTabIndex = args.grid.domNode.getAttribute('tabindex');
+				t._tabIndex = gridTabIndex > 0 ? gridTabIndex : 0;
+			}
+		},
+
+		postCreate: function(){
+			var t = this;
+			t.domNode.setAttribute('tabIndex', t.grid.domNode.getAttribute('tabIndex'));
+			t.connect(t, 'onFocus', '_onFocus');
+			t.connect(t.domNode, 'onkeydown', '_onKey');
+			t.grid.pagination.loaded.then(function(){
+				t.refresh();
+			});
+		},
+
+		//Public-----------------------------------------------------------------------------
+		grid: null,
+
+		//Private----------------------------------------------------------------------------
+		_tabIndex: -1,
+
+		_findNodeByEvent: function(evt, targetClass, containerClass){
+			var n = evt.target,
+				hasClass = domClass.contains;
+			while(!hasClass(n, targetClass)){
+				if(hasClass(n, containerClass)){
+					return null;
+				}
+				n = n.parentNode;
+			}
+			return n;
+		},
+
+		_toggleHover: function(evt, targetCls, containerCls, hoverCls){
+			var n = this._findNodeByEvent(evt, targetCls, containerCls);
+			if(n){
+				domClass.toggle(n, hoverCls, evt.type == 'mouseover');
+			}
+		},
+
+		_focus: function(nodes, node, isMove, isLeft, isFocusable){
+			//Try to focus on node, but if node is not focsable, find the next focusable node in nodes 
+			//along the given direction. If not found, try the other direction.
+			//Return the node if successfully focused, null if not.
+			var dir = isLeft ? -1 : 1,
+				i = node ? array.indexOf(nodes, node) + (isMove ? dir : 0) : (isLeft ? nodes.length - 1 : 0),
+				findNode = function(i, dir){
+					while(nodes[i] && !isFocusable(nodes[i])){
+						i += dir;
+					}
+					return nodes[i];
+				};
+			node = findNode(i, dir) || findNode(i - dir, -dir);
+			if(node){
+				node.focus();
+			}
+			return node;
+		},
+
+		_onFocus: function(){
+			this._focusNextBtn();
+		}
+	});
+});

data/app/assets/javascripts/gridx/support/exporter/exporter.js

@@ -0,0 +1,350 @@
+define([
+/*====="dojo/_base/declare", =====*/
+	"dojo/_base/lang",
+	"dojo/_base/Deferred",
+	"dojo/_base/array"
+], function(/*=====declare, =====*/lang, Deferred, array){
+
+/*=====
+	function exporter(grid, writer, args){
+		// summary:
+		//		Go through the grid using the given args and writer implementation.
+		//		Return a dojo.Deferred object. Users can cancel and see progress 
+		//		of the exporting process.
+		//		Pass the exported result to the callback function of the Deferred object.
+		// grid: gridx/Grid
+		//		The grid instance to export
+		// writer: __Writer
+		//		The writer implementation.
+		// args: __ExportArgs
+		//		Export arguments.
+		// returns:
+		//		A deferred object.
+	}
+
+	exporter.__Writer = declare([], {
+		beforeHeader: function(args, context){
+			//summary:
+			//		Triggered before exporting the header cells.
+			//return: Boolean|undefined
+			//		If return false, does not handle following header cells.
+		},
+
+		handleHeaderCell: function(args, context){
+			//summary:
+			//		Triggered when exporting a header cell.
+		},
+
+		afterHeader: function(args, context){
+			//summary:
+			//		Triggered when the header has been exported.
+		},
+
+		beforeBody: function(args, context){
+			//summary:
+			//		Triggered before exporting the grid body.
+			//return: Boolean|undefined
+			//		If return false, does not handle any of the grid body content.
+		},
+
+		beforeRow: function(args, context){
+			//summary:
+			//		Triggered before exporting a row.
+			//return: Boolean|undefined
+			//		If return false, does not handle the cells in this row.
+		},
+
+		handleCell: function(args, context){
+			//summary:
+			//		Triggered when exporting a cell.
+		},
+
+		afterRow: function(args, context){
+			//summary:
+			//		Triggered when a row has been exported.
+		},
+
+		afterBody: function(args, context){
+			//summary:
+			//		Triggered when the grid body has been exported.
+		},
+
+		getResult: function(){
+			//summary:
+			//		This must be implemented.
+			return '';
+		}
+	});
+
+	exporter.__ExportArgs = declare([], {
+		// columns: String[]?
+		//		An array of column ID. Indicates which columns to be exported. 
+		//		If invalid or empty array, export all grid columns.
+		columns: null,
+
+		// start: Number?
+		//		Indicates from which row to start exporting. If invalid, 
+		//		default to 0.
+		start: 0,
+
+		// count: Number?
+		//		Indicates the count of rows export.
+		//		If invalid, export all rows up to the end of grid.
+		count: 0,
+
+		// selectedOnly: Boolean?
+		//		Whether only export selected rows. This constraint is applied 
+		//		upon the rows specified by start and count parameters.
+		//		This paramter and the filter parameter can be used togetther. 
+		//		Default to false.
+		selectedOnly: false,
+
+		// filter: Function?
+		//		A predicate function (returns Boolean) to judge whether to 
+		//		export a row. 
+		//		This constraint is applied upon the result rows of the 
+		//		selectedOnly parameter, if provided.
+		filter: null,
+
+		// useStoreData: Boolean?
+		//		Indicates whether to export grid data (formatted data) or 
+		//		store data. Default to false.
+		useStoreData: false,
+
+		// formatters: Object?
+		//		A customized way to export data, if neither grid data nor store 
+		//		data could meet the requirement. 
+		//		This is an associative array from column id to formatter function. 
+		//		A grid cell object will be passed into that function as an argument.
+		formatter: null,
+
+		// omitHeader: Boolean?
+		//		Indicates whether to export grid header. Default to false.
+		omitHeader: false,
+
+		// progressStep: Number?
+		//		Number of rows in each progress. Default to 0 (invalid means only one progress).
+		//		After each progress, the deferred.progress() is called, so the 
+		//		exporting process can be viewed by the user.
+		progressStep: 0
+	});
+
+	exporter.__ExportContext = {
+		// columnIds: String[]
+		//		Available for header.
+		columnIds: null,
+
+		// column: Grid Column
+		//		Available for header cell or a body cell.
+		column: null,
+
+		// row: Grid Row
+		//		Available for a row or a body cell.
+		row: null,
+
+		// cell: Grid Cell
+		//		Available for a body cell
+		cell: null,
+
+		// data: Anything
+		//		Available for a body cell
+		data: null
+	};
+
+	return exporter;
+=====*/
+
+	function check(writer, method, context, args){
+		return !writer[method] || false !== writer[method](context || args, args);
+	}
+
+	function prepareReqs(args, rowIndexes, size){
+		var reqs = [],
+			i, start = 0, end = 0,
+			ps = args.progressStep;
+		if(typeof args.start == 'number' && args.start >= 0){
+			start = args.start;
+		}
+		if(typeof args.count == 'number' && args.count > 0){
+			end = start + args.count;
+		}
+		end = end || size;
+		if(rowIndexes){
+			rowIndexes = array.filter(rowIndexes, function(idx){
+				return idx >= start && idx < end;
+			});
+			if(rowIndexes.length && (!ps || rowIndexes.length <= ps)){
+				reqs.push(rowIndexes);
+			}else{
+				for(i = 0; i < rowIndexes.length; i += ps){
+					reqs.push(rowIndexes.slice(i, i + ps));
+				}
+			}
+		}else{
+			var count = end - start;
+			if(!ps || count <= ps){
+				reqs.push({
+					start: start,
+					count: count
+				});
+			}else{
+				for(i = start; i < end; i += ps){
+					reqs.push({
+						start: i,
+						count: i + ps < end ? ps : end - i
+					});
+				}
+			}
+		}
+		reqs.p = 0;
+		return reqs;
+	}
+
+	function first(req, grid){
+		return lang.isArray(req) ? {
+			p: 0,
+			row: grid.row(req[0])
+		} : {
+			p: req.start,
+			row: grid.row(req.start)
+		};
+	}
+
+	function next(req, grid, prevRow){
+		var p = prevRow.p + 1,
+			isArray = lang.isArray(req);
+		return p < (isArray ? req.length : req.start + req.count) ? {
+			p: p,
+			row: grid.row(isArray ? req[p] : p)
+		} : null;
+	}
+
+	function format(args, cell){
+		var fs = args.formatters,
+			cid = cell.column.id;
+		if(fs && lang.isFunction(fs[cid])){
+			return fs[cid](cell);
+		}else if(args.useStoreData){
+			return cell.rawData() || '';
+		}
+		return cell.data() || '';
+	}
+
+	function fetchRows(grid, defer, writer, context, args, d, reqs){
+		var f = args.filter,
+			cols = context.columnIds,
+			req = reqs[reqs.p++],
+			fail = lang.hitch(d, d.errback),
+			func = function(){
+				defer.progress(reqs.p / reqs.length);
+				grid.when(req, function(){
+					for(var r = first(req, grid); r && r.row; r = next(req, grid, r)){
+						context.row = r.row;
+						if((!f || f(r.row)) && check(writer, 'beforeRow', context, args)){
+							for(var i = 0; i < cols.length; ++i){
+								var col = grid.column(cols[i], 1),	//1 as true
+									cell = context.cell = grid.cell(r.row, col);
+								context.column = col;
+								context.data = format(args, cell);
+								check(writer, 'handleCell', context, args);
+							}
+							check(writer, 'afterRow', context, args);
+						}
+					}
+				}).then(function(){
+					fetchRows(grid, defer, writer, context, args, d, reqs);
+				}, fail);
+			};
+		if(req){
+			if(reqs.length > 1){
+				setTimeout(func, 10);
+			}else{
+				func();
+			}
+		}else{
+			d.callback();
+		}
+	}
+
+	function getColumns(grid, args){
+		var colsById = grid._columnsById,
+			s = grid.select,
+			sc = s && s.column,
+			cols;
+		if(lang.isArrayLike(args.columns) && args.columns.length){
+			cols = array.filter(args.columns, function(cid){
+				return colsById[cid];
+			});
+			cols.sort(function(a, b){
+				return colsById[a].index - colsById[b].index;
+			});
+		}else{
+			cols = array.map(grid._columns, function(c){
+				return c.id;
+			});
+		}
+		return cols;
+	}
+
+	function exporter(grid, writer, /* __ExportArgs */ args){
+		var d = new Deferred(),
+			model = grid.model,
+			cols = getColumns(grid, args),
+			s = grid.select,
+			sr = s && s.row,
+			sc = s && s.column,
+			waitForRows,
+			rowIds,
+			context = {
+				grid: grid,
+				columnIds: cols
+			},
+			success = function(){
+				check(writer, 'afterBody', context, args);
+				d.callback(writer.getResult());
+			},
+			fail = lang.hitch(d, d.errback);
+		
+		try{
+			check(writer, 'initialize', context, args);
+			if(!args.omitHeader && check(writer, 'beforeHeader', context, args)){
+				array.forEach(cols, function(cid){
+					context.column = grid.column(cid, 1);	//1 as true
+					check(writer, 'handleHeaderCell', context, args);
+				});
+				check(writer, 'afterHeader', context, args);
+			}
+			if(check(writer, 'beforeBody', context, args)){
+				if(args.selectedOnly && sr && (!sc || !sc.getSelected().length)){
+					waitForRows = model.when().then(function(){
+						rowIds = sr.getSelected();
+					}, fail);
+				}
+				Deferred.when(waitForRows, function(){
+					var rowIdxes,
+						waitForRowIndex = rowIds && model.when({id: rowIds}, function(){
+							rowIdxes = array.map(rowIds, function(id){
+								return model.idToIndex(id);
+							});
+							rowIdxes.sort(function(a, b){
+								return a - b;
+							});
+						}, fail);
+					Deferred.when(waitForRowIndex, function(){
+						var dd = new Deferred(),
+							rowCount = model.size();
+						fetchRows(grid, d, writer, context, args, dd, prepareReqs(args, rowIdxes, rowCount));
+						dd.then(success, fail);
+					}, fail);
+				}, fail);
+			}else{
+				d.callback(writer.getResult());
+			}
+		}catch(e){
+			fail(e);
+		}
+		return d;
+	}
+
+	return exporter;
+});

data/app/assets/javascripts/gridx/support/exporter/toCSV.js

@@ -0,0 +1,75 @@
+define([
+/*====="dojo/_base/declare", =====*/
+	"./exporter"
+], function(/*=====declare, =====*/exporter){
+
+/*=====
+	function toCSV(grid, args){
+		// summary:
+		//		Export the grid contents to CSV according to the given args.
+		// args: __CSVExportArgs?
+		//		The args to configure the export result and the export process.
+		// returns:
+		//		A deferred object indicating when the export process is completed,
+		//		and then pass the exported CSV string to callbacks.
+	}
+
+	toCSV.__CSVExportArgs = declare(exporter.__ExportArgs, {
+		// seperator: String?
+		//		The seperator string used in CSV. Default to comma ','.
+		separator: '',
+
+		// newLine: String?
+		//		The new line string used in CSV. Deault to '\r\n';
+		newLine: ''
+	});
+
+	return toCSV;
+=====*/
+
+	function toCSV(grid, args){
+		return exporter(grid, toCSV.writer, args || {});
+	}
+
+	toCSV.writer = {
+		initialize: function(context, args){
+			this._s = args.separator || ",";
+			this._n = args.newLine || "\r\n";
+			this._lines = [];
+		},
+
+		beforeHeader: function(){
+			this._cells = [];
+		},
+
+		handleHeaderCell: function(context){
+			this._cells.push(context.column.name());
+		},
+
+		afterHeader: function(){
+			this._lines.push(this._cells.join(this._s));
+		},
+
+		beforeRow: function(){
+			this._cells = [];
+		},
+
+		handleCell: function(context){
+			var data = String(context.data).replace(/"/g, '""');
+			if(data.indexOf(this._s) >= 0 || data.search(/[" \t\r\n]/) >= 0){
+				data = '"' + data + '"';
+			}
+			this._cells.push(data);
+		},
+
+		afterRow: function(){
+			this._lines.push(this._cells.join(this._s));
+		},
+
+		getResult: function(){
+			return this._lines.join(this._n);
+		}
+	};
+
+	return toCSV;
+});