git.infodrom.org Git - infodrom/rico3/blob - ricoClient/js/ricoLiveGridForms.js

   1 /*
   2  *  (c) 2005-2009 Richard Cowin (http://openrico.org)
   3  *  (c) 2005-2009 Matt Brown (http://dowdybrown.com)
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
   6  *  file except in compliance with the License. You may obtain a copy of the License at
   7  *
   8  *         http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software distributed under the
  11  *  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  12  *  either express or implied. See the License for the specific language governing permissions
  13  *  and limitations under the License.
  14  */
  15
  16 if(typeof Rico=='undefined') throw("LiveGridForms requires the Rico JavaScript framework");
  17
  18
  19 Rico.TableEdit = function(liveGrid) {
  20   this.initialize(liveGrid);
  21 }
  22
  23 Rico.TableEdit.prototype = {
  24 /**
  25  * @class Supports editing LiveGrid data.
  26  * @constructs
  27  */
  28   initialize: function(liveGrid) {
  29     Rico.log('Rico.TableEdit initialize: '+liveGrid.tableId);
  30     this.grid=liveGrid;
  31     this.options = {
  32       maxDisplayLen    : 20,    // max displayed text field length
  33       panelHeight      : 200,   // size of tabbed panels
  34       panelWidth       : 500,
  35       compact          : false,    // compact corners
  36       RecordName       : Rico.getPhraseById("record"),
  37       updateURL        : window.location.href, // default is that updates post back to the generating page
  38       showSaveMsg      : 'errors'  // disposition of database update responses (full - show full response, errors - show full response for errors and short response otherwise)
  39     };
  40     Rico.extend(this.options, liveGrid.options);
  41     this.hasWF2=(document.implementation && document.implementation.hasFeature && document.implementation.hasFeature('WebForms', '2.0'));
  42     this.menu=liveGrid.menu;
  43     this.menu.options.dataMenuHandler=Rico.bind(this,'editMenu');
  44     this.menu.ignoreClicks();
  45     this.editText=Rico.getPhraseById("editRecord",this.options.RecordName);
  46     this.cloneText=Rico.getPhraseById("cloneRecord",this.options.RecordName);
  47     this.delText=Rico.getPhraseById("deleteRecord",this.options.RecordName);
  48     this.addText=Rico.getPhraseById("addRecord",this.options.RecordName);
  49     this.buttonHover=new Rico.HoverSet();
  50     this.dateRegExp=/^\s*(\w+)(\W)(\w+)(\W)(\w+)/i;
  51     Rico.EditControls.atLoad();
  52     this.createKeyArray();
  53     this.createEditDiv();
  54     this.saveMsg=Rico.$(liveGrid.tableId+'_savemsg');
  55     Rico.eventBind(document,"click", Rico.eventHandle(this,'clearSaveMsg'));
  56     this.extraMenuItems=[];
  57     this.responseHandler=Rico.bind(this,'processResponse');
  58     Rico.log("Rico.TableEdit.initialize complete, hasWF2="+this.hasWF2);
  59   },
  60
  61   createKeyArray: function() {
  62     this.keys=[];
  63     for (var i=0; i<this.grid.columns.length; i++) {
  64       if (this.grid.columns[i].format && this.grid.columns[i].format.isKey)
  65         this.keys.push({colidx:i});
  66     }
  67   },
  68
  69   createEditDiv: function() {
  70
  71     // create popup form
  72
  73     this.requestCount=1;
  74     this.formPopup=new Rico.Window('', {overflow: this.options.panels ? 'hidden' : 'auto'});
  75     this.formPopup.contentCell.className='ricoLG_editDiv';
  76     if (this.options.canEdit || this.options.canAdd) {
  77       this.startForm();
  78       this.createForm(this.form);
  79     } else {
  80       var buttonClose=this.createButton(Rico.getPhraseById("close"));
  81       Rico.eventBind(buttonClose,"click", Rico.eventHandle(this,'cancelEdit'), false);
  82       this.createForm(this.formPopup.contentDiv);
  83     }
  84     this.editDivCreated=true;
  85
  86     // create responseDialog
  87
  88     this.responseDialog = this.grid.createDiv('editResponse',document.body);
  89     this.responseDialog.style.display='none';
  90
  91     var buttonOK = document.createElement('button');
  92     buttonOK.appendChild(document.createTextNode('OK'));
  93     Rico.eventBind(buttonOK,"click", Rico.eventHandle(this,'ackResponse'));
  94     this.responseDialog.appendChild(buttonOK);
  95
  96     this.responseDiv = this.grid.createDiv('editResponseText',this.responseDialog);
  97
  98     if (this.panelGroup) {
  99       Rico.log("createEditDiv complete, requestCount="+this.requestCount);
 100       Rico.runLater(50,this,'initPanelGroup');
 101     }
 102   },
 103
 104   initPanelGroup: function() {
 105     this.requestCount--;
 106     Rico.log("initPanelGroup: "+this.requestCount);
 107     if (this.requestCount>0) return;
 108     var wi=parseInt(this.options.panelWidth,10);
 109     if (this.form) {
 110       //this.form.style.width=(wi+10)+'px';
 111       if (Rico.isWebKit) this.formPopup.container.style.display='block';  // this causes display to flash briefly
 112       this.options.bgColor = Rico.Color.createColorFromBackground(this.form).toString();
 113     }
 114     this.formPopup.container.style.display='none';
 115     //this.options.panelHdrWidth=(Math.floor(wi / this.options.panels.length)-20)+'px';
 116     this.formPanels=new Rico.TabbedPanel(this.panelGroup, this.options);
 117   },
 118
 119   notEmpty: function(v) {
 120     return typeof(v)!='undefined';
 121   },
 122
 123   startForm: function() {
 124     this.form = document.createElement('form');
 125     /** @ignore */
 126     this.form.onsubmit=function() {return false;};
 127     this.form.autocomplete="off"; // seems to fix "Permission denied..." errors in FF
 128     this.formPopup.contentDiv.appendChild(this.form);
 129
 130     var tab = document.createElement('div');
 131     tab.className='ButtonBar';
 132     var button=tab.appendChild(this.createButton(Rico.getPhraseById("saveRecord",this.options.RecordName)));
 133     Rico.eventBind(button,"click", Rico.eventHandle(this,'TESubmit'), false);
 134     button=tab.appendChild(this.createButton(Rico.getPhraseById("cancel")));
 135     Rico.eventBind(button,"click", Rico.eventHandle(this,'cancelEdit'), false);
 136     this.form.appendChild(tab);
 137
 138     // hidden fields
 139     this.hiddenFields = document.createElement('div');
 140     this.hiddenFields.style.display='none';
 141     this.action = this.appendHiddenField(this.grid.actionId,'');
 142     var i,fldSpec;
 143     for (i=0; i<this.grid.columns.length; i++) {
 144       fldSpec=this.grid.columns[i].format;
 145       if (fldSpec && fldSpec.FormView && fldSpec.FormView=="hidden")
 146         this.appendHiddenField(fldSpec.FieldName,fldSpec.ColData);
 147     }
 148     for (var k=0; k<this.keys.length; k++) {
 149       this.keys[k].keyField = this.appendHiddenField('_k'+this.keys[k].colidx,'');
 150     }
 151     this.form.appendChild(this.hiddenFields);
 152   },
 153
 154   createButton: function(buttonLabel) {
 155     var button = document.createElement('a');
 156     button.href='javascript:void(0)';
 157     button.innerHTML=buttonLabel;
 158     button.className='RicoButton';
 159     if (Rico.theme.button) Rico.addClass(button,Rico.theme.button);
 160     this.buttonHover.add(button);
 161     return button;
 162   },
 163
 164   createPanel: function(i) {
 165     var hasFields=false;
 166     for (var j=0; j<this.grid.columns.length; j++) {
 167       var fldSpec=this.grid.columns[j].format;
 168       if (!fldSpec) continue;
 169       if (!fldSpec.EntryType) continue;
 170       if (fldSpec.EntryType=='H') continue;
 171       if (fldSpec.FormView && fldSpec.FormView=="hidden") continue;
 172       var panelIdx=fldSpec.panelIdx || 0;
 173       if (panelIdx==i) {
 174         hasFields=true;
 175         break;
 176       }
 177     }
 178     if (!hasFields) return null;
 179     this.panelHdr[i] = document.createElement('li');
 180     this.panelHdr[i].innerHTML=this.options.panels[i];
 181     this.panelHdrs.appendChild(this.panelHdr[i]);
 182     this.panelContent[i] = document.createElement('div');
 183     this.panelContents.appendChild(this.panelContent[i]);
 184     this.panelActualIdx[i]=this.panelCnt++;
 185     return this.createFormTable(this.panelContent[i],'tabContent');
 186   },
 187
 188   createForm: function(parentDiv) {
 189     var i,div,fldSpec,panelIdx,tables=[];
 190     this.panelCnt=0;
 191     this.panelHdr=[];
 192     this.panelContent=[];
 193     if (this.options.panels) {
 194       this.panelGroup = document.createElement('div');
 195       this.panelGroup.className='tabPanelGroup';
 196       this.panelHdrs = document.createElement('ul');
 197       this.panelGroup.appendChild(this.panelHdrs);
 198       this.panelContents = document.createElement('div');
 199       this.panelContents.className='tabContentContainer';
 200       this.panelGroup.appendChild(this.panelContents);
 201       this.panelActualIdx=[];
 202       parentDiv.appendChild(this.panelGroup);
 203       if (this.grid.direction=='rtl') {
 204         for (i=this.options.panels.length-1; i>=0; i--) {
 205           tables[i]=this.createPanel(i);
 206         }
 207       } else {
 208         for (i=0; i<this.options.panels.length; i++) {
 209           tables[i]=this.createPanel(i);
 210         }
 211       }
 212       parentDiv.appendChild(this.panelGroup);
 213     } else {
 214       div=document.createElement('div');
 215       div.className='noTabContent';
 216       tables[0]=this.createFormTable(div);
 217       parentDiv.appendChild(div);
 218     }
 219     for (i=0; i<this.grid.columns.length; i++) {
 220       fldSpec=this.grid.columns[i].format;
 221       if (!fldSpec) continue;
 222       panelIdx=fldSpec.panelIdx || 0;
 223       if (tables[panelIdx]) this.appendFormField(this.grid.columns[i],tables[panelIdx]);
 224       if (typeof fldSpec.pattern=='string') {
 225         switch (fldSpec.pattern) {
 226           case 'email':
 227             fldSpec.regexp=/^[_a-zA-Z0-9-]+(\.[_a-zA-Z0-9-]+)*@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*\.(([0-9]{1,3})|([a-zA-Z]{2,3})|(aero|coop|info|museum|name))$/;
 228             break;
 229           case 'float-unsigned':
 230             fldSpec.regexp=/^\d+(\.\d+)?$/;
 231             break;
 232           case 'float-signed':
 233             fldSpec.regexp=/^[-+]?\d+(\.\d+)?$/;
 234             break;
 235           case 'int-unsigned':
 236             fldSpec.regexp=/^\d+$/;
 237             break;
 238           case 'int-signed':
 239             fldSpec.regexp=/^[-+]?\d+$/;
 240             break;
 241           default:
 242             fldSpec.regexp=new RegExp(fldSpec.pattern);
 243             break;
 244         }
 245       }
 246     }
 247   },
 248
 249   createFormTable: function(div) {
 250     var tab=document.createElement('table');
 251     tab.border=0;
 252     div.appendChild(tab);
 253     return tab;
 254   },
 255
 256   appendHiddenField: function(name,value) {
 257     var field=Rico.createFormField(this.hiddenFields,'input','hidden',name,name);
 258     field.value=value;
 259     return field;
 260   },
 261
 262   appendFormField: function(column, table) {
 263     var fmt=column.format;
 264     if (!fmt.EntryType) return;
 265     if (fmt.EntryType=="H") return;
 266     if (fmt.FormView) return;
 267     Rico.log('appendFormField: '+column.displayName+' - '+fmt.EntryType);
 268     var row = fmt.noFormBreak && table.rows.length > 0 ? table.rows[table.rows.length-1] : table.insertRow(-1);
 269     var hdr = row.insertCell(-1);
 270     column.formLabel=hdr;
 271     if (hdr.noWrap) hdr.noWrap=true;
 272     var entry = row.insertCell(-1);
 273     if (entry.noWrap) entry.noWrap=true;
 274     hdr.id='lbl_'+fmt.FieldName;
 275     var field, name=fmt.FieldName;
 276     switch (fmt.EntryType) {
 277       case 'TA':
 278       case 'tinyMCE':
 279         field=Rico.createFormField(entry,'textarea',null,name);
 280         field.cols=fmt.TxtAreaCols;
 281         field.rows=fmt.TxtAreaRows;
 282         field.innerHTML=fmt.ColData;
 283         hdr.style.verticalAlign='top';
 284         break;
 285       case 'R':
 286       case 'RL':
 287         field=Rico.createFormField(entry,'div',null,name);
 288         if (fmt.DescriptionField) field.RicoUpdate=fmt.DescriptionField;
 289         if (fmt.MultiSelect) Rico.addClass(field, 'MultiSelect');
 290         if (fmt.isNullable && !fmt.MultiSelect) this.addSelectNone(field);
 291         this.selectValuesRequest(field,column);
 292         break;
 293       case 'N':
 294         field=Rico.createFormField(entry,'select',null,name);
 295         if (fmt.isNullable) this.addSelectNone(field);
 296         Rico.eventBind(field,"change", Rico.eventHandle(this,'checkSelectNew'));
 297         this.selectValuesRequest(field,column);
 298         field=document.createElement('span');
 299         field.className='ricoEditLabel';
 300         field.id='labelnew__'+fmt.FieldName;
 301         field.innerHTML='&nbsp;&nbsp;&nbsp;'+Rico.getPhraseById('formNewValue').replace(' ','&nbsp;');
 302         entry.appendChild(field);
 303         name='textnew__'+fmt.FieldName;
 304         field=Rico.createFormField(entry,'input','text',name,name);
 305         break;
 306       case 'S':
 307       case 'SL':
 308         if (fmt.ReadOnly) {
 309           field=Rico.createFormField(entry,'input','text',name,name);
 310           this.initField(field,fmt);
 311         } else {
 312           field=Rico.createFormField(entry,'select',null,name);
 313           if (fmt.MultiSelect) field.multiple=true;
 314           if (fmt.SelectRows) field.size=parseInt(fmt.SelectRows,10);
 315           if (fmt.isNullable && !fmt.MultiSelect) this.addSelectNone(field);
 316           if (fmt.DescriptionField) {
 317             field.RicoUpdate=fmt.DescriptionField;
 318             Rico.eventBind(field,"change", Rico.eventHandle(this,'selectClick'), false);
 319           }
 320           this.selectValuesRequest(field,column);
 321         }
 322         break;
 323       case 'D':
 324         if (!fmt.isNullable) fmt.required=true;
 325         if (!fmt.dateFmt) fmt.dateFmt=Rico.dateFmt;
 326         if (!fmt.Help) fmt.Help=fmt.dateFmt;
 327         if (typeof fmt.min=='string') fmt.min=Rico.setISO8601(fmt.min) || new Date(fmt.min);
 328         if (typeof fmt.max=='string') fmt.max=Rico.setISO8601(fmt.max) || new Date(fmt.max);
 329         if (this.hasWF2) {
 330           field=Rico.createFormField(entry,'input','date',name,name);
 331           field.required=fmt.required;
 332           if (fmt.min) field.min=Rico.toISO8601String(fmt.min,3);
 333           if (fmt.max) field.max=Rico.toISO8601String(fmt.max,3);
 334           field.required=fmt.required;
 335           fmt.SelectCtl=null;  // use the WebForms calendar instead of the Rico calendar
 336         } else {
 337           field=Rico.createFormField(entry,'input','text',name,name);
 338         }
 339         this.initField(field,fmt);
 340         break;
 341       case 'I':
 342         if (!fmt.isNullable) fmt.required=true;
 343         if (!fmt.pattern) fmt.pattern='int-signed';
 344         if (this.hasWF2) {
 345           field=Rico.createFormField(entry,'input','number',name,name);
 346           field.required=fmt.required;
 347           field.min=fmt.min;
 348           field.max=fmt.max;
 349           field.step=1;
 350         } else {
 351           field=Rico.createFormField(entry,'input','text',name,name);
 352         }
 353         if (typeof fmt.min=='string') fmt.min=parseInt(fmt.min,10);
 354         if (typeof fmt.max=='string') fmt.max=parseInt(fmt.max,10);
 355         this.initField(field,fmt);
 356         break;
 357       case 'F':
 358         if (!fmt.isNullable) fmt.required=true;
 359         if (!fmt.pattern) fmt.pattern='float-signed';
 360         field=Rico.createFormField(entry,'input','text',name,name);
 361         this.initField(field,fmt);
 362         if (typeof fmt.min=='string') fmt.min=parseFloat(fmt.min);
 363         if (typeof fmt.max=='string') fmt.max=parseFloat(fmt.max);
 364         break;
 365       default:
 366         field=Rico.createFormField(entry,'input','text',name,name);
 367         if (!fmt.isNullable && fmt.EntryType!='T') fmt.required=true;
 368         this.initField(field,fmt);
 369         break;
 370     }
 371     if (field) {
 372       if (fmt.SelectCtl)
 373         Rico.EditControls.applyTo(column,field);
 374     }
 375     var hdrSuffix='';
 376     hdr.className='ricoEditLabel';
 377     if (fmt.Help) {
 378       hdr.title=fmt.Help;
 379       hdrSuffix="&nbsp;<img src='"+Rico.imgDir+"info_icon.gif'>";
 380       Rico.addClass(hdr,'ricoHelp');
 381     }
 382     var hdrText=fmt.EntryType.length>1 && fmt.EntryType.charAt(1)=='L' ? column.next.displayName : column.displayName;
 383     hdr.innerHTML=hdrText+hdrSuffix;
 384   },
 385
 386   addSelectNone: function(field) {
 387     this.addSelectOption(field,this.options.TableSelectNone,Rico.getPhraseById("selectNone"));
 388   },
 389
 390   initField: function(field,fmt) {
 391     if (fmt.Length) {
 392       field.maxLength=fmt.Length;
 393       field.size=Math.min(fmt.Length, this.options.maxDisplayLen);
 394     }
 395     field.value=fmt.ColData;
 396   },
 397
 398   selectClick: function(e) {
 399     var SelObj=Rico.eventElement(e);
 400     if (SelObj.readOnly) {
 401       Rico.eventStop(e);
 402       return false;
 403     }
 404     if (SelObj.RicoUpdate) {
 405       var opt=SelObj.options[SelObj.selectedIndex];
 406       Rico.$(SelObj.RicoUpdate).value=opt.innerHTML;
 407     }
 408   },
 409
 410   radioClick: function(e) {
 411     var ChkBoxObj=Rico.eventElement(e);
 412     if (ChkBoxObj.readOnly) {
 413       Rico.eventStop(e);
 414       return false;
 415     }
 416     var container=Rico.getParentByTagName(ChkBoxObj,'div');
 417     if (container.RicoUpdate) {
 418       Rico.$(container.RicoUpdate).value=ChkBoxObj.nextSibling.innerHTML;
 419     }
 420   },
 421
 422   checkSelectNew: function(e) {
 423     this.updateSelectNew(Rico.eventElement(e));
 424   },
 425
 426   updateSelectNew: function(SelObj) {
 427     var vis=(SelObj.value==this.options.TableSelectNew) ? "" : "hidden";
 428     Rico.$("labelnew__" + SelObj.id).style.visibility=vis;
 429     Rico.$("textnew__" + SelObj.id).style.visibility=vis;
 430   },
 431
 432   selectValuesRequest: function(elem,column) {
 433     var fldSpec=column.format;
 434     if (fldSpec.SelectValues) {
 435       var valueList=fldSpec.SelectValues.split(',');
 436       for (var i=0; i<valueList.length; i++)
 437         this.addSelectOption(elem,valueList[i],valueList[i],i);
 438     } else {
 439       this.requestCount++;
 440       var options={};
 441       Rico.extend(options, this.grid.buffer.ajaxOptions);
 442       options.parameters = {id: this.grid.tableId, offset: '0', page_size: '-1', edit: column.index};
 443       options.parameters[this.grid.actionId]="query";
 444       options.onComplete = Rico.bind(this,'selectValuesUpdate',elem);
 445       new Rico.ajaxRequest(this.grid.buffer.dataSource, options);
 446       Rico.log("selectValuesRequest: "+fldSpec.FieldName);
 447     }
 448   },
 449
 450   selectValuesUpdate: function(elem,request) {
 451     var response = request.responseXML.getElementsByTagName("ajax-response");
 452     Rico.log("selectValuesUpdate: "+request.status);
 453     if (response == null || response.length != 1) return;
 454     response=response[0];
 455     var error = response.getElementsByTagName('error');
 456     if (error.length > 0) {
 457       var errmsg=Rico.getContentAsString(error[0],this.grid.buffer.isEncoded);
 458       Rico.log("Data provider returned an error:\n"+errmsg);
 459       alert(Rico.getPhraseById("requestError",errmsg));
 460       return null;
 461     }
 462     response=response.getElementsByTagName('response')[0];
 463     var rowsElement = response.getElementsByTagName('rows')[0];
 464     var rows = this.grid.buffer.dom2jstable(rowsElement);
 465     Rico.log("selectValuesUpdate: id="+elem.id+' rows='+rows.length);
 466     for (var i=0; i<rows.length; i++) {
 467       if (rows[i].length>0) {
 468         var c0=rows[i][0];
 469         var c1=(rows[i].length>1) ? rows[i][1] : c0;
 470         this.addSelectOption(elem,c0,c1,i);
 471       }
 472     }
 473     if (Rico.$('textnew__'+elem.id))
 474       this.addSelectOption(elem,this.options.TableSelectNew,Rico.getPhraseById("selectNewVal"));
 475     if (this.panelGroup)
 476       Rico.runLater(50,this,'initPanelGroup');
 477   },
 478
 479   addSelectOption: function(elem,value,text,idx) {
 480     switch (elem.tagName.toLowerCase()) {
 481       case 'div':
 482         var opt=Rico.createFormField(elem,'input', Rico.hasClass(elem, 'MultiSelect') ? 'checkbox' : 'radio', elem.id+'_'+idx, elem.id);
 483         opt.value=value;
 484         var lbl=document.createElement('label');
 485         lbl.innerHTML=text;
 486         lbl.htmlFor=opt.id;
 487         elem.appendChild(lbl);
 488         Rico.eventBind(opt,"click", Rico.eventHandle(this,'radioClick'), false);
 489         break;
 490       case 'select':
 491         Rico.addSelectOption(elem,value,text);
 492         break;
 493     }
 494   },
 495
 496   clearSaveMsg: function() {
 497     if (this.saveMsg) this.saveMsg.innerHTML="";
 498   },
 499
 500   addMenuItem: function(menuText,menuAction,enabled) {
 501     this.extraMenuItems.push({menuText:menuText,menuAction:menuAction,enabled:enabled});
 502   },
 503
 504   editMenu: function(grid,r,c,onBlankRow) {
 505     this.clearSaveMsg();
 506     if (this.grid.buffer.sessionExpired==true || this.grid.buffer.startPos<0) return false;
 507     this.rowIdx=r;
 508     var elemTitle=Rico.$('pageTitle');
 509     var pageTitle=elemTitle ? elemTitle.innerHTML : document.title;
 510     this.menu.addMenuHeading(pageTitle);
 511     if (onBlankRow==false) {
 512       for (var i=0; i<this.extraMenuItems.length; i++) {
 513         this.menu.addMenuItem(this.extraMenuItems[i].menuText,this.extraMenuItems[i].menuAction,this.extraMenuItems[i].enabled);
 514       }
 515       this.menu.addMenuItem(this.editText,Rico.bind(this,'editRecord'),this.canEdit(r));
 516       this.menu.addMenuItem(this.delText,Rico.bind(this,'deleteRecord'),this.canDelete(r));
 517       if (this.options.canClone) {
 518         this.menu.addMenuItem(this.cloneText,Rico.bind(this,'cloneRecord'),this.canAdd(r) && this.canEdit(r));
 519       }
 520     }
 521     this.menu.addMenuItem(this.addText,Rico.bind(this,'addRecord'),this.canAdd(r));
 522     return true;
 523   },
 524
 525   canAdd: function(r) {
 526     return (typeof this.options.canAdd=='function') ? this.options.canAdd(r) : this.options.canAdd;
 527   },
 528
 529   canEdit: function(r) {
 530     return (typeof this.options.canEdit=='function') ? this.options.canEdit(r) : this.options.canEdit;
 531   },
 532
 533   canDelete: function(r) {
 534     return (typeof this.options.canDelete=='function') ? this.options.canDelete(r) : this.options.canDelete;
 535   },
 536
 537   cancelEdit: function(e) {
 538     Rico.eventStop(e);
 539     for (var i=0; i<this.grid.columns.length; i++) {
 540       if (this.grid.columns[i].format && this.grid.columns[i].format.SelectCtl)
 541         Rico.EditControls.close(this.grid.columns[i].format.SelectCtl);
 542     }
 543     this.makeFormInvisible();
 544     this.grid.highlightEnabled=true;
 545     this.menu.cancelmenu();
 546     return false;
 547   },
 548
 549   setField: function(fldnum,fldvalue) {
 550     var fldSpec=this.grid.columns[fldnum].format;
 551     var e=Rico.$(fldSpec.FieldName);
 552     var a,i,o,elems,opts,txt;
 553     if (!e) return;
 554     Rico.log('setField: '+fldSpec.FieldName+'='+fldvalue);
 555     switch (e.tagName.toUpperCase()) {
 556       case 'DIV':
 557         elems=e.getElementsByTagName('INPUT');
 558         o={}
 559         if (fldSpec.MultiSelect && fldvalue) {
 560           a=fldvalue.split(',');
 561           for (var i=0; i<a.length; i++) o[a[i]]=1;
 562         } else {
 563           o[fldvalue]=1;
 564         }
 565         for (i=0; i<elems.length; i++)
 566           elems[i].checked=o[elems[i].value]==1;
 567         break;
 568       case 'INPUT':
 569         if (fldSpec.EntryType=='D' && fldvalue!=fldSpec.ColData) {
 570           // remove time data if it exists
 571           a=fldvalue.split(/\s|T/);
 572           fldvalue=a[0];
 573           if (this.isTextInput(e)) {
 574             var d=Rico.setISO8601(fldvalue);
 575             if (d) fldvalue=Rico.formatDate(d,fldSpec.dateFmt);
 576           }
 577         }
 578         e.value=fldvalue;
 579         break;
 580       case 'SELECT':
 581         opts=e.options;
 582         //alert('setField SELECT: id='+e.id+'\nvalue='+fldvalue+'\nopt cnt='+opts.length)
 583         o={}
 584         if (fldSpec.MultiSelect && fldvalue) {
 585           a=fldvalue.split(',');
 586           for (var i=0; i<a.length; i++) o[a[i]]=1;
 587           for (i=0; i<opts.length; i++)
 588             opts[i].selected=o[opts[i].value]==1;
 589         } else {
 590           for (i=0; i<opts.length; i++) {
 591             if (opts[i].value==fldvalue) {
 592               e.selectedIndex=i;
 593               break;
 594             }
 595           }
 596         }
 597         if (fldSpec.EntryType=='N') {
 598           txt=Rico.$('textnew__'+e.id);
 599           if (!txt) alert('Warning: unable to find id "textnew__'+e.id+'"');
 600           txt.value=fldvalue;
 601           if (e.selectedIndex!=i) e.selectedIndex=opts.length-1;
 602           this.updateSelectNew(e);
 603         }
 604         return;
 605       case 'TEXTAREA':
 606         e.value=fldvalue;
 607         if (fldSpec.EntryType=='tinyMCE' && typeof(tinyMCE)!='undefined' && this.initialized) {
 608           if (tinyMCE.updateContent) {
 609             tinyMCE.updateContent(e.id);  // version 2.x
 610           } else {
 611             tinyMCE.execInstanceCommand(e.id, 'mceSetContent', false, fldvalue);  // version 3.x
 612           }
 613         }
 614         return;
 615     }
 616   },
 617
 618   setReadOnly: function(action) {
 619     for (var ro,i=0; i<this.grid.columns.length; i++) {
 620       var fldSpec=this.grid.columns[i].format;
 621       if (!fldSpec) continue;
 622       var e=Rico.$(fldSpec.FieldName);
 623       if (!e) continue;
 624       switch (action) {
 625         case 'ins': ro=!fldSpec.Writeable || fldSpec.ReadOnly || fldSpec.UpdateOnly; break;
 626         case 'upd': ro=!fldSpec.Writeable || fldSpec.ReadOnly || fldSpec.InsertOnly; break;
 627         default:    ro=false; break;
 628       }
 629       switch (e.tagName.toUpperCase()) {
 630         case 'DIV':
 631           var elems=e.getElementsByTagName('INPUT');
 632           for (var j=0; j<elems.length; j++) {
 633             elems[j].disabled=ro;
 634           }
 635           break;
 636         case 'SELECT':
 637           if (fldSpec.EntryType=='N') {
 638             var txt=Rico.$('textnew__'+e.id);
 639             txt.disabled=ro;
 640           }
 641           e.disabled=ro;
 642           break;
 643         case 'TEXTAREA':
 644         case 'INPUT':
 645           e.disabled=ro;
 646           if (fldSpec.selectIcon) fldSpec.selectIcon.style.display=ro ? 'none' : '';
 647           break;
 648       }
 649     }
 650   },
 651
 652   hideResponse: function(msg) {
 653     this.responseDiv.innerHTML=msg;
 654     this.responseDialog.style.display='none';
 655   },
 656
 657   showResponse: function() {
 658     var offset=Rico.cumulativeOffset(this.grid.outerDiv);
 659     offset.top+=Rico.docScrollTop();
 660     this.responseDialog.style.top=offset.top+"px";
 661     this.responseDialog.style.left=offset.left+"px";
 662     this.responseDialog.style.display='';
 663   },
 664
 665   processResponse: function(xhr) {
 666     var responseText,success=true;
 667     Rico.log('Processing response from form submittal');
 668     this.responseDiv.innerHTML=xhr.responseText;
 669     var respNodes=Rico.select('.ricoFormResponse',this.responseDiv);
 670     if (respNodes) {
 671       // generate a translated response
 672       var phraseId=Rico.trim(respNodes[0].className).split(/\s+/)[1];
 673       responseText=Rico.getPhraseById(phraseId,this.options.RecordName);
 674     } else {
 675       // present the response as sent from the server (untranslated)
 676       var ch=this.responseDiv.childNodes;
 677       for (var i=ch.length-1; i>=0; i--) {
 678         if (ch[i].nodeType==1 && ch[i].nodeName!='P' && ch[i].nodeName!='DIV' && ch[i].nodeName!='BR')
 679           this.responseDiv.removeChild(ch[i]);
 680       }
 681       responseText=Rico.stripTags(this.responseDiv.innerHTML);
 682       success=(responseText.toLowerCase().indexOf('error')==-1);
 683     }
 684     if (success && this.options.showSaveMsg!='full') {
 685       this.hideResponse('');
 686       this.grid.resetContents();
 687       this.grid.buffer.foundRowCount = false;
 688       this.grid.buffer.fetch(this.grid.lastRowPos || 0);
 689       if (this.saveMsg) this.saveMsg.innerHTML='&nbsp;'+responseText+'&nbsp;';
 690     }
 691     this.processCallback(this.options.onSubmitResponse);
 692     Rico.log('Processing response completed');
 693   },
 694
 695   processCallback: function(callback) {
 696     switch (typeof callback) {
 697       case 'string': return eval(callback);
 698       case 'function': return callback();
 699     }
 700   },
 701
 702   // called when ok pressed on error response message
 703   ackResponse: function(e) {
 704     this.hideResponse('');
 705     this.grid.highlightEnabled=true;
 706   },
 707
 708   cloneRecord: function() {
 709     this.formPopup.setTitle(this.cloneText);
 710     this.displayEditForm("ins");
 711   },
 712
 713   editRecord: function() {
 714     this.formPopup.setTitle(this.editText);
 715     this.displayEditForm("upd");
 716   },
 717
 718   displayEditForm: function(action) {
 719     this.grid.highlightEnabled=false;
 720     this.menu.cancelmenu();
 721     this.hideResponse(Rico.getPhraseById('saving'));
 722     this.grid.outerDiv.style.cursor = 'auto';
 723     this.action.value=action;
 724     for (var i=0; i<this.grid.columns.length; i++) {
 725       var c=this.grid.columns[i];
 726       if (c.format) {
 727         var v=c.getValue(this.rowIdx);
 728         this.setField(i,v);
 729         if (c.format.selectDesc) {
 730           if (c.format.EntryType.length>1 && c.format.EntryType.charAt(1)=='L')
 731             v=this.grid.columns[i+1].getValue(this.rowIdx);
 732           v=c._format(v);
 733           if (v==='') v='&nbsp;';
 734           c.format.selectDesc.innerHTML=v;
 735         }
 736         if (c.format.SelectCtl)
 737           Rico.EditControls.displayClrImg(c, !c.format.InsertOnly);
 738       }
 739     }
 740     this.setReadOnly(action);
 741     for (var k=0; k<this.keys.length; k++) {
 742       this.keys[k].keyField.value = this.grid.buffer.getWindowValue(this.rowIdx,this.keys[k].colidx);
 743     }
 744     this.makeFormVisible(this.rowIdx);
 745   },
 746
 747   addPrepare: function() {
 748     this.hideResponse(Rico.getPhraseById('saving'));
 749     this.form.reset();
 750     this.setReadOnly("ins");
 751     this.action.value="ins";
 752     for (var i=0; i<this.grid.columns.length; i++) {
 753       var c=this.grid.columns[i];
 754       if (c.format) {
 755         this.setField(i,c.format.ColData);
 756         if (c.format.SelectCtl) {
 757           Rico.EditControls.resetValue(c);
 758           Rico.EditControls.displayClrImg(c, !c.format.UpdateOnly);
 759         }
 760       }
 761     }
 762   },
 763
 764   addRecord: function() {
 765     this.menu.cancelmenu();
 766     this.formPopup.setTitle(this.addText);
 767     this.addPrepare();
 768     this.makeFormVisible(-1);
 769     if (this.formPanels) this.formPanels.select(0);
 770   },
 771
 772   drillDown: function(e,masterColNum,detailColNum) {
 773     return this.grid.drillDown.apply(this.grid, arguments);
 774   },
 775
 776   // set filter on a detail grid that is in a master-detail relationship
 777   setDetailFilter: function(colNumber,filterValue) {
 778     this.grid.setDetailFilter(colNumber,filterValue);
 779   },
 780
 781   makeFormVisible: function(row) {
 782     this.formPopup.container.style.display='block';
 783
 784     // set left position
 785     var editWi=this.formPopup.container.offsetWidth;
 786     var odOffset=Rico.cumulativeOffset(this.grid.outerDiv);
 787     var winWi=Rico.windowWidth();
 788     this.formPopup.container.style.left=editWi+odOffset.left > winWi ? (winWi-editWi)+'px' : (odOffset.left+1)+'px';
 789
 790     // set top position
 791     var scrTop=Rico.docScrollTop();
 792     var editHt=this.formPopup.container.offsetHeight;
 793     var newTop=odOffset.top+this.grid.hdrHt+scrTop;
 794     var bottom=Rico.windowHeight()+scrTop;
 795     if (row >= 0) {
 796       newTop+=(row+1)*this.grid.rowHeight;
 797       if (newTop+editHt>bottom) newTop-=(this.formPopup.contentCell.offsetHeight+this.grid.rowHeight);
 798     } else {
 799       if (newTop+editHt>bottom) newTop=bottom-editHt-2;
 800     }
 801
 802     if (this.processCallback(this.options.formOpen) === false) return;
 803     this.formPopup.openPopup(null,Math.max(newTop,scrTop));
 804     this.formPopup.container.style.visibility='visible';
 805     Rico.EditControls.setZ(Rico.getStyle(this.formPopup.container,'zIndex'));
 806     if (this.initialized) return;
 807
 808     var i, spec;
 809     for (i = 0; i < this.grid.columns.length; i++) {
 810       spec=this.grid.columns[i].format;
 811       if (!spec || !spec.EntryType || !spec.FieldName) continue;
 812       switch (spec.EntryType) {
 813         case 'tinyMCE':
 814           if (typeof tinyMCE!='undefined') tinyMCE.execCommand('mceAddControl', true, spec.FieldName);
 815           break;
 816       }
 817     }
 818     this.initialized=true;
 819   },
 820
 821   makeFormInvisible: function() {
 822     this.formPopup.container.style.visibility='hidden';
 823     this.formPopup.closePopup();
 824     this.processCallback(this.options.formClose);
 825   },
 826
 827   getConfirmDesc: function(rowIdx) {
 828     return Rico.stripTags(this.grid.cell(rowIdx,this.options.ConfirmDeleteCol).innerHTML).replace('&nbsp;',' '); //.unescapeHTML();
 829   },
 830
 831   deleteRecord: function() {
 832     this.menu.cancelmenu();
 833     var desc;
 834     switch(this.options.ConfirmDeleteCol){
 835       case -1 :
 836         desc=Rico.getPhraseById("thisRecord",this.options.RecordName);
 837         break;
 838       case -2 : // Use key/column header to identify the row
 839         for (var k=0; k<this.keys.length; k++) {
 840           var i=this.keys[k].colidx;
 841           var fmt=this.grid.columns[i].format;
 842           if (fmt.EntryType.length>1 && fmt.EntryType.charAt(1)=='L') i++;
 843           var value=Rico.stripTags(this.grid.cell(rowIdx,i).innerHTML).replace(/&nbsp;/g,' ');
 844           if (desc) desc+=', ';
 845           desc+=this.grid.columns[i].displayName+" "+value;
 846         }
 847         break;
 848       default   :
 849         desc='\"' + Rico.truncate(this.getConfirmDesc(this.rowIdx),50) + '\"';
 850         break;
 851     }
 852     if (!this.options.ConfirmDelete.valueOf || confirm(Rico.getPhraseById("confirmDelete",desc))) {
 853       this.hideResponse(Rico.getPhraseById('deleting'));
 854       this.showResponse();
 855       var parms={};
 856       parms[this.grid.actionId]="del";
 857       for (var k=0; k<this.keys.length; k++) {
 858         var i=this.keys[k].colidx;
 859         var value=this.grid.columns[i].getValue(this.rowIdx);
 860         parms['_k'+i]=value;  // prototype does the encoding automatically
 861         //parms['_k'+i]=encodeURIComponent(value);
 862       }
 863       new Rico.ajaxRequest(this.options.updateURL, {parameters:parms,method:'post',onComplete:this.responseHandler});
 864     }
 865     this.menu.cancelmenu();
 866   },
 867
 868   validationMsg: function(elem,colnum,phraseId) {
 869     var col=this.grid.columns[colnum];
 870     if (this.formPanels) this.formPanels.select(this.panelActualIdx[col.format.panelIdx]);
 871     var label=Rico.stripTags(col.formLabel.innerHTML).replace(/&nbsp;/g,' ');
 872     var msg=Rico.getPhraseById(phraseId," \"" + label + "\"");
 873     Rico.log(' Validation error: '+msg);
 874     if (col.format.Help) msg+="\n\n"+col.format.Help;
 875     alert(msg);
 876     setTimeout(function() { try { elem.focus(); elem.select(); } catch(e) {}; }, 10);
 877     return false;
 878   },
 879
 880   isTextInput: function(elem) {
 881     if (!elem) return false;
 882     if (elem.tagName.toLowerCase()!='input') return false;
 883     if (elem.type.toLowerCase()!='text') return false;
 884     if (elem.readOnly) return false;
 885     if (!Rico.visible(elem)) return false;
 886     return true;
 887   },
 888
 889   parseDate: function(v, dateFmt) {
 890     dateParts={};
 891     if (!this.dateRegExp.exec(dateFmt)) return NaN;
 892     dateParts[RegExp.$1]=0;
 893     dateParts[RegExp.$3]=1;
 894     dateParts[RegExp.$5]=2;
 895     var aDate = v.split(/\D/);
 896     var d=new Date();
 897     var curyr=d.getFullYear();
 898     if (aDate.length==2 && dateParts.yyyy==2) aDate.push(curyr);
 899     if (aDate.length!=3) return NaN;
 900     var dd=parseInt(aDate[dateParts.dd], 10);
 901     if (dd==0 || dd>31) return NaN;
 902     var mm=parseInt(aDate[dateParts.mm], 10) - 1;
 903     if (mm > 11) return NaN;
 904     var yy=parseInt(aDate[dateParts.yyyy], 10);
 905     if (yy < 100) {
 906       // apply a century to 2-digit years
 907       yy+=curyr - (curyr % 100);
 908     }
 909     d.setFullYear(yy,mm,dd);
 910     return d;
 911   },
 912
 913   TESubmit: function(e) {
 914     var i,ro,lbl,spec,elem,n,dateValues=[];
 915
 916     Rico.eventStop(e);
 917     Rico.log('Event: TESubmit called to validate input');
 918
 919     // check fields that are supposed to be non-blank
 920
 921     for (i = 0; i < this.grid.columns.length; i++) {
 922       spec=this.grid.columns[i].format;
 923       if (!spec || !spec.EntryType || !spec.FieldName) continue;
 924       elem=Rico.$(spec.FieldName);
 925       if (!this.isTextInput(elem)) continue;
 926       switch (this.action.value) {
 927         case 'ins': ro=!spec.Writeable || spec.ReadOnly || spec.UpdateOnly; break;
 928         case 'upd': ro=!spec.Writeable || spec.ReadOnly || spec.InsertOnly; break;
 929         default:    ro=false; break;
 930       }
 931       if (ro) continue;  // readonly, so don't validate
 932       Rico.log(' Validating field #'+i+' EntryType='+spec.EntryType+' ('+spec.FieldName+')');
 933
 934       // check for blanks
 935       if (elem.value.length == 0) {
 936         if (spec.required)
 937           return this.validationMsg(elem,i,"formPleaseEnter");
 938         else
 939           continue;
 940       }
 941
 942       // check pattern
 943       if (elem.value.length > 0 && spec.regexp && !spec.regexp.test(elem.value))
 944         return this.validationMsg(elem,i,"formInvalidFmt");
 945
 946       // check min/max and date values
 947       switch (spec.EntryType.charAt(0)) {
 948         case 'I': n=parseInt(elem.value,10); break;
 949         case 'F': n=parseFloat(elem.value); break;
 950         case 'D':
 951           n=this.parseDate(elem.value,spec.dateFmt);
 952           if (isNaN(n)) return this.validationMsg(elem,i,"formInvalidFmt");
 953           dateValues.push({e:elem,v:n});
 954           break;
 955         default:  n=NaN; break;
 956       }
 957       if (typeof spec.min!='undefined' && !isNaN(n) && n < spec.min)
 958         return this.validationMsg(elem,i,"formOutOfRange");
 959       if (typeof spec.max!='undefined' && !isNaN(n) && n > spec.max)
 960         return this.validationMsg(elem,i,"formOutOfRange");
 961     }
 962     if (this.processCallback(this.options.formSubmit) === false) return false;
 963
 964     // update drop-down for any columns with entry type of N
 965
 966     for (i = 0; i < this.grid.columns.length; i++) {
 967       spec=this.grid.columns[i].format;
 968       if (!spec || !spec.EntryType || !spec.FieldName) continue;
 969       if (spec.EntryType.charAt(0) != 'N') continue;
 970       var SelObj=Rico.$(spec.FieldName);
 971       if (!SelObj || SelObj.value!=this.options.TableSelectNew) continue;
 972       var newtext=Rico.$("textnew__" + SelObj.id).value;
 973       this.addSelectOption(SelObj,newtext,newtext);
 974     }
 975
 976     // set date values to ISO format
 977     for (i = 0; i < dateValues.length; i++) {
 978       dateValues[i].e.value = Rico.formatDate(dateValues[i].v,'yyyy-mm-dd');
 979     }
 980
 981     if (typeof tinyMCE!='undefined') tinyMCE.triggerSave();
 982     this.makeFormInvisible();
 983     this.sendForm();
 984     this.menu.cancelmenu();
 985     return false;
 986   },
 987
 988   sendForm: function() {
 989     this.setReadOnly("reset");  // reset disabled flag so that all fields are sent to server
 990     this.showResponse();
 991     Rico.log("sendForm: "+this.grid.tableId);
 992     Rico.ajaxSubmit(this.form, this.options.updateURL, {method:'post',onComplete:this.responseHandler});
 993   }
 994 };
 995
 996
 997 /**
 998  * @namespace Registers custom popup widgets to fill in a text box (e.g. ricoCalendar and ricoTree)
 999  * <pre>
1000  * Custom widget must implement:
1001  *   open() method (make control visible)
1002  *   close() method (hide control)
1003  *   container property (div element that contains the control)
1004  *   id property (uniquely identifies the widget class)
1005  *
1006  * widget calls returnValue method to return a value to the caller
1007  *
1008  * this object handles clicks on the control's icon and positions the control appropriately.
1009  * </pre>
1010  */
1011 Rico.EditControls = {
1012   widgetList : {},
1013   elemList   : {},
1014   zIndex     : 0,
1015
1016   register: function(widget, imgsrc) {
1017     this.widgetList[widget.id] = {imgsrc:imgsrc, widget:widget, currentEl:''};
1018     widget.returnValue=Rico.bind(this,'setValue',widget);
1019     Rico.log("Rico.EditControls.register:"+widget.id);
1020   },
1021
1022   setZ: function(z) {
1023     this.zIndex=Math.max(this.zIndex,z+10);
1024   },
1025
1026   atLoad: function() {
1027     for (var id in this.widgetList) {
1028       var widget=this.widgetList[id].widget;
1029       if (widget.atLoad && !widget.atLoadComplete) {
1030         Rico.log("Rico.EditControls.atLoad: "+id);
1031         widget.atLoad();
1032         widget.atLoadComplete=true;
1033       }
1034     }
1035   },
1036
1037   applyTo: function(column,inputCtl) {
1038     var wInfo=this.widgetList[column.format.SelectCtl];
1039     if (!wInfo) return;
1040     Rico.log('Rico.EditControls.applyTo: '+column.displayName+' : '+column.format.SelectCtl);
1041     var descSpan = document.createElement('span');
1042     var newimg = document.createElement('img');
1043     newimg.style.paddingLeft='4px';
1044     newimg.style.cursor='pointer';
1045     newimg.align='top';
1046     newimg.src=wInfo.imgsrc;
1047     newimg.id=this.imgId(column.format.FieldName);
1048     Rico.eventBind(newimg,"click", Rico.eventHandle(this,'processClick'));
1049     inputCtl.parentNode.appendChild(descSpan);
1050     inputCtl.parentNode.appendChild(newimg);
1051     inputCtl.style.display='none';    // comment out this line for debugging
1052     var clr;
1053     if (column.format.isNullable) {
1054       clr=Rico.clearButton(Rico.eventHandle(this,'processClear'));
1055       clr.id=newimg.id+'_clear';
1056       inputCtl.parentNode.appendChild(clr);
1057     }
1058     this.elemList[newimg.id] = {descSpan:descSpan, inputCtl:inputCtl, widget:wInfo.widget, listObj:wInfo, column:column, clrimg:clr};
1059     column.format.selectIcon=newimg;
1060     column.format.selectDesc=descSpan;
1061   },
1062
1063   displayClrImg: function(column,bShow) {
1064     var el=this.elemList[this.imgId(column.format.FieldName)];
1065     //alert(column.format.FieldName+': '+bShow+' '+typeof(el.clrimg));
1066     if (el && el.clrimg) el.clrimg.style.display=bShow ? 'inline-block' : 'none';
1067   },
1068
1069   processClear: function(e) {
1070     var elem=Rico.eventElement(e);
1071     var el=this.elemList[elem.id.slice(0,-6)];
1072     if (!el) return;
1073     el.inputCtl.value='';
1074     el.descSpan.innerHTML=el.column._format('');
1075   },
1076
1077   processClick: function(e) {
1078     var elem=Rico.eventElement(e);
1079     var el=this.elemList[elem.id];
1080     if (!el) return;
1081     if (el.listObj.currentEl==elem.id && el.widget.container.style.display!='none') {
1082       el.widget.close();
1083       el.listObj.currentEl='';
1084     } else {
1085       el.listObj.currentEl=elem.id;
1086       Rico.log('Rico.EditControls.processClick: '+el.widget.id+' : '+el.inputCtl.value);
1087       el.widget.container.style.zIndex=this.zIndex;
1088       el.widget.open(el.inputCtl.value,el.column);     // this may change the size of the widget
1089       Rico.positionCtlOverIcon(el.widget.container,elem);
1090     }
1091   },
1092
1093   imgId: function(fieldname) {
1094     return 'icon_'+fieldname;
1095   },
1096
1097   resetValue: function(column) {
1098     var el=this.elemList[this.imgId(column.format.FieldName)];
1099     if (!el) return;
1100     el.inputCtl.value=column.format.ColData;
1101     var v=column._format(column.format.ColData);
1102     if (v==='') v='&nbsp;';
1103     el.descSpan.innerHTML=v;
1104   },
1105
1106   setValue: function(widget,newVal,newDesc) {
1107     var wInfo=this.widgetList[widget.id];
1108     if (!wInfo) return null;
1109     var id=wInfo.currentEl;
1110     if (!id) return null;
1111     var el=this.elemList[id];
1112     if (!el) return null;
1113     el.inputCtl.value=newVal;
1114     if (!newDesc) newDesc=el.column._format(newVal);
1115     el.descSpan.innerHTML=newDesc;
1116     if (el.column.format.DescriptionField)
1117       Rico.$(el.column.format.DescriptionField).value = newDesc;
1118     //alert(widget.id+':'+id+':'+el.inputCtl.id+':'+el.inputCtl.value+':'+newDesc);
1119   },
1120
1121   close: function(id) {
1122     var wInfo=this.widgetList[id];
1123     if (!wInfo) return;
1124     if (wInfo.widget.container.style.display!='none')
1125       wInfo.widget.close();
1126   }
1127 };
1128
1129 Rico.includeLoaded('ricoLiveGridForms.js');