diff options
Diffstat (limited to 'js/dojo-1.6/dojox/form/ListInput.xd.js')
| -rw-r--r-- | js/dojo-1.6/dojox/form/ListInput.xd.js | 1016 |
1 files changed, 1016 insertions, 0 deletions
diff --git a/js/dojo-1.6/dojox/form/ListInput.xd.js b/js/dojo-1.6/dojox/form/ListInput.xd.js new file mode 100644 index 0000000..26182f9 --- /dev/null +++ b/js/dojo-1.6/dojox/form/ListInput.xd.js @@ -0,0 +1,1016 @@ +/*
+ Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
+ Available via Academic Free License >= 2.1 OR the modified BSD license.
+ see: http://dojotoolkit.org/license for details
+*/
+
+
+dojo._xdResourceLoaded(function(dojo, dijit, dojox){
+return {depends: [["provide", "dojox.form.ListInput"],
+["require", "dijit.form._FormWidget"],
+["require", "dijit.form.ValidationTextBox"],
+["require", "dijit.InlineEditBox"],
+["requireLocalization", "dijit", "common", null, "ROOT,ar,ca,cs,da,de,el,es,fi,fr,he,hu,it,ja,kk,ko,nb,nl,pl,pt,pt-pt,ro,ru,sk,sl,sv,th,tr,zh,zh-tw", "ROOT,ar,ca,cs,da,de,el,es,fi,fr,he,hu,it,ja,kk,ko,nb,nl,pl,pt,pt-pt,ro,ru,sk,sl,sv,th,tr,zh,zh-tw"]],
+defineResource: function(dojo, dijit, dojox){if(!dojo._hasResource["dojox.form.ListInput"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.form.ListInput"] = true;
+dojo.experimental("dojox.form.ListInput");
+
+dojo.provide("dojox.form.ListInput");
+
+dojo.require("dijit.form._FormWidget");
+dojo.require("dijit.form.ValidationTextBox");
+dojo.require("dijit.InlineEditBox");
+;
+
+dojo.declare("dojox.form.ListInput",
+ [dijit.form._FormValueWidget],
+ {
+ // summary:
+ // An automatic list maker
+ // description:
+ // you can add value to list with add method.
+ // you can only remove by clicking close button
+
+ constructor: function(){
+ this._items = [];
+
+
+ if(!dojo.isArray(this.delimiter)){
+ this.delimiter=[this.delimiter];
+ }
+ var r="("+this.delimiter.join("|")+")?";
+ this.regExp="^"+this.regExp+r+"$";
+ },
+
+ // inputClass: String
+ // Class which will be used to create the input box. You can implements yours.
+ // It must be a widget, focusNode or domNode must have "onkeydown" event
+ // It must have .attr("value") to get value
+ // It also must impement an (or more) handler for the "onChange" method
+ inputClass: "dojox.form._ListInputInputBox",
+
+ // inputHandler: String || Array
+ // The widget will connect on all handler to check input value
+ // You can use comma separated list
+ inputHandler: "onChange",
+
+ // inputProperties: String || Object
+ // Properties used to create input box
+ // If String, it must be a valid JSON
+ inputProperties: {
+ minWidth:50
+ },
+
+ // submitOnlyValidValue: Boolean
+ // If true, only valid value will be submited with form
+ submitOnlyValidValue:true,
+
+ // useOnBlur: Boolean
+ // If true, onBlur event do a validate (like pressing ENTER)
+ useOnBlur:true,
+
+ // readOnlyInput: Boolean
+ // if false, the list will be editable
+ // Can only be set when instanciate
+ readOnlyInput: false,
+
+ // maxItems: Int
+ // Specify max item the list can have
+ // null = infiny
+ maxItems: null,
+
+ // showCloseButtonWhenValid: Boolean
+ // if true, a close button will be added on valid item
+ showCloseButtonWhenValid: true,
+
+ // showCloseButtonWhenInvalid: Boolean
+ // if true, a close button will be added on invalid item
+ showCloseButtonWhenInvalid: true,
+
+ // regExp: [extension protected] String
+ // regular expression string used to validate the input
+ // Do not specify both regExp and regExpGen
+ regExp: ".*", //"[a-zA-Z.-_]+@[a-zA-Z.-_]+.[a-zA-Z]+",
+
+ // delimiter: String || Array
+ // delimiter for the string. Every match will be splitted
+ // The string can contain only one delimiter
+ delimiter: ",",
+
+ // constraints: dijit.form.ValidationTextBox.__Constraints
+ // user-defined object needed to pass parameters to the validator functions
+ constraints: {},
+
+ baseClass:"dojoxListInput",
+
+ type: "select",
+
+ value: "",
+
+ templateString: "<div dojoAttachPoint=\"focusNode\" class=\"dijit dijitReset dijitLeft dojoxListInput\"><select dojoAttachpoint=\"_selectNode\" multiple=\"multiple\" class=\"dijitHidden\" ${!nameAttrSetting}></select><ul dojoAttachPoint=\"_listInput\"><li dojoAttachEvent=\"onclick: _onClick\" class=\"dijitInputField dojoxListInputNode dijitHidden\" dojoAttachPoint=\"_inputNode\"></li></ul></div>",
+
+ // useAnim: Boolean
+ // If true, then item will use an anime to show hide itself
+ useAnim: true,
+
+ // duration: Integer
+ // Animation duration
+ duration: 500,
+
+ // easingIn: function
+ // function used to easing on fadeIn end
+ easingIn: null,
+
+ // easingOut: function
+ // function used to easing on fadeOut end
+ easingOut: null,
+
+ // readOnlyItem: Boolean
+ // If true, items can be edited
+ // Can only be set when instanciate
+ readOnlyItem: false,
+
+ // useArrowForEdit: Boolean
+ // If true, arraow left and right can be used for editing
+ // Can only be set when instanciate
+ useArrowForEdit: true,
+
+ // _items: Array
+ // Array of widget.
+ // Contain all reference to _ListInputInputItem
+ _items: null,
+
+ // _lastAddedItem: Widget
+ // Contain a reference to the last created item
+ _lastAddedItem: null,
+
+ // _currentItem: Widget
+ // Widget currently in edition
+ _currentItem: null,
+
+ // _input: Widget
+ // Widget use for input box
+ _input: null,
+
+ // _count: Int
+ // Count items
+ _count: 0,
+
+ postCreate: function(){
+ // summary:
+ // If closeButton is used, add a class
+ this.inherited(arguments);
+ this._createInputBox();
+ },
+
+ _setReadOnlyInputAttr: function(/*Boolean*/value){
+ // summary:
+ // Change status and if needed, create the inputbox
+ // tags:
+ // private
+ if(!this._started){ return this._createInputBox(); }
+ this.readOnlyInput = value;
+ this._createInputBox();
+ },
+
+ _setReadOnlyItemAttr: function(/*Boolean*/value){
+ // summary:
+ // set read only items
+ // tags:
+ // private
+ if(!this._started){ return; }
+ for(var i in this._items){
+ this._items[i].set("readOnlyItem", value);
+ }
+ },
+
+ _createInputBox: function(){
+ // summary:
+ // Create the input box
+ // tags:
+ // private
+ dojo.toggleClass(this._inputNode, "dijitHidden", this.readOnlyInput);
+ if(this.readOnlyInput){ return; }
+ if(this._input){ return; }
+
+ if(this.inputHandler === null){
+ console.warn("you must add some handler to connect to input field");
+ return false;
+ }
+ if(dojo.isString(this.inputHandler)){
+ this.inputHandler = this.inputHandler.split(",");
+ }
+ if(dojo.isString(this.inputProperties)){
+ this.inputProperties = dojo.fromJson(this.inputProperties);
+ }
+
+
+ var input = dojo.getObject(this.inputClass, false);
+
+ this.inputProperties.regExp = this.regExpGen(this.constraints);
+
+ this._input = new input(this.inputProperties);
+ this._input.startup();
+ this._inputNode.appendChild(this._input.domNode);
+ dojo.forEach(this.inputHandler, function(handler){
+ this.connect(this._input,dojo.string.trim(handler),"_onHandler");
+ },this);
+
+ this.connect(this._input, "onKeyDown", "_inputOnKeyDown");
+ this.connect(this._input, "onBlur", "_inputOnBlur");
+ },
+
+ compare: function(/*Array*/val1,/*Array*/val2){
+ // summary:
+ // Compare 2 values (as returned by attr('value') for this widget).
+ // tags:
+ // protected
+ val1 = val1.join(",");
+ val2 = val2.join(",");
+ if(val1 > val2){
+ return 1;
+ }else if(val1 < val2){
+ return -1;
+ }else{
+ return 0;
+ }
+ },
+
+ add: function(/*String || Array*/values){
+ // summary:
+ // Create new list element
+ if(this._count>=this.maxItems && this.maxItems !== null){return;}
+ this._lastValueReported = this._getValues();
+
+ if(!dojo.isArray(values)){
+ values = [values];
+ }
+
+ for(var i in values){
+ var value=values[i];
+ if(value === "" || typeof value != "string"){
+ continue;
+ }
+ this._count++;
+ var re = new RegExp(this.regExpGen(this.constraints));
+
+ this._lastAddedItem = new dojox.form._ListInputInputItem({
+ "index" : this._items.length,
+ readOnlyItem : this.readOnlyItem,
+ value : value,
+ regExp: this.regExpGen(this.constraints)
+ });
+ this._lastAddedItem.startup();
+
+ this._testItem(this._lastAddedItem,value);
+
+ this._lastAddedItem.onClose = dojo.hitch(this,"_onItemClose",this._lastAddedItem);
+ this._lastAddedItem.onChange = dojo.hitch(this,"_onItemChange",this._lastAddedItem);
+ this._lastAddedItem.onEdit = dojo.hitch(this,"_onItemEdit",this._lastAddedItem);
+ this._lastAddedItem.onKeyDown = dojo.hitch(this,"_onItemKeyDown",this._lastAddedItem);
+
+ if(this.useAnim){
+ dojo.style(this._lastAddedItem.domNode, {opacity:0, display:""});
+ }
+
+ this._placeItem(this._lastAddedItem.domNode);
+
+ if(this.useAnim){
+ var anim = dojo.fadeIn({
+ node : this._lastAddedItem.domNode,
+ duration : this.duration,
+ easing : this.easingIn
+ }).play();
+ }
+
+ this._items[this._lastAddedItem.index] = this._lastAddedItem;
+
+ if(this._onChangeActive && this.intermediateChanges){ this.onChange(value); }
+
+ if(this._count>=this.maxItems && this.maxItems !== null){
+ break;
+ }
+ }
+
+ this._updateValues();
+ if(this._lastValueReported.length==0){
+ this._lastValueReported = this.value;
+ }
+
+ if(!this.readOnlyInput){
+ this._input.set("value", "");
+ }
+
+ if(this._onChangeActive){ this.onChange(this.value); }
+
+ this._setReadOnlyWhenMaxItemsReached();
+ },
+
+ _setReadOnlyWhenMaxItemsReached: function(){
+ // summary:
+ // set input to readonly when max is reached
+ // tags:
+ // private
+ this.set("readOnlyInput",(this._count>=this.maxItems && this.maxItems !== null));
+ },
+
+ _setSelectNode: function(){
+ // summary:
+ // put all item in the select (for a submit)
+ // tags:
+ // private
+ this._selectNode.options.length = 0;
+
+ var values=this.submitOnlyValidValue?this.get("MatchedValue"):this.value;
+
+ if(!dojo.isArray(values)){
+ return;
+ }
+ dojo.forEach(values,function(item){
+ this._selectNode.options[this._selectNode.options.length]=new Option(item,item,true,true);
+ },this);
+ },
+
+ _placeItem: function(/*domNode*/node){
+ // summary:
+ // Place item in the list
+ // tags:
+ // private
+ dojo.place(node,this._inputNode,"before");
+ },
+
+ _getCursorPos: function(/*domNode*/node){
+ // summary:
+ // get current cursor pos
+ // tags:
+ // private
+ if(typeof node.selectionStart != 'undefined'){
+ return node.selectionStart;
+ }
+
+ // IE Support
+ try{ node.focus(); }catch(e){}
+ var range = node.createTextRange();
+ range.moveToBookmark(dojo.doc.selection.createRange().getBookmark());
+ range.moveEnd('character', node.value.length);
+ try{
+ return node.value.length - range.text.length;
+ }finally{ range=null; }
+ },
+
+ _onItemClose: function(/*dijit._Widget*/ item){
+ // summary:
+ // Destroy a list element when close button is clicked
+ // tags:
+ // private
+ if(this.disabled){ return; }
+
+ if(this.useAnim){
+ var anim = dojo.fadeOut({
+ node : item.domNode,
+ duration : this.duration,
+ easing : this.easingOut,
+ onEnd : dojo.hitch(this, "_destroyItem", item)
+ }).play();
+ }else{
+ this._destroyItem(item);
+ }
+ },
+
+ _onItemKeyDown: function(/*dijit._Widget*/ item, /*Event*/ e){
+ // summary:
+ // Call when item get a keypress
+ // tags:
+ // private
+ if(this.readOnlyItem || !this.useArrowForEdit){ return; }
+
+ if(e.keyCode == dojo.keys.LEFT_ARROW && this._getCursorPos(e.target)==0){
+ this._editBefore(item);
+ }else if(e.keyCode == dojo.keys.RIGHT_ARROW && this._getCursorPos(e.target)==e.target.value.length){
+ this._editAfter(item);
+ }
+ },
+
+ _editBefore: function(/*widget*/item) {
+ // summary:
+ // move trough items
+ // tags:
+ // private
+ this._currentItem = this._getPreviousItem(item);
+ if(this._currentItem !== null){
+ this._currentItem.edit();
+ }
+ },
+ _editAfter: function(/*widget*/item) {
+ // summary:
+ // move trough items
+ // tags:
+ // private
+ this._currentItem = this._getNextItem(item);
+ if(this._currentItem !== null){
+ this._currentItem.edit();
+ }
+
+ if(!this.readOnlyInput){
+ if(this._currentItem === null){
+ //no more item ?
+ //so edit input (if available)
+ this._focusInput();
+ }
+ }
+ },
+
+ _onItemChange: function(/*dijit._Widget*/ item, /*String*/ value){
+ // summary:
+ // Call when item value change
+ // tags:
+ // private
+
+ value = value || item.get("value");
+
+ //revalidate content
+ this._testItem(item,value);
+
+ //update value
+ this._updateValues();
+ },
+
+ _onItemEdit: function(/*dijit._Widget*/ item){
+ // summary:
+ // Call when item is edited
+ // tags:
+ // private
+ dojo.removeClass(item.domNode,["dijitError", this.baseClass + "Match", this.baseClass + "Mismatch"]);
+ },
+
+ _testItem: function(/*Object*/item,/*String*/value){
+ // summary:
+ // Change class of item (match, mismatch)
+ // tags:
+ // private
+ var re = new RegExp(this.regExpGen(this.constraints));
+ var match = value.match(re);
+
+ dojo.removeClass(item.domNode, this.baseClass + (!match ? "Match" : "Mismatch"));
+ dojo.addClass(item.domNode, this.baseClass + (match ? "Match" : "Mismatch"));
+ dojo.toggleClass(item.domNode, "dijitError", !match);
+
+ if((this.showCloseButtonWhenValid && match) ||
+ (this.showCloseButtonWhenInvalid && !match)){
+ dojo.addClass(item.domNode,this.baseClass+"Closable");
+ }else {
+ dojo.removeClass(item.domNode,this.baseClass+"Closable");
+ }
+ },
+
+ _getValueAttr: function(){
+ // summary:
+ // get all value in then list and return an array
+ // tags:
+ // private
+ return this.value;
+ },
+
+ _setValueAttr: function(/*Array || String*/ newValue){
+ // summary:
+ // Hook so attr('value', value) works.
+ // description:
+ // Sets the value of the widget.
+ // If the value has changed, then fire onChange event, unless priorityChange
+ // is specified as null (or false?)
+ this._destroyAllItems();
+
+ this.add(this._parseValue(newValue));
+ },
+
+ _parseValue: function(/*String*/newValue){
+ // summary:
+ // search for delemiters and split if needed
+ // tags:
+ // private
+ if(typeof newValue == "string"){
+ if(dojo.isString(this.delimiter)){
+ this.delimiter = [this.delimiter];
+ }
+ var re = new RegExp("^.*("+this.delimiter.join("|")+").*");
+ if(newValue.match(re)){
+ re = new RegExp(this.delimiter.join("|"));
+ return newValue.split(re);
+ }
+ }
+ return newValue;
+ },
+
+ regExpGen: function(/*dijit.form.ValidationTextBox.__Constraints*/constraints){
+ // summary:
+ // Overridable function used to generate regExp when dependent on constraints.
+ // Do not specify both regExp and regExpGen.
+ // tags:
+ // extension protected
+ return this.regExp; // String
+ },
+
+ _setDisabledAttr: function(/*Boolean*/ value){
+ // summary:
+ // also enable/disable editable items
+ // tags:
+ // private
+ if(!this.readOnlyItem){
+ for(var i in this._items){
+ this._items[i].set("disabled", value);
+ }
+ }
+
+ if(!this.readOnlyInput){
+ this._input.set("disabled", value);
+ }
+ this.inherited(arguments);
+ },
+
+ _onHandler: function(/*String*/value){
+ // summary:
+ // When handlers of input are fired, this method check input value and (if needed) modify it
+ // tags:
+ // private
+ var parsedValue = this._parseValue(value);
+ if(dojo.isArray(parsedValue)){
+ this.add(parsedValue);
+ }
+ },
+
+ _onClick: function(/*event*/e){
+ // summary:
+ // give focus to inputbox
+ // tags:
+ // private
+ this._focusInput();
+ },
+
+ _focusInput: function(){
+ // summary:
+ // give focus to input
+ // tags:
+ // private
+ if(!this.readOnlyInput && this._input.focus){
+ this._input.focus();
+ }
+ },
+
+ _inputOnKeyDown: function(/*event*/e){
+ // summary:
+ // Used to add keybord interactivity
+ // tags:
+ // private
+ this._currentItem = null;
+ var val = this._input.get("value");
+
+ if(e.keyCode == dojo.keys.BACKSPACE && val == "" && this.get("lastItem")){
+ this._destroyItem(this.get("lastItem"));
+ }else if(e.keyCode == dojo.keys.ENTER && val != ""){
+ this.add(val);
+ }else if(e.keyCode == dojo.keys.LEFT_ARROW && this._getCursorPos(this._input.focusNode) == 0 &&
+ !this.readOnlyItem && this.useArrowForEdit){
+ this._editBefore();
+ }
+ },
+
+ _inputOnBlur: function(){
+ // summary:
+ // Remove focus class and act like pressing ENTER key
+ // tags:
+ // private
+ var val = this._input.get('value');
+ if(this.useOnBlur && val != ""){
+ this.add(val);
+ }
+ },
+
+ _getMatchedValueAttr: function(){
+ // summary:
+ // get value that match regexp in then list and return an array
+ // tags:
+ // private
+ return this._getValues(dojo.hitch(this,this._matchValidator));
+ },
+
+ _getMismatchedValueAttr: function(){
+ // summary:
+ // get value that mismatch regexp in then list and return an array
+ // tags:
+ // private
+ return this._getValues(dojo.hitch(this,this._mismatchValidator));
+ },
+
+ _getValues: function(/*function*/validator){
+ // summary:
+ // return values with comparator constraint
+ // tags:
+ // private
+ var value = [];
+ validator = validator||this._nullValidator;
+ for(var i in this._items){
+ var item = this._items[i];
+ if(item === null){
+ continue;
+ }
+ var itemValue = item.get("value");
+ if(validator(itemValue)){
+ value.push(itemValue);
+ }
+ }
+ return value;
+ },
+
+ _nullValidator: function(/*String*/itemValue){
+ // summary:
+ // return true or false
+ // tags:
+ // private
+ return true;
+ },
+ _matchValidator: function(/*String*/itemValue){
+ // summary:
+ // return true or false
+ // tags:
+ // private
+ var re = new RegExp(this.regExpGen(this.constraints));
+ return itemValue.match(re);
+ },
+ _mismatchValidator: function(/*String*/itemValue){
+ // summary:
+ // return true or false
+ // tags:
+ // private
+ var re = new RegExp(this.regExpGen(this.constraints));
+ return !(itemValue.match(re));
+ },
+
+ _getLastItemAttr: function(){
+ // summary:
+ // return the last item in list
+ // tags:
+ // private
+ return this._getSomeItem();
+ },
+ _getSomeItem: function(/*dijit._Widget*/ item,/*String*/ position){
+ // summary:
+ // return the item before the one in params
+ // tags:
+ // private
+ item=item||false;
+ position=position||"last";
+
+ var lastItem = null;
+ var stop=-1;
+ for(var i in this._items){
+ if(this._items[i] === null){ continue; }
+
+ if(position=="before" && this._items[i] === item){
+ break;
+ }
+
+ lastItem = this._items[i];
+
+ if(position=="first" ||stop==0){
+ stop=1;
+ break;
+ }
+ if(position=="after" && this._items[i] === item){
+ stop=0;
+ }
+ }
+ if(position=="after" && stop==0){
+ lastItem = null;
+ }
+ return lastItem;
+ },
+ _getPreviousItem: function(/*dijit._Widget*/ item){
+ // summary:
+ // return the item before the one in params
+ // tags:
+ // private
+ return this._getSomeItem(item,"before");
+ },
+ _getNextItem: function(/*dijit._Widget*/ item){
+ // summary:
+ // return the item before the one in params
+ // tags:
+ // private
+ return this._getSomeItem(item,"after");
+ },
+
+ _destroyItem: function(/*dijit._Widget*/ item, /*Boolean?*/ updateValue){
+ // summary:
+ // destroy an item
+ // tags:
+ // private
+ this._items[item.index] = null;
+ item.destroy();
+ this._count--;
+ if(updateValue!==false){
+ this._updateValues();
+ this._setReadOnlyWhenMaxItemsReached();
+ }
+ },
+
+ _updateValues: function(){
+ // summary:
+ // update this.value and the select node
+ // tags:
+ // private
+ this.value = this._getValues();
+ this._setSelectNode();
+ },
+
+ _destroyAllItems: function(){
+ // summary:
+ // destroy all items
+ // tags:
+ // private
+ for(var i in this._items){
+ if(this._items[i]==null){ continue; }
+ this._destroyItem(this._items[i],false);
+ }
+ this._items = [];
+ this._count = 0;
+ this.value = null;
+ this._setSelectNode();
+ this._setReadOnlyWhenMaxItemsReached();
+ },
+
+ destroy: function(){
+ // summary:
+ // Destroy all widget
+ this._destroyAllItems();
+ this._lastAddedItem = null;
+
+ if(!this._input){
+ this._input.destroy();
+ }
+
+ this.inherited(arguments);
+ }
+});
+
+dojo.declare("dojox.form._ListInputInputItem",
+ [dijit._Widget, dijit._Templated],
+ {
+ // summary:
+ // Item created by ListInputInput when delimiter is found
+ // description:
+ // Simple <li> with close button added to ListInputInput when delimiter is found
+
+ templateString: "<li class=\"dijit dijitReset dijitLeft dojoxListInputItem\" dojoAttachEvent=\"onclick: onClick\" ><span dojoAttachPoint=\"labelNode\"></span></li>",
+
+ // closeButtonNode: domNode
+ // ref to the close button node
+ closeButtonNode: null,
+
+ // readOnlyItem: Boolean
+ // if true, item is editable
+ readOnlyItem: true,
+
+ baseClass:"dojoxListInputItem",
+
+ // value: String
+ // value of item
+ value: "",
+
+ // regExp: [extension protected] String
+ // regular expression string used to validate the input
+ // Do not specify both regExp and regExpGen
+ regExp: ".*",
+
+ // _editBox: Widget
+ // inline edit box
+ _editBox: null,
+
+ // _handleKeyDown: handle
+ // handle for the keyDown connect
+ _handleKeyDown: null,
+
+ attributeMap: {
+ value: { node: "labelNode", type: "innerHTML" }
+ },
+
+ postMixInProperties: function(){
+ var _nlsResources = dojo.i18n.getLocalization("dijit", "common");
+ dojo.mixin(this, _nlsResources);
+ this.inherited(arguments);
+ },
+
+ postCreate: function(){
+ // summary:
+ // Create the close button if needed
+ this.inherited(arguments);
+
+ this.closeButtonNode = dojo.create("span",{
+ "class" : "dijitButtonNode dijitDialogCloseIcon",
+ title : this.itemClose,
+ onclick: dojo.hitch(this, "onClose"),
+ onmouseenter: dojo.hitch(this, "_onCloseEnter"),
+ onmouseleave: dojo.hitch(this, "_onCloseLeave")
+ }, this.domNode);
+
+ dojo.create("span",{
+ "class" : "closeText",
+ title : this.itemClose,
+ innerHTML : "x"
+ }, this.closeButtonNode);
+ },
+
+ startup: function(){
+ // summary:
+ // add the edit box
+ this.inherited(arguments);
+ this._createInlineEditBox();
+ },
+
+ _setReadOnlyItemAttr: function(/*Boolean*/value){
+ // summary:
+ // change the readonly state
+ // tags:
+ // private
+ this.readOnlyItem = value;
+ if(!value){
+ this._createInlineEditBox();
+ }else if(this._editBox){
+ this._editBox.set("disabled", true);
+ }
+ },
+
+ _createInlineEditBox: function(){
+ // summary:
+ // create the inline editbox if needed
+ // tags:
+ // private
+ if(this.readOnlyItem){ return; }
+ if(!this._started){ return; }
+ if(this._editBox){
+ this._editBox.set("disabled",false);
+ return;
+ }
+ this._editBox = new dijit.InlineEditBox({
+ value:this.value,
+ editor: "dijit.form.ValidationTextBox",
+ editorParams:{
+ regExp:this.regExp
+ }
+ },this.labelNode);
+ this.connect(this._editBox,"edit","_onEdit");
+ this.connect(this._editBox,"onChange","_onCloseEdit");
+ this.connect(this._editBox,"onCancel","_onCloseEdit");
+ },
+
+ edit: function(){
+ // summary:
+ // enter inline editbox in edit mode
+ if(!this.readOnlyItem){
+ this._editBox.edit();
+ }
+ },
+
+ _onCloseEdit: function(/*String*/value){
+ // summary:
+ // call when inline editor close himself
+ // tags:
+ // private
+ dojo.removeClass(this.closeButtonNode,this.baseClass + "Edited");
+ dojo.disconnect(this._handleKeyDown);
+ this.onChange(value);
+ },
+
+ _onEdit: function(){
+ // summary:
+ // call when inline editor start editing
+ // tags:
+ // private
+ dojo.addClass(this.closeButtonNode,this.baseClass + "Edited");
+ this._handleKeyDown = dojo.connect(this._editBox.editWidget,"_onKeyPress",this,"onKeyDown");
+ this.onEdit();
+ },
+
+ _setDisabledAttr: function(/*Boolean*/value){
+ // summary:
+ // disable inline edit box
+ // tags:
+ // private
+ if(!this.readOnlyItem){
+ this._editBox.set("disabled", value);
+ }
+ },
+
+ _getValueAttr: function(){
+ // summary:
+ // return value
+ // tags:
+ // private
+ return (!this.readOnlyItem && this._started ? this._editBox.get("value") : this.value);
+ },
+
+ destroy: function(){
+ // summary:
+ // Destroy the inline editbox
+ if(this._editBox){
+ this._editBox.destroy();
+ }
+ this.inherited(arguments);
+ },
+
+ _onCloseEnter: function(){
+ // summary:
+ // Called when user hovers over close icon
+ // tags:
+ // private
+ dojo.addClass(this.closeButtonNode, "dijitDialogCloseIcon-hover");
+ },
+
+ _onCloseLeave: function(){
+ // summary:
+ // Called when user stops hovering over close icon
+ // tags:
+ // private
+ dojo.removeClass(this.closeButtonNode, "dijitDialogCloseIcon-hover");
+ },
+
+ onClose: function(){
+ // summary:
+ // callback when close button is clicked
+ },
+
+ onEdit: function(){
+ // summary:
+ // callback when widget come in edition
+ },
+
+ onClick: function(){
+ // summary:
+ // callback when widget is click
+ },
+
+ onChange: function(/*String*/value){
+ // summary:
+ // callback when widget change its content
+ },
+
+
+ onKeyDown: function(/*String*/value){
+ // summary:
+ // callback when widget get a KeyDown
+ }
+});
+dojo.declare("dojox.form._ListInputInputBox",
+ [dijit.form.ValidationTextBox],
+ {
+ // summary:
+ // auto-sized text box
+ // description:
+ // Auto sized textbox based on dijit.form.TextBox
+
+ // minWidth: Integer
+ // Min width of the input box
+ minWidth:50,
+
+ // intermediateChanges: Boolean
+ // Fires onChange for each value change or only on demand
+ // Force to true in order to get onChanged called
+ intermediateChanges:true,
+
+ // regExp: [extension protected] String
+ // regular expression string used to validate the input
+ // Do not specify both regExp and regExpGen
+ regExp: ".*",
+
+ // _sizer: DomNode
+ // Used to get size of textbox content
+ _sizer:null,
+
+ onChange: function(/*string*/value){
+ // summary:
+ // compute content width
+ this.inherited(arguments);
+ if(this._sizer === null){
+ this._sizer = dojo.create("div",{
+ style : {
+ position : "absolute",
+ left : "-10000px",
+ top : "-10000px"
+ }
+ },dojo.body());
+ }
+ this._sizer.innerHTML = value;
+ var w = dojo.contentBox(this._sizer).w + this.minWidth;
+ dojo.contentBox(this.domNode,{ w : w });
+ },
+
+ destroy: function(){
+ // summary:
+ // destroy the widget
+ dojo.destroy(this._sizer);
+ this.inherited(arguments);
+ }
+});
+
+}
+
+}};});
|