gridx-rails 1.1.0

data/app/assets/javascripts/gridx/modules/move/Column.js

@@ -0,0 +1,223 @@
+define([
+/*====="../../core/Column", =====*/
+	"dojo/_base/declare",
+	"dojo/query",
+	"dojo/_base/array",
+	"dojo/keys",
+	"../../core/_Module"
+], function(/*=====Column, =====*/declare, query, array, keys, _Module){
+
+/*=====
+	Column.moveTo = function(target){
+		// summary:
+		//		Move this column to the position before the column with index "target"
+		// target: Integer
+		//		The target index
+	};
+
+	return declare(_Module, {
+		// summary:
+		//		This module provides several APIs to move columns within grid.
+		// description:
+		//		This module does not include any UI. So different kind of column dnd UI implementations can be built
+		//		upon this module.
+		//		But this module does provide a keyboard support for reordering columns. When focus is on a column header,
+		//		pressing CTRL+LEFT/RIGHT ARROW will move the column around within grid.
+
+		// moveSelected: Boolean
+		//		When moving using keyboard, whether to move all selected columns together.
+		moveSelected: true,
+
+		// constraints: Hash-Object
+		//		Define several constraint ranges. Columns within these ranges can not be moved out of the range.
+		//		Columns outside these ranges can not be moved into these ranges.
+		//		Hash key is the starting column index, value is the end column index.
+		//		End index should be always larger than start index.
+		//		For example: { 0: 3 } means the first 4 columns can only be moved within themselves,
+		//		they can not be moved out and other columns can not be moved in.
+		constraints: Object,
+
+		move: function(columnIndexes, target){
+			// summary:
+			//		Move some columns to the given target position
+			// columnIndexes: Integer[]
+			//		The current indexes of columns to move
+			// target: Integer
+			//		The moved columns will be inserted before the column with this index.
+		},
+
+		moveRange: function(start, count, target){
+			// summary:
+			//		Move a range of columns to a given target position
+			// start: Integer
+			//		The index of the first column to move
+			// count: Integer
+			//		The count of columns to move
+		},
+
+		onMoved: function(){
+			// summary:
+			//		Fired when column move is performed successfully
+			// tags:
+			//		callback
+		}
+	});
+=====*/
+
+	return declare(_Module, {
+		name: 'moveColumn',
+		
+		getAPIPath: function(){
+			return {
+				move: {
+					column: this
+				}
+			};
+		},
+
+		preload: function(){
+			this.aspect(this.grid, 'onHeaderCellKeyDown', '_onKeyDown');
+		},
+
+		columnMixin: {
+			moveTo: function(target){
+				this.grid.move.column.moveRange(this.index(), 1, target);
+				return this;
+			}
+		},
+		
+		//public---------------------------------------------------------------
+		moveSelected: true,
+
+		//constraints: null,
+
+		_isInConstraints: function(idx, target){
+			var c = this.arg('constraints', {}),
+				outRange = function(a, b, start){
+					return idx >= start && idx <= c[start] && (target < start || target > c[start] + 1);
+				};
+			for(var start in c){
+				if(outRange(idx, target, start) || outRange(target, idx, start)){
+					return 0;
+				}
+			}
+			return 1;
+		},
+
+		move: function(columnIndexes, target){
+			if(typeof columnIndexes === 'number'){
+				columnIndexes = [columnIndexes];
+			}
+			var map = [], i, len, columns = this.grid._columns, pos, movedCols = [];
+			for(i = 0, len = columnIndexes.length; i < len; ++i){
+				if(this._isInConstraints(columnIndexes[i], target)){
+					map[columnIndexes[i]] = true;
+				}
+			}
+			for(i = map.length - 1; i >= 0; --i){
+				if(map[i]){
+					movedCols.unshift(columns[i]);
+					columns.splice(i, 1);
+				}
+			}
+			for(i = 0, len = columns.length; i < len; ++i){
+				if(columns[i].index >= target){
+					pos = i;
+					break;
+				}
+			}
+			if(pos === undefined){
+				pos = columns.length;
+			}
+			this._moveComplete(movedCols, pos);
+		},
+	
+		moveRange: function(start, count, target){
+			if(target < start || target > start + count){
+				var colsToMove = [];
+				for(var i = 0; i < count; ++i){
+					if(this._isInConstraints(start + i, target)){
+						colsToMove.push(start + i);
+					}
+				}
+				this.move(colsToMove, target);
+			}
+		},
+		
+		//Events--------------------------------------------------------------------
+		onMoved: function(){},
+		
+		//Private-------------------------------------------------------------------
+		_moveComplete: function(movedCols, target){
+			var g = this.grid,
+				map = {},
+				columns = g._columns,
+				i, movedColIds = {},
+				targetId = target < columns.length ? columns[target].id : null,
+				update = function(tr){
+					var cells = query('> .gridxCell', tr).filter(function(cellNode){
+						return movedColIds[cellNode.getAttribute('colid')];
+					});
+					if(targetId === null){
+						cells.place(tr);
+					}else{
+						var nextNode = query('> [colid="' + g._escapeId(targetId) + '"]', tr)[0];
+						if(nextNode){
+							cells.place(nextNode, 'before');
+						}else if(target > 0){
+							var tid = columns[target - 1].id;
+							var prevNode = query('> [colid="' + g._escapeId(tid) + '"]', tr)[0];
+							if(prevNode){
+								cells.place(prevNode, 'after');
+							}
+						}
+					}
+				};
+			for(i = movedCols.length - 1; i >= 0; --i){
+				map[movedCols[i].index] = target + i;
+				movedColIds[movedCols[i].id] = 1;
+			}
+			[].splice.apply(columns, [target, 0].concat(movedCols));
+			for(i = columns.length - 1; i >= 0; --i){
+				columns[i].index = i;
+			}
+			query('.gridxHeaderRowInner > table > tbody > tr', g.headerNode).forEach(update);
+			query('.gridxRow > table > tbody > tr', g.bodyNode).forEach(update);
+			this.onMoved(map);
+		},
+
+		_onKeyDown: function(e){
+			var t = this,
+				g = t.grid,
+				selector = t.arg('moveSelected') && g.select && g.select.column,
+				ltr = g.isLeftToRight(),
+				preKey = ltr ? keys.LEFT_ARROW : keys.RIGHT_ARROW,
+				postKey = ltr ? keys.RIGHT_ARROW : keys.LEFT_ARROW;
+			if(e.ctrlKey && !e.shiftKey && !e.altKey && (e.keyCode == preKey || e.keyCode == postKey)){
+				var target = e.columnIndex,
+					colIdxes = selector && selector.isSelected(e.columnId) ?
+						array.map(selector.getSelected(), function(id){
+							return g._columnsById[id].index;
+						}) : [e.columnIndex],
+					node = g.header.getHeaderNode(e.columnId);
+				if(e.keyCode == preKey){
+					while(array.indexOf(colIdxes, target) >= 0){
+						target--;
+					}
+					if(target >= 0){
+						t.move(colIdxes, target);
+						g.header._focusNode(node);
+					}
+				}else if(e.keyCode == postKey){
+					while(array.indexOf(colIdxes, target) >= 0){
+						target++;
+					}
+					if(target < g._columns.length){
+						t.move(colIdxes, target + 1);
+						g.header._focusNode(node);
+					}
+				}
+			}
+		}
+	});
+});

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

