gridx-rails 1.1.0

data/app/assets/javascripts/gridx/modules/select/Row.js

@@ -0,0 +1,302 @@
+define([
+/*====="../../core/Row", =====*/
+	"dojo/_base/declare",
+	"dojo/_base/array",
+	"dojo/_base/sniff",
+	"dojo/_base/event",
+	"dojo/query",
+	"dojo/_base/lang",
+	"dojo/dom-class",
+	"dojo/keys",
+	"./_RowCellBase",
+	"../../core/_Module"
+], function(/*=====Row, =====*/declare, array, has, event, query, lang, domClass, keys, _RowCellBase, _Module){
+
+/*=====
+	Row.select = function(){
+		// summary:
+		//		Select this row.
+	};
+	Row.deselect = function(){
+		// summary:
+		//		Deselect this row.
+	};
+	Row.isSelected = function(){
+		// summary:
+		//		Whether this row is selected.
+	};
+	Row.isSelectable = function(){
+		// summary:
+		//		Check whether this row is selectable.
+	};
+	Row.setSelectable = function(){
+		// summary:
+		//		Set this row to be selectable or not.
+	};
+
+	return declare(_RowCellBase, {
+		// summary:
+		//		Provides simple row selection.
+		// description:
+		//		This module provides a simple way for selecting rows by clicking or SPACE key, or CTRL + Click to select multiple rows.
+		//		This module uses gridx/core/model/extensions/Mark.
+		//
+		// example:
+		//		1. Use select api on grid row object obtained from grid.row(i)
+		//		|	grid.row(1).select();
+		//		|	grid.row(1).deselect();
+		//		|	grid.row(1).isSelected();
+		//
+		//		2. Use select api on select.row module
+		//		|	grid.select.row.selectById(rowId);
+		//		|	grid.select.row.deSelectById(rowId);
+		//		|	grid.select.row.isSelected(rowId);
+		//		|	grid.select.row.getSelected();//[]
+		//		|	grid.select.row.clear();
+
+		// triggerOnCell: [readonly] Boolean
+		//		Whether row can be selected by clicking on cell, false by default
+		triggerOnCell: false,
+
+		// treeMode: Boolean
+		//		Whether to apply tri-state selection for child rows.
+		treeMode: true,
+
+		// unselectable: Object
+		//		User can set unselectable rows in this hash object. The hash key is the row ID.
+		unselectable: {},
+
+		// setSelectable: Function(rowId, selectable)
+		//		TODOC
+		setSelectable: function(){},
+
+		selectById: function(rowId){
+			// summary:
+			//		Select a row by id.
+		},
+
+		deselectById: function(rowId){
+			// summary:
+			//		Deselect a row by id.
+		},
+
+		isSelected: function(rowId){
+			// summary:
+			//		Check if a row is already selected.
+		},
+
+		getSelected: function(){
+			// summary:
+			//		Get id array of all selected rows
+		},
+
+		clear: function(notClearId){
+			// summary:
+			//		Deselected all selected rows;
+		},
+
+		onSelected: function(row, rowId){
+			// summary:
+			//		Fired when a row is selected.
+			// row: grid.core.Row
+			//		The Row object (null if the row is not yet loaded);
+			// rowId:
+			//		The row ID
+		},
+
+		onDeselected: function(row, rowId){
+			// summary:
+			//		Fired when a row is deselected.
+			// row: grid.core.Row
+			//		The Row object (null if the row is not yet loaded);
+			// rowID:
+			//		The row ID
+		},
+
+		onHighlightChange: function(){
+			// summary:
+			//		Fired when a row's highlight is changed.
+			// tags:
+			//		private
+		},
+	});
+=====*/
+
+	return declare(_RowCellBase, {
+		name: "selectRow",
+		
+		rowMixin: {
+			select: function(){
+				this.grid.select.row.selectById(this.id);
+				return this;
+			},
+
+			deselect: function(){
+				this.grid.select.row.deselectById(this.id);
+				return this;
+			},
+
+			isSelected: function(){
+				return this.grid.select.row.isSelected(this.id);
+			},
+
+			isSelectable: function(){
+				return this.grid.select.row._isSelectable(this.id);
+			},
+
+			setSelectable: function(selectable){
+				this.grid.select.row.setSelectable(this.id, selectable);
+			}
+		},
+
+		//Public API--------------------------------------------------------------------------------
+		treeMode: true,
+
+		setSelectable: function(rowId, selectable){
+			var t = this,
+				m = t.model,
+				n = t.grid.body.getRowNode({
+					rowId: rowId
+				});
+			m.setMarkable(rowId, selectable);
+			t.unselectable[rowId] = !selectable;
+			if(n){
+				domClass.toggle(n, 'gridxRowUnselectable', !selectable);
+				t.onHighlightChange({row: parseInt(n.getAttribute('visualindex'), 10)}, m.getMark(rowId));
+				t.onSelectionChange();
+			}
+		},
+
+		getSelected: function(){
+			return this.model.getMarkedIds();
+		},
+
+		clear: function(notClearId){
+			if(this.arg('enabled')){
+				var model = this.model;
+				array.forEach(model.getMarkedIds(), function(id){
+					if(id !== notClearId){
+						model.markById(id, 0);
+					}
+				});
+				model.when();
+			}
+		},
+
+		//Private--------------------------------------------------------------------------------
+		_type: 'row',
+
+		_isSelectable: function(rowId){
+			var unselectable = this.arg('unselectable'),
+				ret = rowId in unselectable ? !unselectable[rowId] : true;
+			return ret;
+		},
+
+		_getUnselectableRows: function(){
+			var ret = [],
+				t = this,
+				unselectable = t.arg('unselectable');
+			for(var id in unselectable){
+				if(t.unselectable[id] && t.model.byId(id)){
+					ret.push(id);
+				}
+			}
+			return ret;
+		},
+
+		_init: function(){
+			var t = this,
+				g = t.grid,
+				unselectable = t.arg('unselectable', {});
+			t.model.treeMarkMode('', t.arg('treeMode'));
+			for(var id in unselectable){
+				t.model.setMarkable(id, !unselectable[id]);
+			}
+			t.inherited(arguments);
+			t.model._spTypes.select = 1;
+			t.model.setMarkable(lang.hitch(t, '_isSelectable'));
+			t.batchConnect(
+				[g, 'onRowClick', function(e){
+					//Have to check whether we are on the 
+					if((t.arg('triggerOnCell') &&
+						!domClass.contains(e.target, 'gridxTreeExpandoIcon') &&
+						!domClass.contains(e.target, 'gridxTreeExpandoInner')) ||
+						!e.columnId){
+						t._select(e.rowId, g._isCopyEvent(e));
+					}
+				}],
+				[g.body, 'onAfterRow', function(row){
+					var unselectable = !row.isSelectable();
+					domClass.toggle(row.node(), 'gridxRowUnselectable', unselectable);
+				}],
+				[g, has('ff') < 4 ? 'onRowKeyUp' : 'onRowKeyDown', function(e){
+					if((t.arg('triggerOnCell') || !e.columnId) && e.keyCode == keys.SPACE){
+						var cell = g.cell(e.rowId, e.columnId);
+						if(!(cell && cell.isEditing && cell.isEditing())){
+							t._select(e.rowId, g._isCopyEvent(e));
+							event.stop(e);
+						}
+					}
+				}],
+				[g, 'setStore', '_syncMarkable']
+				);
+		},
+
+		_onMark: function(id, toMark, oldState, type){
+			if(type == 'select'){
+				var t = this;
+				t._highlight(id, toMark);
+				t[toMark ? 'onSelected' : 'onDeselected'](t.grid.row(id, 1), id);
+				t._onSelectionChange();
+			}
+		},
+
+		_highlight: function(rowId, toHighlight){
+			var nodes = query('[rowid="' + this.grid._escapeId(rowId) + '"]', this.grid.mainNode),
+				selected = toHighlight && toHighlight != 'mixed';
+			if(nodes.length){
+				nodes.forEach(function(node){
+					domClass.toggle(node, "gridxRowSelected", selected);
+					domClass.toggle(node, "gridxRowPartialSelected", toHighlight == 'mixed');
+					node.setAttribute('aria-selected', !!selected);
+				});
+				this.onHighlightChange({row: parseInt(nodes[0].getAttribute('visualindex'), 10)}, toHighlight);
+			}
+		},
+
+		_markById: function(id, toMark){
+			var t = this,
+				m = t.model,
+				g = t.grid,
+				row = g.row(id);
+			if(m.treeMarkMode() && !m.getMark(id) && toMark){
+				toMark = 'mixed';
+			}
+			m.markById(id, toMark);
+			m.when();
+		},
+
+		_onRender: function(start, count){
+			var t = this,
+				g = t.grid,
+				model = t.model,
+				end = start + count,
+				i, id, rowNode;
+			for(i = start; i < end; ++i){
+				rowNode = t.grid.body.getRowNode({visualIndex: i});
+				if(rowNode){
+					id = rowNode.getAttribute('rowid');
+					t._highlight(id, model.getMark(id));
+				}
+			}
+		},
+	
+		_syncMarkable: function(){
+			var t = this,
+				unselectable = this.arg('unselectable');
+			for(var id in unselectable){
+				t.model.setMarkable(id, !unselectable[id]);
+			}	
+		}
+	});
+});

