Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.grid._data.editors"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojox.grid._data.editors"] = true;

dojo.provide("dojox.grid._data.editors");

dojo.provide("dojox.grid.editors");

dojo.declare("dojox.grid.editors.Base", null, {

	// summary:

	//	base grid editor class. Other grid editors should inherited from this class.

	constructor: function(inCell){

		this.cell = inCell;

	},

	//private

	_valueProp: "value",

	_formatPending: false,

	format: function(inDatum, inRowIndex){

		// summary:

		//	formats the cell for editing

		// inDatum: anything

		//	cell data to edit

		// inRowIndex: int

		//	grid row index

		// returns: string of html to place in grid cell

	},

	//protected

	needFormatNode: function(inDatum, inRowIndex){

		this._formatPending = true;

		dojox.grid.whenIdle(this, "_formatNode", inDatum, inRowIndex);

	},

	cancelFormatNode: function(){

		this._formatPending = false;

	},

	//private

	_formatNode: function(inDatum, inRowIndex){

		if(this._formatPending){

			this._formatPending = false;

			// make cell selectable

			dojo.setSelectable(this.cell.grid.domNode, true);

			this.formatNode(this.getNode(inRowIndex), inDatum, inRowIndex);

		}

	},

	//protected

	getNode: function(inRowIndex){

		return (this.cell.getNode(inRowIndex) || 0).firstChild || 0;

	},

	formatNode: function(inNode, inDatum, inRowIndex){

		// summary:

		//	format the editing dom node. Use when editor is a widget.

		// inNode: dom node

		// dom node for the editor

		// inDatum: anything

		//	cell data to edit

		// inRowIndex: int

		//	grid row index

		if(dojo.isIE){

			// IE sux bad

			dojox.grid.whenIdle(this, "focus", inRowIndex, inNode);

		}else{

			this.focus(inRowIndex, inNode);

		}

	},

	dispatchEvent: function(m, e){

		if(m in this){

			return this[m](e);

		}

	},

	//public

	getValue: function(inRowIndex){

		// summary:

		//	returns value entered into editor

		// inRowIndex: int

		// grid row index

		// returns:

		//	value of editor

		return this.getNode(inRowIndex)[this._valueProp];

	},

	setValue: function(inRowIndex, inValue){

		// summary:

		//	set the value of the grid editor

		// inRowIndex: int

		// grid row index

		// inValue: anything

		//	value of editor

		var n = this.getNode(inRowIndex);

		if(n){

			n[this._valueProp] = inValue

		};

	},

	focus: function(inRowIndex, inNode){

		// summary:

		//	focus the grid editor

		// inRowIndex: int

		// grid row index

		// inNode: dom node

		//	editor node

		dojox.grid.focusSelectNode(inNode || this.getNode(inRowIndex));

	},

	save: function(inRowIndex){

		// summary:

		//	save editor state

		// inRowIndex: int

		// grid row index

		this.value = this.value || this.getValue(inRowIndex);

		//console.log("save", this.value, inCell.index, inRowIndex);

	},

	restore: function(inRowIndex){

		// summary:

		//	restore editor state

		// inRowIndex: int

		// grid row index

		this.setValue(inRowIndex, this.value);

		//console.log("restore", this.value, inCell.index, inRowIndex);

	},

	//protected

	_finish: function(inRowIndex){

		// summary:

		//	called when editing is completed to clean up editor

		// inRowIndex: int

		// grid row index

		dojo.setSelectable(this.cell.grid.domNode, false);

		this.cancelFormatNode(this.cell);

	},

	//public

	apply: function(inRowIndex){

		// summary:

		//	apply edit from cell editor

		// inRowIndex: int

		// grid row index

		this.cell.applyEdit(this.getValue(inRowIndex), inRowIndex);

		this._finish(inRowIndex);

	},

	cancel: function(inRowIndex){

		// summary:

		//	cancel cell edit

		// inRowIndex: int

		// grid row index

		this.cell.cancelEdit(inRowIndex);

		this._finish(inRowIndex);

	}

});