@@ -0,0 +1,154 @@
+define([
+/*====="../../core/Row", =====*/
+	"dojo/_base/declare",
+	"dojo/_base/array",
+	"dojo/keys",
+	"../../core/_Module",
+	"../../core/model/extensions/Move"
+], function(/*=====Row, =====*/declare, array, keys, _Module, Move){
+
+/*=====
+	Row.moveTo = function(target, skipUpdateBody){
+	};
+
+	return declare(_Module, {
+		// summary:
+		//		This module provides some APIs to move rows within grid
+		// description:
+		//		This module requires the "Move" model extension.
+		//		This module does not include any UI. So different kind of row dnd UI implementations can be built
+		//		upon this module.
+		//		But this module does provide a keyboard support for reordering rows. When focus is on a row,
+		//		pressing CTRL+UP/DOWN ARROW will move the row around within grid.
+		//		This module uses gridx/core/model/extensions/Move.
+
+		// moveSelected: Boolean
+		//		When moving using keyboard, whether to move all selected rows together.
+		moveSelected: true,
+
+		move: function(rowIndexes, target, skipUpdateBody){
+			// summary:
+			//		Move some rows to target position
+			// rowIndexes: Integer[]
+			//		An array of row indexes
+			// target: Integer
+			//		The rows will be moved to the position before the target row
+			// skipUpdateBody: Boolean?
+			//		If set to true, the grid will not refresh immediately, so that several
+			//		grid operations can be done altogether.
+		},
+
+		moveRange: function(start, count, target, skipUpdateBody){
+			// summary:
+			//		Move a range of rows to target position
+			// start: Integer
+			//		The index of the first row to be moved
+			// count: Integer
+			//		The count of rows to be moved
+			// skipUpdateBody: Boolean?
+			//		
+		},
+
+		onMoved: function(rowIndexMapping){
+			// summary:
+			//		Fired when row move is performed successfully
+			// tags:
+			//		callback
+		}
+	});
+=====*/
+
+	return declare(_Module, {
+		name: 'moveRow',
+		
+		modelExtensions: [Move],
+
+		constructor: function(){
+			this.connect(this.model, 'onMoved', '_onMoved');
+		},
+	
+		getAPIPath: function(){
+			return {
+				move: {
+					row: this
+				}
+			};
+		},
+
+		preload: function(){
+			this.aspect(this.grid, 'onRowKeyDown', '_onKeyDown');
+		},
+		
+		rowMixin: {
+			moveTo: function(target, skipUpdateBody){
+				this.grid.move.row.move([this.index()], target, skipUpdateBody);
+				return this;
+			}
+		},
+		
+		//Public-----------------------------------------------------------------
+		moveSelected: true,
+
+		move: function(rowIndexes, target, skipUpdateBody){
+			var m = this.model;
+			m.moveIndexes(rowIndexes, target);
+			if(!skipUpdateBody){
+				m.when();
+			}
+		},
+		
+		moveRange: function(start, count, target, skipUpdateBody){
+			var m = this.model;
+			m.move(start, count, target);
+			if(!skipUpdateBody){
+				m.when();
+			}
+		},
+		
+		//Events------------------------------------------------------------------
+		onMoved: function(/* rowIndexMapping */){},
+		
+		//Private-----------------------------------------------------------------
+		_onMoved: function(){
+			this.grid.body.refresh();
+			this.onMoved();
+		},
+
+		_onKeyDown: function(e){
+			var t = this,
+				g = t.grid,
+				selector = g.select && g.select.row;
+			if(e.ctrlKey && !e.shiftKey && !e.altKey && (e.keyCode == keys.UP_ARROW || e.keyCode == keys.DOWN_ARROW)){
+				var target = e.rowIndex,
+					doMove = function(rowIdxes){
+						if(e.keyCode == keys.UP_ARROW){
+							while(array.indexOf(rowIdxes, target) >= 0){
+								target--;
+							}
+							if(target >= 0){
+								t.move(rowIdxes, target);
+							}
+						}else{
+							while(array.indexOf(rowIdxes, target) >= 0){
+								target++;
+							}
+							if(target < g.view.rootStart + g.view.rootCount){
+								t.move(rowIdxes, target + 1);
+							}
+						}
+					};
+				if(t.arg('moveSelected') && selector && selector.isSelected(e.rowId)){
+					var selected = selector.getSelected();
+					g.model.when({id: selected}, function(){
+						var rowIdxes = array.map(selected, function(id){
+							return g.model.idToIndex(id);
+						});
+						doMove(rowIdxes);
+					});
+				}else{
+					doMove([g.model.idToIndex(e.rowId)]);
+				}
+			}
+		}
+	});
+});