data/app/assets/javascripts/gridx/modules/select/_Base.js

@@ -0,0 +1,99 @@
+define([
+	'dojo/_base/declare',
+	'dojo/_base/connect',
+	'../../core/_Module'
+], function(declare, connect, _Module){
+
+/*=====
+	return declare(_Module, {
+		// enabled: Boolean
+		//		Whether this module is enabled.
+		enabled: true,
+	
+		// multiple: Boolean
+		//		Whether multiple selectionis allowe.
+		multiple: true,
+	
+		// holdingCtrl: Boolean
+		//		Whether to add to selection all the time (as if the CTRL key is always held).
+		holdingCtrl: false,
+
+		onSelected: function(){},
+
+		onDeselected: function(){},
+
+		onHighlightChange: function(){}
+	});
+=====*/
+
+	return declare(_Module, {
+		getAPIPath: function(){
+			var path = {
+				select: {}
+			};
+			path.select[this._type] = this;
+			return path;
+		},
+
+		preload: function(){
+			var t = this, g = t.grid;
+			t._lastSelectedIds = [];
+			t.subscribe('gridClearSelection_' + g.id, function(type){
+				if(type != t._type){
+					t.clear();
+				}
+			});
+			t.connect(g.body, 'onRender', '_onRender');
+			if(t.arg('multiple')){
+				g.domNode.setAttribute('aria-multiselectable', true);
+			}
+			t._init();
+		},
+
+		//Public--------------------------------------------------------------------
+		enabled: true,
+
+		multiple: true,
+
+		holdingCtrl: false,
+
+		//Events----------------------------------------------------------------------
+		onSelected: function(){},
+
+		onDeselected: function(){},
+
+		onHighlightChange: function(){},
+
+		onSelectionChange: function(){},
+
+		//Private---------------------------------------------------------------------
+		_getMarkType: function(){},
+
+		_isSelected: function(){
+			return this.isSelected.apply(this, arguments);
+		},
+
+		_isSelectable: function(){
+			return true;
+		},
+
+		_onSelectionChange: function(){
+			var t = this, selectedIds = t.getSelected();
+			t.onSelectionChange(selectedIds, t._lastSelectedIds);
+			t._lastSelectedIds = selectedIds;
+		},
+
+		_select: function(item, extending){
+			var t = this, toSelect = 1, g = t.grid;
+			if(t.arg('enabled') && t._isSelectable(item)){
+				if(t.arg('multiple') && (extending || t.arg('holdingCtrl'))){
+					toSelect = !t._isSelected(item);
+				}else{
+					t.clear(item);
+				}
+				connect.publish('gridClearSelection_' + t.grid.id, [t._type]);
+				t._markById(item, toSelect);
+			}
+		}
+	});
+});