dojox.grid.editors.base = dojox.grid.editors.Base; // back-compat

dojo.declare("dojox.grid.editors.Input", dojox.grid.editors.Base, {

	// summary

	// grid cell editor that provides a standard text input box

	constructor: function(inCell){

		this.keyFilter = this.keyFilter || this.cell.keyFilter;

	},

	// keyFilter: object

	// optional regex for disallowing keypresses

	keyFilter: null,

	format: function(inDatum, inRowIndex){

		this.needFormatNode(inDatum, inRowIndex);

		return '<input class="dojoxGrid-input" type="text" value="' + inDatum + '">';

	},

	formatNode: function(inNode, inDatum, inRowIndex){

		this.inherited(arguments);

		// FIXME: feels too specific for this interface

		this.cell.registerOnBlur(inNode, inRowIndex);

	},

	doKey: function(e){

		if(this.keyFilter){

			var key = String.fromCharCode(e.charCode);

			if(key.search(this.keyFilter) == -1){

				dojo.stopEvent(e);

			}

		}

	},

	_finish: function(inRowIndex){

		this.inherited(arguments);

		var n = this.getNode(inRowIndex);

		try{

			dojox.grid.fire(n, "blur");

		}catch(e){}

	}

});

dojox.grid.editors.input = dojox.grid.editors.Input; // back compat

dojo.declare("dojox.grid.editors.Select", dojox.grid.editors.Input, {

	// summary:

	// grid cell editor that provides a standard select

	// options: text of each item

	// values: value for each item

	// returnIndex: editor returns only the index of the selected option and not the value

	constructor: function(inCell){

		this.options = this.options || this.cell.options;

		this.values = this.values || this.cell.values || this.options;

	},

	format: function(inDatum, inRowIndex){

		this.needFormatNode(inDatum, inRowIndex);

		var h = [ '<select class="dojoxGrid-select">' ];

		for (var i=0, o, v; (o=this.options[i])&&(v=this.values[i]); i++){

			h.push("<option", (inDatum==o ? ' selected' : ''), /*' value="' + v + '"',*/ ">", o, "</option>");

		}

		h.push('</select>');

		return h.join('');

	},

	getValue: function(inRowIndex){

		var n = this.getNode(inRowIndex);

		if(n){

			var i = n.selectedIndex, o = n.options[i];

			return this.cell.returnIndex ? i : o.value || o.innerHTML;

		}

	}

});

dojox.grid.editors.select = dojox.grid.editors.Select; // back compat

dojo.declare("dojox.grid.editors.AlwaysOn", dojox.grid.editors.Input, {

	// summary:

	// grid cell editor that is always on, regardless of grid editing state

	// alwaysOn: boolean

	// flag to use editor to format grid cell regardless of editing state.

	alwaysOn: true,

	_formatNode: function(inDatum, inRowIndex){

		this.formatNode(this.getNode(inRowIndex), inDatum, inRowIndex);

	},

	applyStaticValue: function(inRowIndex){

		var e = this.cell.grid.edit;

		e.applyCellEdit(this.getValue(inRowIndex), this.cell, inRowIndex);

		e.start(this.cell, inRowIndex, true);

	}

});

dojox.grid.editors.alwaysOn = dojox.grid.editors.AlwaysOn; // back-compat

dojo.declare("dojox.grid.editors.Bool", dojox.grid.editors.AlwaysOn, {

	// summary:

	// grid cell editor that provides a standard checkbox that is always on

	_valueProp: "checked",

	format: function(inDatum, inRowIndex){

		return '<input class="dojoxGrid-input" type="checkbox"' + (inDatum ? ' checked="checked"' : '') + ' style="width: auto" />';

	},

	doclick: function(e){

		if(e.target.tagName == 'INPUT'){

			this.applyStaticValue(e.rowIndex);

		}

	}

});

dojox.grid.editors.bool = dojox.grid.editors.Bool; // back-compat

}