data/app/assets/javascripts/gridx/modules/pagination/Pagination.js

@@ -0,0 +1,16 @@
+define([
+/*====='dojo/_base/declare',=====*/
+	'dojo/_base/kernel',
+	'../Pagination'
+], function(/*=====declare, =====*/kernel, Pagination){
+	kernel.deprecated('Pagination is moved from gridx/modules/pagination/Pagination to gridx/modules/Pagination.', 'Use the new path instead.', '1.3');
+
+/*=====
+	return declare([], {
+		// summary:
+		//		Moved to gridx/modules/Pagination. This path is deprecated.
+	});
+=====*/
+
+	return Pagination;
+});

data/app/assets/javascripts/gridx/modules/pagination/PaginationBar.js

@@ -0,0 +1,68 @@
+define([
+	'dojo/_base/declare',
+	'dojo/dom-class',
+	'./_PaginationBarBase',
+	'../../support/LinkPager',
+	'../../support/LinkSizer',
+	'../../support/GotoPageButton'
+], function(declare, domClass, _PaginationBarBase, LinkPager, LinkSizer, GotoPageButton){
+
+/*=====
+	return declare(_PaginationBarBase, {
+		// summary:
+		//		Show link button pagination bar at the bottom of grid.
+		// description:
+		//		This module directly uses gridx/modules/Bar to show gridx/support/Summary, gridx/support/LinkPager, gridx/support/LinkSizer,
+		//		and gridx/support/GotoPageButton.
+		//		This module depends on "bar" and "pagination" modules.
+
+		// visibleSteppers: Integer
+		visibleSteppers: 3,
+
+		// sizeSeparator: String
+		sizeSeparator: '|',
+
+		// gotoButton: Boolean|String
+		gotoButton: true
+	});
+=====*/
+
+	return declare(_PaginationBarBase, {
+		visibleSteppers: 3,
+
+		sizeSeparator: '|',
+
+		gotoButton: true,
+
+		_init: function(pos){
+			var t = this,
+				gotoBtnProt = GotoPageButton.prototype;
+			t._add(LinkPager, 1, pos, 'stepper', {
+				className: 'gridxPagerStepperTD',
+				visibleSteppers: t.arg('visibleSteppers')
+			});
+			t._add(LinkSizer, 2, pos, 'sizeSwitch', {
+				className: 'gridxPagerSizeSwitchTD',
+				sizes: t.arg('sizes'),
+				sizeSeparator: t.arg('sizeSeparator')
+			});
+			t._add(GotoPageButton, 3, pos, 'gotoButton', {
+				className: 'gridxPagerGoto',
+				dialogClass: t.arg('dialogClass') || gotoBtnProt.dialogClass,
+				dialogProps: t.arg('dialogProps') || gotoBtnProt.dialogProps,
+				buttonClass: t.arg('buttonClass') || gotoBtnProt.buttonClass,
+				numberTextBoxClass: t.arg('numberTextBoxClass') || gotoBtnProt.numberTextBoxClass
+			});
+		},
+
+		_refresh: function(bar, pos){
+			var t = this;
+			domClass.toggle(bar[1].domNode, 'dijitHidden', !t._exist(pos, 'stepper'));
+			domClass.toggle(bar[2].domNode, 'dijitHidden', !t._exist(pos, 'sizeSwitch'));
+			domClass.toggle(bar[3].domNode.parentNode, 'dijitHidden', !t._exist(pos, 'gotoButton'));
+			bar[1].visibleSteppers = t.arg('visibleSteppers');
+			bar[2].sizes = t.arg('sizes');
+			bar[2].sizeSeparator = t.arg('sizeSeparator');
+		}
+	});
+});