data/app/assets/javascripts/gridx/modules/select/_RowCellBase.js

@@ -0,0 +1,51 @@
+define([
+	"dojo/_base/declare",
+	"dojo/_base/lang",
+	"./_Base",
+	"../../core/model/extensions/Mark"
+], function(declare, lang, _Base, Mark){
+
+/*=====
+	return declare(_Base, {
+	});
+=====*/
+
+	return declare(_Base, {
+		modelExtensions: [Mark],
+
+		selectById: function(rowId, columnId){
+			var t = this,
+				m = t.model,
+				type = t._getMarkType(columnId),
+				item = t._type == 'row' ? rowId : [rowId, columnId];
+			if(t.arg('enabled') && t._isSelectable(item)){
+				if(!t.arg('multiple')){
+					m.clearMark(type);
+				}
+				m.markById(rowId, 1, type);
+				m.when();
+			}
+		},
+
+		deselectById: function(rowId, columnId){
+			var t = this,
+				m = t.model,
+				item = t._type == 'row' ? rowId : [rowId, columnId];
+			if(t.arg('enabled') && t._isSelectable(item)){
+				m.markById(rowId, 0, t._getMarkType(columnId));
+				m.when();
+			}
+		},
+
+		isSelected: function(rowId, columnId){
+			//Mixed status is not selected
+			return this.model.getMark(rowId, this._getMarkType(columnId)) === true;
+		},
+
+		//Private-----------------------------------------------------------------
+		_init: function(){
+			var t = this, m = t.model;
+			t.connect(m, 'onMarkChange', '_onMark');
+		}
+	});
+});

data/app/assets/javascripts/gridx/nls/Body.js

@@ -0,0 +1,47 @@
+define({root:
+({
+	loadingInfo: "Loading...",
+	emptyInfo: "No items to display",
+	loadFailInfo: "Failed to load data!",
+	loadMore: "Load More",
+	loadMoreLoading: "Loading...",
+	loadPrevious: "Load Previous",
+	loadPreviousLoading: "Loading...",
+	indirectSelectAll: "Press SPACE to select all.",
+	indirectDeselectAll: "Press SPACE to deselect all.",
+	treeExpanded: "Control + left arrow key to collapse this row.",
+	treeCollapsed: "Control + right arrow key to expand this row."
+}),
+"ar": true,
+"bg": true,
+"ca": true,
+"cs": true,
+"da": true,
+"de": true,
+"el": true,
+"es": true,
+"fi": true,
+"fr": true,
+"he": true,
+"hr": true,
+"hu": true,
+"it": true,
+"ja": true,
+"kk": true,
+"ko": true,
+"nb": true,
+"nl": true,
+"pl": true,
+"pt": true,
+"pt-pt": true,
+"ro": true,
+"ru": true,
+"sk": true,
+"sl": true,
+"sv": true,
+"th": true,
+"tr": true,
+"uk": true,
+"zh": true,
+"zh-tw": true
+});

data/app/assets/javascripts/gridx/nls/FilterBar.js