data/app/assets/javascripts/gridx/modules/pagination/PaginationBarDD.js

@@ -0,0 +1,40 @@
+define([
+	'dojo/_base/declare',
+	'dojo/dom-class',
+	'./_PaginationBarBase',
+	'../../support/DropDownPager',
+	'../../support/DropDownSizer'
+], function(declare, domClass, _PaginationBarBase, DropDownPager, DropDownSizer){
+
+/*=====
+	return declare(_PaginationBarBase, {
+	});
+=====*/
+
+	return declare(_PaginationBarBase, {
+		_init: function(pos){
+			var t = this,
+				pagerProt = DropDownPager.prototype,
+				sizerProt = DropDownSizer.prototype;
+			t._add(DropDownPager, 1, pos, 'stepper', {
+				className: 'gridxPagerStepperTD',
+				visibleSteppers: t.arg('visibleSteppers'),
+				stepperClass: t.arg('stepperClass') || pagerProt.stepperClass,
+				stepperProps: t.arg('stepperProps') || pagerProt.stepperProps
+			});
+			t._add(DropDownSizer, 2, pos, 'sizeSwitch', {
+				className: 'gridxPagerSizeSwitchTD',
+				sizes: t.arg('sizes'),
+				sizeSeparator: t.arg('sizeSeparator'),
+				sizerClass: t.arg('sizerClass') || sizerProt.sizerClass,
+				sizerProps: t.arg('sizerProps') || sizerProt.sizerProps
+			});
+		},
+
+		_refresh: function(bar, pos){
+			domClass.toggle(bar[1].domNode, 'dijitHidden', !this._exist(pos, 'stepper'));
+			domClass.toggle(bar[2].domNode, 'dijitHidden', !this._exist(pos, 'sizeSwitch'));
+			bar[2].sizes = this.arg('sizes');
+		}
+	});
+});