@@ -0,0 +1,133 @@
+define({ root:
+//begin v1.x content
+({
+	"clearFilterDialogTitle": "Clear Filter",
+	"filterDefDialogTitle": "Filter",
+	"defaultRuleTitle": "Rule",
+	"ruleTitleTemplate": "Rule ${ruleNumber}",
+	"noFilterApplied": "No filter applied.",
+	"defineFilter": "Define filter",
+	
+	"conditionEqual": "equal",
+	"conditionNotEqual": "does not equal",
+	"conditionLess": "is less than",
+	"conditionLessEqual": "less than or equal",
+	"conditionGreater": "is greater than",
+	"conditionGreaterEqual": "greater than or equal",
+	"conditionContain": "contains",
+	"conditionIs": "is",
+	"conditionStartWith": "starts with",
+	"conditionEndWith": "ends with",
+	"conditionNotContain": "does not contain",
+	"conditionIsNot": "is not",
+	"conditionNotStartWith": "does not start with",
+	"conditionNotEndWith": "does not end with",
+	"conditionBefore": "before",
+	"conditionAfter": "after",
+	"conditionRange": "range",
+	"conditionIsEmpty": "is empty",
+	
+	"all": "all",
+	"any": "any",
+	"relationAll": "all rules",
+	"waiRelAll": "Match all of the following rules:",
+	"relationAny": "any rule",
+	"waiRelAny": "Match any of the following rules:",
+	"relationMsgFront": "Match",
+	"relationMsgTail": "",
+	"and": "and",
+	"or": "or",
+	
+	"addRuleButton": "Add Rule",
+	"waiAddRuleButton": "Add a new rule",
+	"removeRuleButton": "Remove Rule",
+	"waiRemoveRuleButtonTemplate": "Remove rule ${0}",
+	
+	"addRuleButton": "Add Filter Rule",
+	"cancelButton": "Cancel",
+	"waiCancelButton": "Cancel this dialog",
+	"clearButton": "Clear",
+	"waiClearButton": "Clear the filter",
+	"filterButton": "Filter",
+	"waiFilterButton": "Submit the filter",
+	
+	"columnSelectLabel": "Column:",
+	"waiColumnSelectTemplate": "Column for rule ${0}",
+	"conditionSelectLabel": "Condition:",
+	"waiConditionSelectTemplate": "Condition for rule ${0}",
+	"valueBoxLabel": "Value:",
+	"waiValueBoxTemplate": "Enter value to filter for rule ${0}",
+	
+	"rangeTo": "to",
+	"rangeTemplate": "from ${0} to ${1}",
+	
+	"statusTipHeaderColumn": "Column",
+	"statusTipHeaderCondition": "Rules",
+	"statusTipTitle": "Filter Bar",
+	"statusTipMsg": "Click the filter bar here to filter on values in ${0}.",
+	"anycolumn": "any column",
+	"statusTipTitleNoFilter": "Filter Bar",
+	"statusTipTitleHasFilter": "Filter",
+	"statusTipRelPre": "Match",
+	"statusTipRelPost": "rules.",
+	"statusTipHeaderAll": "Match all rules.",
+	"statusTipHeaderAny": "Match any rules.",
+	
+	"defaultItemsName": "items",
+	"filterBarMsgHasFilterTemplate": "${0} of ${1} ${2} shown.",
+	"filterBarMsgNoFilterTemplate": "No filter applied",
+	
+	"filterBarDefButton": "Define filter",
+	"waiFilterBarDefButton": "Filter the table",
+	"a11yFilterBarDefButton": "Filter...",
+	"filterBarClearButton": "Clear filter",
+	"waiFilterBarClearButton": "Clear the filter",
+	"closeFilterBarBtn": "Close filter bar",
+	
+	"clearFilterMsg": "This will remove the filter and show all available records.",
+	"anyColumnOption": "Any Column",
+	
+	"trueLabel": "True",
+	"falseLabel": "False",
+	"radioTrueLabel": "Value True",
+	"radioFalseLabel": "Value False",
+	"beginTimeRangeLabel": "Time Range Value Start",
+	"endTimeRangeLabel": "Time Range Value End",
+	"beginDateRangeLabel": "Date Range Value Start",
+	"endDateRangeLabel": "Date Range Value End",
+	"startsWithExpr": "${0}*"
+}),
+//end v1.x content
+"ar": true,
+"bg": true,
+"ca": true,
+"cs": true,
+"da": true,
+"de": true,
+"el": true,
+"es": true,
+"fi": true,
+"fr": true,
+"he": true,
+"hr": true,
+"hu": true,
+"it": true,
+"ja": true,
+"kk": true,
+"ko": true,
+"nb": true,
+"nl": true,
+"pl": true,
+"pt": true,
+"pt-pt": true,
+"ro": true,
+"ru": true,
+"sk": true,
+"sl": true,
+"sv": true,
+"th": true,
+"tr": true,
+"uk": true,
+"zh": true,
+"zh-tw": true
+});

data/app/assets/javascripts/gridx/nls/NestedSort.js

@@ -0,0 +1,45 @@
+define({ root:
+({
+	singleSort: "Single Sort",
+	nestedSort: "Nested Sort",
+	ascending: "Click to sort Ascending",
+	descending: "Click to sort Descending",
+	sortingState: "${0} - ${1}",
+	unsorted: "Do not sort this column",
+	
+	waiSingleSortLabel: "${0} - is sorted by ${1}. Choose to sort by ${2}",
+	waiNestedSortLabel:"${0} - is nested sorted by ${1}. Choose to nested sort by ${2}"
+}),
+"ar": true,
+"bg": true,
+"ca": true,
+"cs": true,
+"da": true,
+"de": true,
+"el": true,
+"es": true,
+"fi": true,
+"fr": true,
+"he": true,
+"hr": true,
+"hu": true,
+"it": true,
+"ja": true,
+"kk": true,
+"ko": true,
+"nb": true,
+"nl": true,
+"pl": true,
+"pt": true,
+"pt-pt": true,
+"ro": true,
+"ru": true,
+"sk": true,
+"sl": true,
+"sv": true,
+"th": true,
+"tr": true,
+"uk": true,
+"zh": true,
+"zh-tw": true
+});