data/app/assets/javascripts/gridx/modules/pagination/_PaginationBarBase.js

@@ -0,0 +1,105 @@
+define([
+	'dojo/_base/declare',
+	'dojo/_base/lang',
+	'dojo/dom-class',
+	'../../core/_Module',
+	'../../support/Summary',
+	'../Bar'
+], function(declare, lang, domClass, _Module, Summary){
+
+/*=====
+	return declare(_Module, {
+		// sizes: Integer[]
+		sizes: [10, 25, 50, 0],
+
+		// position: String
+		//		The position of the pagination bar, can be "bottom" (default), "top" or "both" (any other value means "both")
+		position: 'bottom',
+
+		// description: Boolean|String
+		//		Whether (and where) to show "description" part of the pagination bar UI.
+		//		Can be true/false, or "bottom", or "top"
+		description: true,
+
+		// stepper: Boolean|String
+		//		Whether (and where) to show "page stepper" part of the pagination bar UI.
+		//		Can be true/false, or "bottom", or "top"
+		stepper: true,
+
+		// sizeSwith: Boolean|String
+		//		Whether (and where) to show "page size switcher" part of the pagination bar UI.
+		//		Can be true/false, or "bottom", or "top"
+		sizeSwitch: true,
+
+		refresh: function(){
+			// summary:
+			//		Redraw the pagination bar using corrent parameters.
+		}
+	});
+=====*/
+
+	return declare(_Module, {
+		name: 'paginationBar',
+
+		required: ['bar', 'pagination'],
+
+		sizes: [10, 25, 50, 0],
+
+		position: 'bottom',
+
+		description: true,
+
+		stepper: true,
+
+		sizeSwitch: true,
+
+		preload: function(){
+			for(var t = this, i = 0, positions = ['top', 'bottom']; i < positions.length; ++i){
+				var pos = positions[i];
+				if(t._exist(pos)){
+					t._add(Summary, 0, pos, 'description', {
+						className: 'gridxPagerDescriptionTD'
+					});
+					t._init(pos);
+				}
+			}
+		},
+
+		refresh: function(){
+			var t = this,
+				bar = t.grid.bar,
+				update = function(bar, pos){
+					if(bar){
+						bar = bar[0];
+						domClass.toggle(bar[0].domNode, 'dijitHidden', !t._exist(pos, 'description'));
+						t._refresh(bar, pos);
+						for(var i = 0; i < bar.length; ++i){
+							bar[i].refresh();
+						}
+					}
+				};
+			update(bar.plugins.pagingtop, 'top');
+			update(bar.plugins.pagingbottom, 'bottom');
+		},
+
+		//Private--------------------------------------------------------------------------
+		_add: function(plugin, col, bar, name, args){
+			this.grid.bar.defs.push(lang.mixin({
+				bar: 'paging' + bar,
+				priority: bar == 'top' ? -1 : 2,
+				container: bar == 'top' ? 'headerNode' : 'footerNode',
+				barClass: 'gridxPaginationBar',
+				row: 0,
+				col: col,
+				'class': this._exist(bar, name) ? '' : 'dijitHidden',
+				pluginClass: plugin
+			}, args));
+		},
+
+		_exist: function(pos, argName){
+			var v = this.arg(argName || 'position');
+			v = v && String(v).toLowerCase();
+			return v && ((v != 'top' && v != 'bottom') || v == pos);
+		}
+	});
+});