1afb5d64e54059043c11f9251b01500039c25e33
[infodrom/rico3] / minsrc / ricoLiveGrid.js
1 /*
2  *  (c) 2005-2011 Richard Cowin (http://openrico.org)
3  *  (c) 2005-2011 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 /** @namespace */
17 if (!Rico.Buffer) Rico.Buffer = {};
18
19 Rico.Buffer.Base = function(dataTable, options) {
20   this.initialize(dataTable, options);
21 }
22 /** @lends Rico.Buffer.Base# */
23 Rico.Buffer.Base.prototype = {
24 /**
25  * @class Defines the static buffer class (no AJAX).
26  * Loads buffer with data that already exists in the document as an HTML table or passed via javascript.
27  * Also serves as a base class for AJAX-enabled buffers.
28  * @constructs
29  */
30   initialize: function(dataTable, options) {
31     this.clear();
32     this.updateInProgress = false;
33     this.lastOffset = 0;
34     this.rcvdRowCount = false;  // true if an eof element was included in the last response
35     this.foundRowCount = false; // true if a response is ever received with eof true
36     this.totalRows = 0;
37     this.rowcntContent = "";
38     this.rcvdOffset = -1;
39     this.options = {
40       fixedHdrRows     : 0,
41       canFilter        : true,  // does buffer object support filtering?
42       isEncoded        : true,  // is the data received via ajax html encoded?
43       acceptStyle      : false, // copy style from original/ajax data?
44       canRefresh       : false  // should "refresh" be shown on filter menu?
45     };
46     Rico.extend(this.options, options || {});
47     if (dataTable) {
48       this.loadRowsFromTable(dataTable,this.options.fixedHdrRows);
49       dataTable.parentNode.removeChild(dataTable);  // delete the data once it has been loaded
50     }
51   },
52
53   registerGrid: function(liveGrid) {
54     this.liveGrid = liveGrid;
55   },
56
57   setTotalRows: function( newTotalRows ) {
58     if (typeof(newTotalRows)!='number') newTotalRows=this.size;
59     if (this.totalRows == newTotalRows) return;
60     this.totalRows = newTotalRows;
61     if (!this.liveGrid) return;
62     Rico.log("setTotalRows, newTotalRows="+newTotalRows);
63     switch (this.liveGrid.sizeTo) {
64       case 'data':
65         this.liveGrid.resizeWindow();
66         break;
67       case 'datamax':
68         this.liveGrid.setPageSize(newTotalRows);
69         break;
70       default:
71         this.liveGrid.updateHeightDiv();
72         break;
73     }
74   },
75
76   loadRowsFromTable: function(tableElement,firstRow) {
77     var newRows = [];
78     var trs = tableElement.getElementsByTagName("tr");
79     for ( var i=firstRow || 0; i < trs.length; i++ ) {
80       var row = [];
81       var cells = trs[i].getElementsByTagName("td");
82       for ( var j=0; j < cells.length ; j++ )
83         row[j]=cells[j].innerHTML;
84       newRows.push( row );
85     }
86     this.loadRows(newRows);
87   },
88
89   loadRowsFromArray: function(array2D) {
90     for ( var i=0; i < array2D.length; i++ ) {
91       for ( var j=0; j < array2D[i].length ; j++ ) {
92         array2D[i][j]=array2D[i][j].toString();
93       }
94     }
95     this.loadRows(array2D);
96   },
97
98   loadRows: function(jstable) {
99     this.baseRows = jstable;
100     this.startPos = 0;
101     this.size = this.baseRows.length;
102   },
103
104   dom2jstable: function(rowsElement) {
105     Rico.log('dom2jstable: encoded='+this.options.isEncoded);
106     var newRows = [];
107     var trs = rowsElement.getElementsByTagName("tr");
108     for ( var i=0; i < trs.length; i++ ) {
109       var row = [];
110       var cells = trs[i].getElementsByTagName("td");
111       for ( var j=0; j < cells.length ; j++ )
112         row[j]=Rico.getContentAsString(cells[j],this.options.isEncoded);
113       newRows.push( row );
114     }
115     return newRows;
116   },
117
118   _blankRow: function() {
119     var newRow=[];
120     for (var i=0; i<this.liveGrid.columns.length; i++) {
121       newRow[i]='';
122     }
123     return newRow;
124   },
125
126   deleteRows: function(rowIndex,cnt) {
127     this.baseRows.splice(rowIndex,typeof(cnt)=='number' ? cnt : 1);
128     this.liveGrid.isPartialBlank=true;
129     this.size=this.baseRows.length;
130   },
131
132   insertRow: function(beforeRowIndex) {
133     var r=this._blankRow();
134     this.baseRows.splice(beforeRowIndex,0,r);
135     this.size=this.baseRows.length;
136     this.liveGrid.isPartialBlank=true;
137     if (this.startPos < 0) this.startPos=0;
138     return r;
139   },
140
141   appendRows: function(cnt) {
142     var newRows=[];
143     for (var i=0; i<cnt; i++) {
144       var r=this._blankRow();
145       this.baseRows.push(r);
146       newRows.push(r);
147     }
148     this.size=this.baseRows.length;
149     this.liveGrid.isPartialBlank=true;
150     if (this.startPos < 0) this.startPos=0;
151     return newRows;
152   },
153   
154   sortFunc: function(coltype) {
155     var self=this;
156     switch (coltype) {
157       case 'number': return function(a,b) { return self._sortNumeric(a,b); };
158       case 'control':return function(a,b) { return self._sortControl(a,b); };
159       default:       return function(a,b) { return self._sortAlpha(a,b); };
160     }
161   },
162
163   sortBuffer: function(colnum) {
164     if (!this.baseRows) {
165       this.delayedSortCol=colnum;
166       return;
167     }
168     this.liveGrid.showMsg(Rico.getPhraseById("sorting"));
169     this.sortColumn=colnum;
170     var col=this.liveGrid.columns[colnum];
171     this.getValFunc=col._sortfunc;
172     this.baseRows.sort(this.sortFunc(col.format.type));
173     if (col.getSortDirection()=='DESC') this.baseRows.reverse();
174   },
175   
176   _sortAlpha: function(a,b) {
177     var aa = this.sortColumn<a.length ? Rico.getInnerText(a[this.sortColumn]) : '';
178     var bb = this.sortColumn<b.length ? Rico.getInnerText(b[this.sortColumn]) : '';
179     if (aa==bb) return 0;
180     if (aa<bb) return -1;
181     return 1;
182   },
183
184   _sortNumeric: function(a,b) {
185     var aa = this.sortColumn<a.length ? this.nan2zero(Rico.getInnerText(a[this.sortColumn])) : 0;
186     var bb = this.sortColumn<b.length ? this.nan2zero(Rico.getInnerText(b[this.sortColumn])) : 0;
187     return aa-bb;
188   },
189
190   nan2zero: function(n) {
191     if (typeof(n)=='string') n=parseFloat(n);
192     return isNaN(n) || typeof(n)=='undefined' ? 0 : n;
193   },
194   
195   _sortControl: function(a,b) {
196     var aa = this.sortColumn<a.length ? Rico.getInnerText(a[this.sortColumn]) : '';
197     var bb = this.sortColumn<b.length ? Rico.getInnerText(b[this.sortColumn]) : '';
198     if (this.getValFunc) {
199       aa=this.getValFunc(aa);
200       bb=this.getValFunc(bb);
201     }
202     if (aa==bb) return 0;
203     if (aa<bb) return -1;
204     return 1;
205   },
206
207   clear: function() {
208     this.baseRows = [];
209     this.rows = [];
210     this.modified = [];
211     this.attr = null;
212     this.startPos = -1;
213     this.size = 0;
214     this.windowPos = 0;
215   },
216
217   isInRange: function(position) {
218     var lastRow=Math.min(this.totalRows, position + this.liveGrid.pageSize);
219     return (position >= this.startPos) && (lastRow <= this.endPos()); // && (this.size != 0);
220   },
221
222   endPos: function() {
223     return this.startPos + this.rows.length;
224   },
225
226   fetch: function(offset) {
227     Rico.log('fetch '+this.liveGrid.tableId+': offset='+offset);
228     this.applyFilters();
229     this.setTotalRows();
230     this.rcvdRowCount = true;
231     this.foundRowCount = true;
232     if (offset < 0) offset=0;
233     this.liveGrid.refreshContents(offset);
234     return;
235   },
236
237 /**
238  * @return a 2D array of buffer data representing the rows that are currently visible on the grid
239  */
240   visibleRows: function() {
241     return this.rows.slice(this.windowStart,this.windowEnd);
242   },
243
244   setWindow: function(startrow, endrow) {
245     this.windowStart = startrow - this.startPos;  // position in the buffer of first visible row
246     Rico.log('setWindow '+this.liveGrid.tableId+': '+startrow+', '+endrow+', newstart='+this.windowStart);
247     this.windowEnd = Math.min(endrow,this.size);  // position in the buffer of last visible row containing data+1
248     this.windowPos = startrow;                    // position in the dataset of first visible row
249   },
250
251 /**
252  * @return true if bufRow is currently visible in the grid
253  */
254   isVisible: function(bufRow) {
255     return bufRow < this.rows.length && bufRow >= this.windowStart && bufRow < this.windowEnd;
256   },
257   
258 /**
259  * takes a window row index and returns the corresponding buffer row index
260  */
261   bufferRow: function(windowRow) {
262     return this.windowStart+windowRow;
263   },
264
265 /**
266  * @return buffer cell at the specified visible row/col index
267  */
268   getWindowCell: function(windowRow,col) {
269     var bufrow=this.bufferRow(windowRow);
270     return this.isVisible(bufrow) && col < this.rows[bufrow].length ? this.rows[bufrow][col] : null;
271   },
272
273   getWindowStyle: function(windowRow,col) {
274     var bufrow=this.bufferRow(windowRow);
275     return this.attr && this.isVisible(bufrow) && this.attr[bufrow] && col < this.attr[bufrow].length ? this.attr[bufrow][col] : '';
276   },
277
278   getWindowValue: function(windowRow,col) {
279     return this.getWindowCell(windowRow,col);
280   },
281
282   setWindowValue: function(windowRow,col,newval) {
283     var bufrow=this.bufferRow(windowRow);
284     if (bufrow >= this.windowEnd) return false;
285     return this.setValue(bufrow,col,newval);
286   },
287
288   getCell: function(bufRow,col) {
289     return bufRow < this.size ? this.rows[bufRow][col] : null;
290   },
291
292   getValue: function(bufRow,col) {
293     return this.getCell(bufRow,col);
294   },
295
296   setValue: function(bufRow,col,newval,newstyle) {
297     if (bufRow>=this.size) return false;
298     if (!this.rows[bufRow][col]) this.rows[bufRow][col]={};
299     this.rows[bufRow][col]=newval;
300     if (this.options.acceptStyle && typeof newstyle=='string') {
301       if (!this.attr) this.attr=[];
302       if (!this.attr[bufRow]) this.attr[bufRow]=[];
303       this.attr[bufRow][col]=newstyle;
304     }
305     if (!this.modified[bufRow]) this.modified[bufRow]=[];
306     this.modified[bufRow][col]=true;
307     return true;
308   },
309
310   getRows: function(start, count) {
311     var begPos = start - this.startPos;
312     var endPos = Math.min(begPos + count,this.size);
313     var results = [];
314     for ( var i=begPos; i < endPos; i++ ) {
315       results.push(this.rows[i]);
316     }
317     return results;
318   },
319
320   applyFilters: function() {
321     var newRows=[],re=[];
322     var r,c,n,i,showRow,filtercnt;
323     var cols=this.liveGrid.columns;
324     for (n=0,filtercnt=0; n<cols.length; n++) {
325       c=cols[n];
326       if (c.filterType == Rico.ColumnConst.UNFILTERED) continue;
327       filtercnt++;
328       if (c.filterOp=='LIKE') re[n]=new RegExp(c.filterValues[0],'i');
329     }
330     Rico.log('applyFilters: # of filters='+filtercnt);
331     if (filtercnt==0) {
332       this.rows = this.baseRows;
333     } else {
334       for (r=0; r<this.baseRows.length; r++) {
335         showRow=true;
336         for (n=0; n<cols.length && showRow; n++) {
337           c=cols[n];
338           if (c.filterType == Rico.ColumnConst.UNFILTERED) continue;
339           switch (c.filterOp) {
340             case 'LIKE':
341               showRow=re[n].test(this.baseRows[r][n]);
342               break;
343             case 'EQ':
344               showRow=this.baseRows[r][n]==c.filterValues[0];
345               break;
346             case 'NE':
347               for (i=0; i<c.filterValues.length && showRow; i++)
348                 showRow=this.baseRows[r][n]!=c.filterValues[i];
349               break;
350             case 'LE':
351               if (c.format.type=='number')
352                 showRow=this.nan2zero(this.baseRows[r][n])<=this.nan2zero(c.filterValues[0]);
353               else
354                 showRow=this.baseRows[r][n]<=c.filterValues[0];
355               break;
356             case 'GE':
357               if (c.format.type=='number')
358                 showRow=this.nan2zero(this.baseRows[r][n])>=this.nan2zero(c.filterValues[0]);
359               else
360                 showRow=this.baseRows[r][n]>=c.filterValues[0];
361               break;
362             case 'NULL':
363               showRow=this.baseRows[r][n]=='';
364               break;
365             case 'NOTNULL':
366               showRow=this.baseRows[r][n]!='';
367               break;
368           }
369         }
370         if (showRow) newRows.push(this.baseRows[r]);
371       }
372       this.rows = newRows;
373     }
374     this.rowcntContent = this.size = this.rows.length;
375   },
376
377   printAll: function() {
378     this.liveGrid.showMsg(Rico.getPhraseById('exportInProgress'));
379     Rico.runLater(10,this,'_printAll');  // allow message to paint
380   },
381
382 /**
383  * Support function for printAll()
384  */
385   _printAll: function() {
386     this.liveGrid.exportStart();
387     this.exportBuffer(this.getRows(0,this.totalRows));
388     this.liveGrid.exportFinish();
389   },
390
391 /**
392  * Copies visible rows to a new window as a simple html table.
393  */
394   printVisible: function() {
395     this.liveGrid.showMsg(Rico.getPhraseById('exportInProgress'));
396     Rico.runLater(10,this,'_printVisible');  // allow message to paint
397   },
398
399   _printVisible: function() {
400     this.liveGrid.exportStart();
401     this.exportBuffer(this.visibleRows());
402     this.liveGrid.exportFinish();
403   },
404
405 /**
406  * Send all rows to print/export window
407  */
408   exportBuffer: function(rows,startPos) {
409     var r,c,v,col,exportText;
410     Rico.log("exportBuffer: "+rows.length+" rows");
411     var exportStyles=this.liveGrid.getExportStyles(this.liveGrid.tbody[0]);
412     var tdstyle=[];
413     var totalcnt=startPos || 0;
414     var cols=this.liveGrid.columns;
415     for (c=0; c<cols.length; c++) {
416       if (cols[c].visible) tdstyle[c]=this.liveGrid.exportStyle(cols[c].cell(0),exportStyles);  // assumes row 0 style applies to all rows
417     }
418     for(r=0; r < rows.length; r++) {
419       exportText='';
420       for (c=0; c<cols.length; c++) {
421         if (!cols[c].visible) continue;
422         col=cols[c];
423         col.expStyle=tdstyle[c];
424         v=col._export(rows[r][c],rows[r]);
425         if (v=='') v='&nbsp;';
426         exportText+="<td style='"+col.expStyle+"'>"+v+"</td>";
427       }
428       this.liveGrid.exportRows.push(exportText);
429       totalcnt++;
430       if (totalcnt % 10 == 0) window.status=Rico.getPhraseById('exportStatus',totalcnt);
431     }
432   }
433
434 };
435
436
437 // Rico.LiveGrid -----------------------------------------------------
438
439 Rico.LiveGrid = function(tableId, buffer, options) {
440   this.initialize(tableId, buffer, options);
441 }
442
443 /** 
444  * @lends Rico.LiveGrid#
445  * @property tableId id string for this grid
446  * @property options the options object passed to the constructor extended with defaults
447  * @property buffer the buffer object containing the data for this grid
448  * @property columns array of {@link Rico.LiveGridColumn} objects
449  */
450 Rico.LiveGrid.prototype = {
451 /**
452  * @class Buffered LiveGrid component
453  * @extends Rico.GridCommon
454  * @constructs
455  */
456   initialize: function( tableId, buffer, options ) {
457     Rico.extend(this, Rico.GridCommon);
458     Rico.extend(this, Rico.LiveGridMethods);
459     this.baseInit();
460     this.tableId = tableId;
461     this.buffer = buffer;
462     this.actionId='_action_'+tableId;
463     Rico.setDebugArea(tableId+"_debugmsgs");    // if used, this should be a textarea
464
465     Rico.extend(this.options, {
466       visibleRows      : -3,    // -1 or 'window'=size grid to client window; -2 or 'data'=size grid to min(window,data); -3 or 'body'=size so body does not have a scrollbar; -4 or 'parent'=size to parent element (e.g. if grid is inside a div)
467       frozenColumns    : 0,
468       offset           : 0,     // first row to be displayed
469       prefetchBuffer   : true,  // load table on page load?
470       minPageRows      : 2,
471       maxPageRows      : 50,
472       canSortDefault   : true,  // can be overridden in the column specs
473       canFilterDefault : buffer.options.canFilter, // can be overridden in the column specs
474       canHideDefault   : true,  // can be overridden in the column specs
475
476       // highlight & selection parameters
477       highlightElem    : 'none',// what gets highlighted/selected (cursorRow, cursorCell, menuRow, menuCell, selection, or none)
478       highlightSection : 3,     // which section gets highlighted (frozen=1, scrolling=2, all=3, none=0)
479       highlightMethod  : 'class', // outline, class, both (outline is less CPU intensive on the client)
480       highlightClass   : Rico.theme.gridHighlightClass || 'ricoLG_selection',
481
482       // export/print parameters
483       maxPrint         : 5000,  // max # of rows that can be printed/exported, 0=disable print/export feature
484
485       // heading parameters
486       headingSort      : 'link', // link: make headings a link that will sort column, hover: make headings a hoverset, none: events on headings are disabled
487       hdrIconsFirst    : true    // true: put sort & filter icons before header text, false: after
488     });
489     // other options:
490     //   sortCol: initial sort column
491
492     var self=this;
493     this.options.sortHandler = function() { self.sortHandler(); };
494     this.options.filterHandler = function() { self.filterHandler(); };
495     this.options.onRefreshComplete = function(firstrow,lastrow) { self.bookmarkHandler(firstrow,lastrow); };
496     this.options.rowOverHandler = Rico.eventHandle(this,'rowMouseOver');
497     this.options.mouseDownHandler = Rico.eventHandle(this,'selectMouseDown');
498     this.options.mouseOverHandler = Rico.eventHandle(this,'selectMouseOver');
499     this.options.mouseUpHandler  = Rico.eventHandle(this,'selectMouseUp');
500     Rico.extend(this.options, options || {});
501
502     switch (typeof this.options.visibleRows) {
503       case 'string':
504         this.sizeTo=this.options.visibleRows;
505         switch (this.options.visibleRows) {
506           case 'data':   this.options.visibleRows=-2; break;
507           case 'body':   this.options.visibleRows=-3; break;
508           case 'parent': this.options.visibleRows=-4; break;
509           case 'datamax':this.options.visibleRows=-5; break;
510           default:       this.options.visibleRows=-1; break;
511         }
512         break;
513       case 'number':
514         switch (this.options.visibleRows) {
515           case -1: this.sizeTo='window'; break;
516           case -2: this.sizeTo='data'; break;
517           case -3: this.sizeTo='body'; break;
518           case -4: this.sizeTo='parent'; break;
519           case -5: this.sizeTo='datamax'; break;
520           default: this.sizeTo='fixed'; break;
521         }
522         break;
523       default:
524         this.sizeTo='body';
525         this.options.visibleRows=-3;
526         break;
527     }
528     this.highlightEnabled=this.options.highlightSection>0;
529     this.pageSize=0;
530     this.createTables();
531     if (this.headerColCnt==0) {
532       alert('ERROR: no columns found in "'+this.tableId+'"');
533       return;
534     }
535     this.createColumnArray('LiveGridColumn');
536     if (this.options.headingSort=='hover')
537       this.createHoverSet();
538
539     this.bookmark=document.getElementById(this.tableId+"_bookmark");
540     this.sizeDivs();
541     var filterUIrow=-1;
542     if (this.buffer.options.canFilter && this.options.AutoFilter)
543       filterUIrow=this.addHeadingRow('ricoLG_FilterRow');
544     this.createDataCells(this.options.visibleRows);
545     if (this.pageSize == 0) return;
546     this.buffer.registerGrid(this);
547     if (this.buffer.setBufferSize) this.buffer.setBufferSize(this.pageSize);
548     this.scrollTimeout = null;
549     this.lastScrollPos = 0;
550     this.attachMenuEvents();
551
552     this.setSortUI( this.options.sortCol, this.options.sortDir );
553     this.setImages();
554     if (this.listInvisible().length==this.columns.length)
555       this.columns[0].showColumn();
556     this.sizeDivs();
557     this.scrollDiv.style.display="";
558     if (this.buffer.totalRows>0)
559       this.updateHeightDiv();
560     if (this.options.prefetchBuffer) {
561       if (this.bookmark) this.bookmark.innerHTML = Rico.getPhraseById('bookmarkLoading');
562       if (this.options.canFilterDefault && this.options.getQueryParms)
563         this.checkForFilterParms();
564       this.scrollToRow(this.options.offset);
565       this.buffer.fetch(this.options.offset);
566     }
567     if (filterUIrow >= 0)
568       this.createFilters(filterUIrow);
569     this.scrollEventFunc=Rico.eventHandle(this,'handleScroll');
570     this.wheelEventFunc=Rico.eventHandle(this,'handleWheel');
571     this.wheelEvent=(Rico.isIE || Rico.isOpera || Rico.isWebKit) ? 'mousewheel' : 'DOMMouseScroll';
572     if (this.options.offset && this.options.offset < this.buffer.totalRows)
573       Rico.runLater(50,this,'scrollToRow',this.options.offset);  // Safari requires a delay
574     this.pluginScroll();
575     this.setHorizontalScroll();
576     Rico.log("setHorizontalScroll done");
577     if (this.options.windowResize)
578       Rico.runLater(100,this,'pluginWindowResize');
579     Rico.log("initialize complete for "+this.tableId);
580     //alert('clientLeft='+this.scrollDiv.clientLeft);
581     if (this.direction=='rtl' && (!Rico.isWebKit || this.scrollDiv.clientLeft > 0)) {
582       this.scrollTab.style.right='0px';
583     } else {
584       this.scrollTab.style.left='0px';
585       Rico.setStyle(this.tabs[1], {'float': 'left'});
586     }
587   }
588 };
589
590
591 Rico.LiveGridMethods = {
592 /** @lends Rico.LiveGrid# */
593
594   createHoverSet: function() {
595     var hdrs=[];
596     for( var c=0; c < this.headerColCnt; c++ ) {
597       if (this.columns[c].sortable) {\r
598         hdrs.push(this.columns[c].hdrCellDiv);
599       }
600     }
601     this.hoverSet = new Rico.HoverSet(hdrs);
602   },
603
604   checkForFilterParms: function() {
605     var s=window.location.search;
606     if (s.charAt(0)=='?') s=s.substring(1);
607     var pairs = s.split('&');
608     for (var i=0; i<pairs.length; i++) {
609       if (pairs[i].match(/^f\[\d+\]/)) {
610         this.buffer.options.requestParameters.push(pairs[i]);
611       }
612     }
613   },
614
615 /**
616  * Refreshes a detail grid from a master grid
617  * @returns row index on master table on success, -1 otherwise
618  */
619   drillDown: function(e,masterColNum,detailColNum) {
620     var cell=Rico.eventElement(e || window.event);
621     cell=Rico.getParentByTagName(cell,'div','ricoLG_cell');
622     if (!cell) return -1;
623     var idx=this.winCellIndex(cell);
624     if (idx.row >= this.buffer.totalRows) return -1
625     this.unhighlight();
626     this.menuIdx=idx;  // ensures selection gets cleared when menu is displayed
627     this.highlight(idx);
628     var drillValue=this.buffer.getWindowCell(idx.row,masterColNum);
629     for (var i=3; i<arguments.length; i++)
630       arguments[i].setDetailFilter(detailColNum,drillValue);
631     return idx.row;
632   },
633
634 /**
635  * set filter on a detail grid that is in a master-detail relationship
636  */
637   setDetailFilter: function(colNumber,filterValue) {
638     var c=this.columns[colNumber];
639     c.format.ColData=filterValue;
640     c.setSystemFilter('EQ',filterValue);
641   },
642
643 /**
644  * Create one table for frozen columns and one for scrolling columns.
645  * Also create div's to contain them.
646  * @returns true on success
647  */
648   createTables: function() {
649     var insertloc,hdrSrc,i;
650     var table = document.getElementById(this.tableId) || document.getElementById(this.tableId+'_outerDiv');
651     if (!table) return false;
652     if (table.tagName.toLowerCase()=='table') {
653       var theads=table.getElementsByTagName("thead");
654       if (theads.length == 1) {
655         Rico.log("createTables: using thead section, id="+this.tableId);
656         if (this.options.ColGroupsOnTabHdr && this.options.ColGroups) {
657           var r=theads[0].insertRow(0);
658           this.insertPanelNames(r, 0, this.options.frozenColumns, 'ricoFrozen');
659           this.insertPanelNames(r, this.options.frozenColumns, this.options.columnSpecs.length);
660         }
661         hdrSrc=theads[0].rows;
662       } else {
663         Rico.log("createTables: using tbody section, id="+this.tableId);
664         hdrSrc=new Array(table.rows[0]);
665       }
666       insertloc=table;
667     } else if (this.options.columnSpecs.length > 0) {
668       if (!table.id.match(/_outerDiv$/)) insertloc=table;
669       Rico.log("createTables: inserting at "+table.tagName+", id="+this.tableId);
670     } else {
671       alert("ERROR!\n\nUnable to initialize '"+this.tableId+"'\n\nLiveGrid terminated");
672       return false;
673     }
674
675     this.createDivs();
676     this.scrollContainer = this.createDiv("scrollContainer",this.structTabLR);
677     this.scrollContainer.appendChild(this.scrollDiv); // move scrollDiv
678     this.scrollTab = this.createDiv("scrollTab",this.scrollContainer);
679     this.shadowDiv  = this.createDiv("shadow",this.scrollDiv);
680     this.shadowDiv.style.direction='ltr';  // avoid FF bug
681     this.scrollDiv.style.display="none";
682     this.scrollDiv.scrollTop=0;
683     if (this.options.highlightMethod!='class') {
684       this.highlightDiv=[];
685       switch (this.options.highlightElem) {
686         case 'menuRow':
687         case 'cursorRow':
688           this.highlightDiv[0] = this.createDiv("highlight",this.outerDiv);
689           this.highlightDiv[0].style.display="none";
690           break;
691         case 'menuCell':
692         case 'cursorCell':
693           for (i=0; i<2; i++) {
694             this.highlightDiv[i] = this.createDiv("highlight",i==0 ? this.frozenTabs : this.scrollTab);
695             this.highlightDiv[i].style.display="none";
696             this.highlightDiv[i].id+=i;
697           }
698           break;
699         case 'selection':
700           // create one div for each side of the rectangle
701           var parentDiv=this.options.highlightSection==1 ? this.frozenTabs : this.scrollTab;
702           for (i=0; i<4; i++) {
703             this.highlightDiv[i] = this.createDiv("highlight",parentDiv);
704             this.highlightDiv[i].style.display="none";
705             this.highlightDiv[i].style.overflow="hidden";
706             this.highlightDiv[i].id+=i;
707             this.highlightDiv[i].style[i % 2==0 ? 'height' : 'width']="0px";
708           }
709           break;
710       }
711     }
712
713     // create new tables
714     for (i=0; i<3; i++) {
715       this.tabs[i] = document.createElement("table");
716       this.tabs[i].className = (i < 2) ? 'ricoLG_table' : 'ricoLG_scrollTab';
717       this.tabs[i].border=0;
718       this.tabs[i].cellPadding=0;
719       this.tabs[i].cellSpacing=0;
720       this.tabs[i].id = this.tableId+"_tab"+i;
721     }
722     // set headings
723     for (i=0; i<2; i++) {
724       this.thead[i]=this.tabs[i].createTHead();
725       this.thead[i].className='ricoLG_top';
726       if (Rico.theme.gridheader) Rico.addClass(this.thead[i],Rico.theme.gridheader);
727     }
728     // set bodies
729     for (i=0; i<2; i++) {
730       this.tbody[i]=Rico.getTBody(this.tabs[i==0?0:2]);
731       this.tbody[i].className='ricoLG_bottom';
732       if (Rico.theme.gridcontent) Rico.addClass(this.tbody[i],Rico.theme.gridcontent);
733       this.tbody[i].insertRow(-1);
734     }
735     this.frozenTabs.appendChild(this.tabs[0]);
736     this.innerDiv.appendChild(this.tabs[1]);
737     this.scrollTab.appendChild(this.tabs[2]);
738     if (insertloc) insertloc.parentNode.insertBefore(this.outerDiv,insertloc);
739     if (hdrSrc) {
740       this.headerColCnt = this.getColumnInfo(hdrSrc);
741       this.loadHdrSrc(hdrSrc);
742     } else {
743       this.createHdr(0,0,this.options.frozenColumns);
744       this.createHdr(1,this.options.frozenColumns,this.options.columnSpecs.length);
745       if (this.options.ColGroupsOnTabHdr && this.options.ColGroups) {
746         this.insertPanelNames(this.thead[0].insertRow(0), 0, this.options.frozenColumns);
747         this.insertPanelNames(this.thead[1].insertRow(0), this.options.frozenColumns, this.options.columnSpecs.length);
748       }
749       for (i=0; i<2; i++)
750         this.headerColCnt = this.getColumnInfo(this.thead[i].rows);
751     }
752     for( var c=0; c < this.headerColCnt; c++ )
753       this.tbody[c<this.options.frozenColumns ? 0 : 1].rows[0].insertCell(-1);
754     if (insertloc) table.parentNode.removeChild(table);
755     Rico.log('createTables end');
756     return true;
757   },
758
759   createDataCells: function(visibleRows) {
760     if (visibleRows < 0) {
761       for (var i=0; i<this.options.minPageRows; i++)
762         this.appendBlankRow();
763       this.sizeDivs();
764       this.autoAppendRows(this.remainingHt());
765     } else {
766       for( var r=0; r < visibleRows; r++ )
767         this.appendBlankRow();
768     }
769     var s=this.options.highlightSection;
770     if (s & 1) this.attachHighlightEvents(this.tbody[0]);
771     if (s & 2) this.attachHighlightEvents(this.tbody[1]);
772   },
773
774 /**
775  * @param colnum column number
776  * @return id string for a filter element
777  */
778   filterId: function(colnum) {
779     return 'RicoFilter_'+this.tableId+'_'+colnum;
780   },
781
782 /**
783  * Create filter elements in heading
784  * Reads this.columns[].filterUI to determine type of filter element for each column (t=text box, s=select list, c=custom)
785  * @param r heading row where filter elements will be placed
786  */
787   createFilters: function(r) {
788     for( var c=0; c < this.headerColCnt; c++ ) {
789       var col=this.columns[c];
790       var fmt=col.format;
791       if (typeof fmt.filterUI!='string') continue;
792       var cell=this.hdrCells[r][c].cell;
793       var field,name=this.filterId(c);\r
794       var divs=cell.getElementsByTagName('div');
795       // copy text alignment from data cell
796       var align=Rico.getStyle(this.cell(0,c),'textAlign');
797       divs[1].style.textAlign=align;
798       switch (fmt.filterUI.charAt(0)) {
799         case 't':
800           // text field
801           field=Rico.createFormField(divs[1],'input',Rico.inputtypes.search ? 'search' : 'text',name,'RicoFilter');
802           var size=fmt.filterUI.match(/\d+/);
803           field.maxLength=fmt.Length || 50;\r
804           field.size=size ? parseInt(size,10) : 10;
805           if (field.type != 'search') divs[1].appendChild(Rico.clearButton(Rico.eventHandle(col,'filterClear')));
806           if (col.filterType==Rico.ColumnConst.USERFILTER && col.filterOp=='LIKE') {
807             var v=col.filterValues[0];
808             if (v.charAt(0)=='*') v=v.substr(1);
809             if (v.slice(-1)=='*') v=v.slice(0,-1);
810             field.value=v;
811             col.lastKeyFilter=v;
812           }
813           Rico.eventBind(field,'keyup',Rico.eventHandle(col,'filterKeypress'),false);
814           col.filterField=field;\r
815           break;\r
816         case 'm':
817           // multi-select
818         case 's':
819           // drop-down select
820           field=Rico.createFormField(divs[1],'select',null,name,'RicoFilter');\r
821           Rico.addSelectOption(field,this.options.FilterAllToken,Rico.getPhraseById("filterAll"));\r
822           col.filterField=field;
823           var options={};\r
824           Rico.extend(options, this.buffer.ajaxOptions);
825           var colnum=typeof(fmt.filterCol)=='number' ? fmt.filterCol : c;
826           options.parameters = this.buffer.formQueryHashXML(0,-1);
827           options.parameters.distinct = colnum;
828           options.onComplete = this.filterValuesUpdateFunc(c);
829           new Rico.ajaxRequest(this.buffer.dataSource, options);
830           break;\r
831         case 'n':
832           field=Rico.createFormField(divs[1],'select',null,name,'RicoFilter');
833           Rico.addSelectOption(field,this.options.FilterAllToken,Rico.getPhraseById("filterAll"));
834           col.filterField=field;
835           var choices=fmt.filterUI.length == 1 ? "-0+" : fmt.filterUI.substr(1);
836           if (choices.indexOf("-") >= 0) Rico.addSelectOption(field,"LT0","< 0");
837           if (choices.indexOf("0") >= 0) Rico.addSelectOption(field,"EQ0","= 0");
838           if (choices.indexOf("+") >= 0) Rico.addSelectOption(field,"GT0","> 0");
839           Rico.eventBind(col.filterField,'change',Rico.eventHandle(col,'nFilterChange'));
840           break;
841         case 'c':
842           // custom
843           if (typeof col._createFilters == 'function')
844             col._createFilters(divs[1], name);
845           break;
846       }
847     }
848     this.initFilterImage(r);
849   },
850   
851   filterValuesUpdateFunc: function(colnum) {
852     var self=this;
853     return function (request) { self.filterValuesUpdate(colnum,request); };
854   },
855
856 /**
857  * update select list filter with values in AJAX response
858  * @returns true on success
859  */
860   filterValuesUpdate: function(colnum,request) {
861     var response = request.responseXML.getElementsByTagName("ajax-response");
862     Rico.log("filterValuesUpdate: "+request.status);
863     if (response == null || response.length != 1) return false;
864     response=response[0];
865     var error = response.getElementsByTagName('error');
866     if (error.length > 0) {
867       Rico.log("Data provider returned an error:\n"+Rico.getContentAsString(error[0],this.buffer.isEncoded));
868       alert(Rico.getPhraseById("requestError",Rico.getContentAsString(error[0],this.buffer.isEncoded)));
869       return false;
870     }\r
871     response=response.getElementsByTagName('response')[0];\r
872     var rowsElement = response.getElementsByTagName('rows')[0];\r
873     var col=this.columns[parseInt(colnum,10)];
874     var rows = this.buffer.dom2jstable(rowsElement);\r
875     var found = !col.filterValues || !col.filterValues.length;
876     if (!found) for (var i=0; i<rows.length; i++) {
877         if (rows[i][0] == col.filterValues[0]) {
878             found = true;
879             break;
880         }
881     }
882     if (!found) {
883         col.setUnfiltered(true);
884         if (this.options.filterHandler)
885             this.options.filterHandler();
886     }
887     var c,opt,v;
888     if (col.filterType==Rico.ColumnConst.USERFILTER && col.filterOp=='EQ') v=col.filterValues[0];
889     Rico.log('filterValuesUpdate: col='+colnum+' rows='+rows.length);
890     switch (col.format.filterUI.charAt(0)) {
891       case 'm':
892         // multi-select
893         col.mFilter = document.body.appendChild(document.createElement("div"));
894         col.mFilter.className = 'ricoLG_mFilter'
895         Rico.hide(col.mFilter);
896         var contentDiv = col.mFilter.appendChild(document.createElement("div"));
897         contentDiv.className = 'ricoLG_mFilter_content'
898         var buttonDiv = col.mFilter.appendChild(document.createElement("div"));
899         buttonDiv.className = 'ricoLG_mFilter_button'
900         col.mFilterButton=buttonDiv.appendChild(document.createElement("button"));
901         col.mFilterButton.innerHTML=Rico.getPhraseById("apply");
902         var eventName=Rico.isWebKit ? 'mousedown' : 'click';
903         Rico.eventBind(col.filterField,eventName,Rico.eventHandle(col,'mFilterSelectClick'));
904         Rico.eventBind(col.mFilterButton,'click',Rico.eventHandle(col,'mFilterFinish'));
905         //col.filterField.options[0].text=$('AllLabel').innerHTML;
906         tab = contentDiv.appendChild(document.createElement("table"));
907         tab.border=0;
908         tab.cellPadding=2;
909         tab.cellSpacing=0;
910         //tbody=(tab.tBodies.length==0) ? tab.appendChild(document.createElement("tbody")) : tab.tBodies[0];
911         var baseId=this.filterId(colnum)+'_';
912         this.createMFilterItem(tab,this.options.FilterAllToken,Rico.getPhraseById("filterAll"),baseId+'all',Rico.eventHandle(col,'mFilterAllClick'));
913         var handle=Rico.eventHandle(col,'mFilterOtherClick')
914         for (var i=0; i<rows.length; i++) {
915           if (rows[i].length>0) {
916             c=rows[i][0];
917             this.createMFilterItem(tab,c,c || Rico.getPhraseById("filterBlank"),baseId+i,handle);
918           }
919         }
920         col.mFilterInputs=contentDiv.getElementsByTagName('input');
921         col.mFilterLabels=contentDiv.getElementsByTagName('label');
922         col.mFilterFocus=col.mFilterInputs.length ? col.mFilterInputs[0] : col.mFilterButton;
923         break;
924
925       case 's':
926         // drop-down select
927         for (var i=0; i<rows.length; i++) {
928           if (rows[i].length>0) {
929             c=rows[i][0];
930             opt=Rico.addSelectOption(col.filterField,c,c || Rico.getPhraseById("filterBlank"));
931             if (col.filterType==Rico.ColumnConst.USERFILTER && c==v) opt.selected=true;
932           }
933         }
934         Rico.eventBind(col.filterField,'change',Rico.eventHandle(col,'filterChange'));
935         break;
936     }
937     return true;\r
938   },
939   
940   createMFilterItem: function(table,code,description,id,eventHandle) {
941     var tr=table.insertRow(-1);
942     tr.vAlign='top';
943     if (tr.rowIndex % 2 == 1) tr.className='ricoLG_mFilter_oddrow';
944     var td1=tr.insertCell(-1)
945     var td2=tr.insertCell(-1)
946     var field=Rico.createFormField(td1,'input','checkbox',id);
947     field.value=code;
948     field.checked=true;
949     var label = td2.appendChild(document.createElement("label"));
950     label.htmlFor = id;
951     label.innerHTML=description;
952     Rico.eventBind(field,'click',eventHandle);
953   },
954
955   unplugHighlightEvents: function() {
956     var s=this.options.highlightSection;
957     if (s & 1) this.detachHighlightEvents(this.tbody[0]);
958     if (s & 2) this.detachHighlightEvents(this.tbody[1]);
959   },
960
961 /**
962  * place panel names on first row of grid header (used by LiveGridForms)
963  */
964   insertPanelNames: function(r,start,limit,cellClass) {
965     Rico.log('insertPanelNames: start='+start+' limit='+limit);
966     r.className='ricoLG_hdg';
967     var lastIdx=-1, span, newCell=null, spanIdx=0;
968     for( var c=start; c < limit; c++ ) {
969       if (lastIdx == this.options.columnSpecs[c].ColGroupIdx) {
970         span++;
971       } else {
972         if (newCell) newCell.colSpan=span;
973         newCell = r.insertCell(-1);
974         if (cellClass) newCell.className=cellClass;
975         span=1;
976         lastIdx=this.options.columnSpecs[c].ColGroupIdx;
977         newCell.innerHTML=this.options.ColGroups[lastIdx];
978       }
979     }
980     if (newCell) newCell.colSpan=span;
981   },
982
983 /**
984  * create grid header for table i (if none was provided)
985  */
986   createHdr: function(i,start,limit) {
987     Rico.log('createHdr: i='+i+' start='+start+' limit='+limit);
988     var mainRow = this.thead[i].insertRow(-1);
989     mainRow.id=this.tableId+'_tab'+i+'h_main';
990     mainRow.className='ricoLG_hdg';
991     for( var c=start; c < limit; c++ ) {
992       var newCell = mainRow.insertCell(-1);
993       newCell.innerHTML=this.options.columnSpecs[c].Hdg;
994     }
995   },
996
997 /**
998  * move header cells in original table to grid
999  */
1000   loadHdrSrc: function(hdrSrc) {
1001     var i,h,c,r,newrow,cells;
1002     Rico.log('loadHdrSrc start');
1003     for (i=0; i<2; i++) {
1004       for (r=0; r<hdrSrc.length; r++) {
1005         newrow = this.thead[i].insertRow(-1);
1006         newrow.className='ricoLG_hdg '+this.tableId+'_hdg'+r;
1007       }
1008     }
1009     if (hdrSrc.length==1) {
1010       cells=hdrSrc[0].cells;
1011       for (c=0; cells.length > 0; c++)
1012         this.thead[c<this.options.frozenColumns ? 0 : 1].rows[0].appendChild(cells[0]);
1013     } else {
1014       for (r=0; r<hdrSrc.length; r++) {
1015         cells=hdrSrc[r].cells;
1016         for (c=0,h=0; cells.length > 0; c++) {
1017           if (Rico.hasClass(cells[0],'ricoFrozen')) {
1018             if (r==this.headerRowIdx) this.options.frozenColumns=c+1;
1019           } else {
1020             h=1;
1021           }
1022           this.thead[h].rows[r].appendChild(cells[0]);
1023         }
1024       }
1025     }
1026     Rico.log('loadHdrSrc end');
1027   },
1028
1029 /**
1030  * Size div elements
1031  */
1032   sizeDivs: function() {
1033     Rico.log('sizeDivs: '+this.tableId);
1034     //this.cancelMenu();
1035     this.unhighlight();
1036     this.baseSizeDivs();
1037     var firstVisible=this.firstVisible();
1038     if (this.pageSize == 0 || firstVisible < 0) return;
1039     var totRowHt=this.columns[firstVisible].dataColDiv.offsetHeight;
1040     this.rowHeight = Math.round(totRowHt/this.pageSize);
1041     var scrHt=this.dataHt;
1042     if (this.scrTabWi0 == this.scrTabWi) {
1043       // no scrolling columns - horizontal scroll bar not needed
1044       this.innerDiv.style.height=(this.hdrHt+1)+'px';
1045       this.scrollDiv.style.overflowX='hidden';
1046     } else {
1047       this.scrollDiv.style.overflowX='scroll';
1048       scrHt+=this.options.scrollBarWidth;
1049     }
1050     this.scrollDiv.style.height=scrHt+'px';
1051     this.innerDiv.style.width=(this.scrWi)+'px';
1052     this.scrollTab.style.width=(this.scrWi-this.options.scrollBarWidth)+'px';
1053     //this.resizeDiv.style.height=this.frozenTabs.style.height=this.innerDiv.style.height=(this.hdrHt+this.dataHt+1)+'px';
1054     this.resizeDiv.style.height=(this.hdrHt+this.dataHt+1)+'px';
1055     Rico.log('sizeDivs scrHt='+scrHt+' innerHt='+this.innerDiv.style.height+' rowHt='+this.rowHeight+' pageSize='+this.pageSize);
1056     var pad=(this.scrWi-this.scrTabWi < this.options.scrollBarWidth) ? 2 : 0;
1057     this.shadowDiv.style.width=(this.scrTabWi+pad)+'px';
1058     this.outerDiv.style.height=(this.hdrHt+scrHt)+'px';
1059     this.setHorizontalScroll();
1060   },
1061
1062   setHorizontalScroll: function() {
1063     var newLeft=(-this.scrollDiv.scrollLeft)+'px';
1064     this.tabs[1].style.marginLeft=newLeft;
1065     this.tabs[2].style.marginLeft=newLeft;
1066   },
1067
1068   remainingHt: function() {
1069     var tabHt=this.outerDiv.offsetHeight;
1070     var winHt=Rico.windowHeight();
1071     var margin=Rico.isIE ? 15 : 10;
1072     // if there is a horizontal scrollbar take it into account
1073     if (!Rico.isIE && window.frameElement && window.frameElement.scrolling=='yes' && this.sizeTo!='parent') margin+=this.options.scrollBarWidth;
1074     switch (this.sizeTo) {
1075       case 'window':
1076         var divTop=Rico.cumulativeOffset(this.outerDiv).top;
1077         Rico.log("remainingHt/window, winHt="+winHt+' tabHt='+tabHt+' gridY='+divTop);
1078         return winHt-divTop-tabHt-margin;  // allow for scrollbar and some margin
1079       case 'parent':
1080         var offset=this.offsetFromParent(this.outerDiv);
1081         if (Rico.isIE) Rico.hide(this.outerDiv);
1082         var parentHt=this.outerDiv.parentNode.clientHeight;
1083         if (Rico.isIE) Rico.show(this.outerDiv);
1084         Rico.log("remainingHt/parent, parentHt="+parentHt+' offset='+offset+' tabHt='+tabHt);
1085         return parentHt-tabHt-offset-margin;
1086       case 'data':
1087       case 'body':
1088         var bodyHt=Rico.isIE ? document.body.scrollHeight : document.body.offsetHeight;
1089         //alert("remainingHt\n document.height="+document.height+"\n body.offsetHeight="+document.body.offsetHeight+"\n body.scrollHeight="+document.body.scrollHeight+"\n documentElement.scrollHeight="+document.documentElement.scrollHeight);
1090         var remHt=winHt-bodyHt-margin;
1091         if (!Rico.isWebKit) remHt-=this.options.scrollBarWidth;
1092         Rico.log("remainingHt, winHt="+winHt+' pageHt='+bodyHt+' remHt='+remHt);
1093         return remHt;
1094       default:
1095         Rico.log("remainingHt, winHt="+winHt+' tabHt='+tabHt);
1096         if (this.sizeTo.slice(-1)=='%') winHt*=parseFloat(this.sizeTo)/100.0;
1097         else if (this.sizeTo.slice(-2)=='px') winHt=parseInt(this.sizeTo,10);
1098         return winHt-tabHt-margin;  // allow for scrollbar and some margin
1099     }
1100   },
1101
1102   offsetFromParent: function(element) {
1103     var valueT = 0;
1104     var elParent=element.parentNode;
1105     do {
1106       //Rico.log("offsetFromParent: "+element.tagName+' id='+element.id+' otop='+element.offsetTop);
1107       valueT += element.offsetTop  || 0;
1108       element = element.offsetParent;
1109       if (!element || element==null) break;
1110       var p = Rico.getStyle(element, 'position');
1111       if (element.tagName=='BODY' || element.tagName=='HTML' || p=='absolute') return valueT-elParent.offsetTop;
1112     } while (element != elParent);
1113     return valueT;
1114   },
1115
1116   adjustPageSize: function() {
1117     Rico.log('adjustPageSize start');
1118     var remHt=this.remainingHt();
1119     Rico.log('adjustPageSize remHt='+remHt+' lastRow='+this.lastRowPos);
1120     if (remHt > this.rowHeight)
1121       this.autoAppendRows(remHt);
1122     else if (remHt < 0 || this.sizeTo=='data')
1123       this.autoRemoveRows(-remHt);
1124     Rico.log('adjustPageSize end');
1125   },
1126   
1127   setPageSize: function(newRowCount) {
1128     Rico.log('setPageSize '+this.tableId+' newRowCount='+newRowCount);
1129     newRowCount=Math.min(newRowCount,this.options.maxPageRows);
1130     newRowCount=Math.max(newRowCount,this.options.minPageRows);
1131     this.sizeTo='fixed';
1132     var oldSize=this.pageSize;
1133     while (this.pageSize > newRowCount) {
1134       this.removeRow();
1135     }
1136     while (this.pageSize < newRowCount) {
1137       this.appendBlankRow();
1138     }
1139     this.finishResize(oldSize);
1140   },
1141
1142   pluginWindowResize: function() {
1143     Rico.log("pluginWindowResize");
1144     this.resizeWindowHandler=Rico.eventHandle(this,'resizeWindow');
1145     Rico.eventBind(window, "resize", this.resizeWindowHandler, false);
1146   },
1147
1148   unplugWindowResize: function() {
1149     if (!this.resizeWindowHandler) return;
1150     Rico.eventUnbind(window,"resize", this.resizeWindowHandler, false);
1151     this.resizeWindowHandler=null;
1152   },
1153
1154   resizeWindow: function() {
1155     Rico.log('resizeWindow '+this.tableId+' lastRow='+this.lastRowPos+' resizeState='+this.resizeState);
1156     if (this.resizeState=='finish') {
1157       Rico.log('resizeWindow postponed');
1158       this.resizeState='resize';
1159       return;
1160     }
1161     if (!this.sizeTo || this.sizeTo=='fixed') {
1162       this.sizeDivs();
1163       return;
1164     }
1165     if (this.sizeTo=='parent' && Rico.getStyle(this.outerDiv.parentNode,'display') == 'none') return;
1166     Rico.log('resizeWindow: about to adjustPageSize')
1167     var oldSize=this.pageSize;
1168     this.adjustPageSize();
1169     this.finishResize(oldSize);
1170   },
1171
1172   finishResize: function(oldSize) {
1173     Rico.log('finishResize '+this.tableId);
1174     if (this.pageSize > oldSize && this.buffer.totalRows>0) {
1175       this.isPartialBlank=true;
1176       var adjStart=this.adjustRow(this.lastRowPos);
1177       this.buffer.fetch(adjStart);
1178     } else if (this.pageSize < oldSize) {
1179       if (this.options.onRefreshComplete) this.options.onRefreshComplete(this.contentStartPos,this.contentStartPos+this.pageSize-1);  // update bookmark
1180     }
1181     this.resizeState='finish';
1182     Rico.runLater(20,this,'finishResize2');
1183     Rico.log('Resize '+this.tableId+' complete. old size='+oldSize+' new size='+this.pageSize);
1184   },
1185
1186   finishResize2: function() {
1187     Rico.log('finishResize2 '+this.tableId+': resizeState='+this.resizeState);
1188     this.sizeDivs();
1189     this.updateHeightDiv();
1190     if (this.resizeState=='resize') {
1191       this.resizeWindow();
1192     } else {
1193       this.resizeState='';
1194     }
1195   },
1196
1197   topOfLastPage: function() {
1198     return Math.max(this.buffer.totalRows-this.pageSize,0);
1199   },
1200
1201   updateHeightDiv: function() {
1202     var notdisp=this.topOfLastPage();
1203     var ht = notdisp ? this.scrollDiv.clientHeight + Math.floor(this.rowHeight * (notdisp + 0.4)) : 1;
1204     Rico.log("updateHeightDiv, ht="+ht+' scrollDiv.clientHeight='+this.scrollDiv.clientHeight+' rowsNotDisplayed='+notdisp);
1205     this.shadowDiv.style.height=ht+'px';
1206   },
1207
1208   autoRemoveRows: function(overage) {
1209     if (!this.rowHeight) return;
1210     var removeCnt=Math.ceil(overage / this.rowHeight);
1211     if (this.sizeTo=='data')
1212       removeCnt=Math.max(removeCnt,this.pageSize-this.buffer.totalRows);
1213     Rico.log("autoRemoveRows overage="+overage+" removeCnt="+removeCnt);
1214     for (var i=0; i<removeCnt; i++)
1215       this.removeRow();
1216   },
1217
1218   removeRow: function() {
1219     if (this.pageSize <= this.options.minPageRows) return;
1220     this.pageSize--;
1221     for( var c=0; c < this.headerColCnt; c++ ) {
1222       var cell=this.columns[c].cell(this.pageSize);
1223       this.columns[c].dataColDiv.removeChild(cell);
1224     }
1225   },
1226
1227   autoAppendRows: function(overage) {
1228     if (!this.rowHeight) return;
1229     var addCnt=Math.floor(overage / this.rowHeight);
1230     Rico.log("autoAppendRows overage="+overage+" cnt="+addCnt+" rowHt="+this.rowHeight);
1231     for (var i=0; i<addCnt; i++) {
1232       if (this.sizeTo=='data' && this.pageSize>=this.buffer.totalRows) break;
1233       this.appendBlankRow();
1234     }
1235   },
1236
1237 /**
1238  * on older systems, this can be fairly slow
1239  */
1240   appendBlankRow: function() {
1241     if (this.pageSize >= this.options.maxPageRows) return;
1242     Rico.log("appendBlankRow #"+this.pageSize);
1243     var cls=this.defaultRowClass(this.pageSize);
1244     for( var c=0; c < this.headerColCnt; c++ ) {
1245       var newdiv = document.createElement("div");
1246       newdiv.className = 'ricoLG_cell '+cls;
1247       newdiv.id=this.tableId+'_'+this.pageSize+'_'+c;
1248       this.columns[c].dataColDiv.appendChild(newdiv);
1249       if (this.columns[c]._create) {
1250         this.columns[c]._create(newdiv,this.pageSize);
1251       } else {
1252         newdiv.innerHTML='&nbsp;';   // this seems to be required by IE
1253       }
1254       if (this.columns[c].format.canDrag && Rico.registerDraggable) {
1255         Rico.registerDraggable( new Rico.LiveGridDraggable(this, this.pageSize, c), this.options.dndMgrIdx );
1256       }
1257     }
1258     this.pageSize++;
1259   },
1260
1261   defaultRowClass: function(rownum) {
1262     var cls
1263     if (rownum % 2==0) {
1264       cls='ricoLG_evenRow';
1265       //if (Rico.theme.primary) cls+=' '+Rico.theme.primary;
1266     } else {
1267       cls='ricoLG_oddRow';
1268       //if (Rico.theme.secondary) cls+=' '+Rico.theme.secondary;
1269     }
1270     return cls;
1271   },
1272
1273   handleMenuClick: function(e) {
1274     if (!this.menu) return;
1275     this.cancelMenu();
1276     this.unhighlight(); // in case highlighting was invoked externally
1277     var idx;
1278     var cell=Rico.eventElement(e);
1279     if (cell.className=='ricoLG_highlightDiv') {
1280       idx=this.highlightIdx;
1281     } else {
1282       cell=Rico.getParentByTagName(cell,'div','ricoLG_cell');
1283       if (!cell) return;
1284       idx=this.winCellIndex(cell);
1285       if ((this.options.highlightSection & (idx.tabIdx+1))==0) return;
1286     }
1287     this.highlight(idx);
1288     this.highlightEnabled=false;
1289     if (this.hideScroll) this.scrollDiv.style.overflow="hidden";
1290     this.menuIdx=idx;
1291     if (!this.menu.div) this.menu.createDiv();
1292     this.menu.liveGrid=this;
1293     if (this.menu.buildGridMenu) {
1294       var showMenu=this.menu.buildGridMenu(idx.row, idx.column, idx.tabIdx);
1295       if (!showMenu) return;
1296     }
1297     if (this.options.highlightElem=='selection' && !this.isSelected(idx.cell)) {
1298       this.selectCell(idx.cell);
1299     }
1300     var self=this;
1301     this.menu.showmenu(e,function() { self.closeMenu(); });
1302     return false;
1303   },
1304
1305   closeMenu: function() {
1306     if (!this.menuIdx) return;
1307     if (this.hideScroll) this.scrollDiv.style.overflow="";
1308     //this.unhighlight();
1309     this.highlightEnabled=true;
1310     this.menuIdx=null;
1311   },
1312
1313 /**
1314  * @return index of cell within the window
1315  */
1316   winCellIndex: function(cell) {
1317     var l=cell.id.lastIndexOf('_',cell.id.length);
1318     var l2=cell.id.lastIndexOf('_',l-1)+1;
1319     var c=parseInt(cell.id.substr(l+1));
1320     var r=parseInt(cell.id.substr(l2,l));
1321     return {row:r, column:c, tabIdx:this.columns[c].tabIdx, cell:cell};
1322   },
1323
1324 /**
1325  * @return index of cell within the dataset
1326  */
1327   datasetIndex: function(cell) {
1328     var idx=this.winCellIndex(cell);
1329     idx.row+=this.buffer.windowPos;
1330     idx.onBlankRow=(idx.row >= this.buffer.endPos());
1331     return idx;
1332   },
1333
1334   attachHighlightEvents: function(tBody) {
1335     switch (this.options.highlightElem) {
1336       case 'selection':
1337         Rico.eventBind(tBody,"mousedown", this.options.mouseDownHandler, false);
1338         /** @ignore */
1339         tBody.ondrag = function () { return false; };
1340         /** @ignore */
1341         tBody.onselectstart = function () { return false; };
1342         break;
1343       case 'cursorRow':
1344       case 'cursorCell':
1345         Rico.eventBind(tBody,"mouseover", this.options.rowOverHandler, false);
1346         break;
1347     }
1348   },
1349
1350   detachHighlightEvents: function(tBody) {
1351     switch (this.options.highlightElem) {
1352       case 'selection':
1353         Rico.eventUnbind(tBody,"mousedown", this.options.mouseDownHandler, false);
1354         tBody.ondrag = null;
1355         tBody.onselectstart = null;
1356         break;
1357       case 'cursorRow':
1358       case 'cursorCell':
1359         Rico.eventUnbind(tBody,"mouseover", this.options.rowOverHandler, false);
1360         break;
1361     }
1362   },
1363
1364 /**
1365  * @return array of objects containing row/col indexes (index values are relative to the start of the window)
1366  */
1367   getVisibleSelection: function() {
1368     var cellList=[];
1369     if (this.SelectIdxStart && this.SelectIdxEnd) {
1370       var r1=Math.max(Math.min(this.SelectIdxEnd.row,this.SelectIdxStart.row)-this.buffer.startPos,this.buffer.windowStart);
1371       var r2=Math.min(Math.max(this.SelectIdxEnd.row,this.SelectIdxStart.row)-this.buffer.startPos,this.buffer.windowEnd-1);
1372       var c1=Math.min(this.SelectIdxEnd.column,this.SelectIdxStart.column);
1373       var c2=Math.max(this.SelectIdxEnd.column,this.SelectIdxStart.column);
1374       //Rico.log("getVisibleSelection "+r1+','+c1+' to '+r2+','+c2+' ('+this.SelectIdxStart.row+',startPos='+this.buffer.startPos+',windowPos='+this.buffer.windowPos+',windowEnd='+this.buffer.windowEnd+')');
1375       for (var r=r1; r<=r2; r++) {
1376         for (var c=c1; c<=c2; c++)
1377           cellList.push({row:r-this.buffer.windowStart,column:c});
1378       }
1379     }
1380     if (this.SelectCtrl) {
1381       for (var i=0; i<this.SelectCtrl.length; i++) {
1382         if (this.SelectCtrl[i].row>=this.buffer.windowStart && this.SelectCtrl[i].row<this.buffer.windowEnd)
1383           cellList.push({row:this.SelectCtrl[i].row-this.buffer.windowStart,column:this.SelectCtrl[i].column});
1384       }
1385     }
1386     return cellList;
1387   },
1388
1389   updateSelectOutline: function() {
1390     if (!this.SelectIdxStart || !this.SelectIdxEnd) return;
1391     var r1=Math.max(Math.min(this.SelectIdxEnd.row,this.SelectIdxStart.row), this.buffer.windowStart);
1392     var r2=Math.min(Math.max(this.SelectIdxEnd.row,this.SelectIdxStart.row), this.buffer.windowEnd-1);
1393     if (r1 > r2) {
1394       this.HideSelection();
1395       return;
1396     }
1397     var c1=Math.min(this.SelectIdxEnd.column,this.SelectIdxStart.column);
1398     var c2=Math.max(this.SelectIdxEnd.column,this.SelectIdxStart.column);
1399     var top1=this.columns[c1].cell(r1-this.buffer.windowStart).offsetTop;
1400     var cell2=this.columns[c1].cell(r2-this.buffer.windowStart);
1401     var bottom2=cell2.offsetTop+cell2.offsetHeight;
1402     var left1=this.columns[c1].dataCell.offsetLeft;
1403     var left2=this.columns[c2].dataCell.offsetLeft;
1404     var right2=left2+this.columns[c2].dataCell.offsetWidth;
1405     //window.status='updateSelectOutline: '+r1+' '+r2+' top='+top1+' bot='+bottom2;
1406     this.highlightDiv[0].style.top=this.highlightDiv[3].style.top=this.highlightDiv[1].style.top=(this.hdrHt+top1-1) + 'px';
1407     this.highlightDiv[2].style.top=(this.hdrHt+bottom2-1)+'px';
1408     this.highlightDiv[3].style.left=(left1-2)+'px';
1409     this.highlightDiv[0].style.left=this.highlightDiv[2].style.left=(left1-1)+'px';
1410     this.highlightDiv[1].style.left=(right2-1)+'px';
1411     this.highlightDiv[0].style.width=this.highlightDiv[2].style.width=(right2-left1-1) + 'px';
1412     this.highlightDiv[1].style.height=this.highlightDiv[3].style.height=(bottom2-top1) + 'px';
1413     //this.highlightDiv[0].style.right=this.highlightDiv[2].style.right=this.highlightDiv[1].style.right=()+'px';
1414     //this.highlightDiv[2].style.bottom=this.highlightDiv[3].style.bottom=this.highlightDiv[1].style.bottom=(this.hdrHt+bottom2) + 'px';
1415     for (var i=0; i<4; i++)
1416       this.highlightDiv[i].style.display='';
1417   },
1418
1419   HideSelection: function() {
1420     var i;
1421     if (this.options.highlightMethod!='class') {
1422       for (i=0; i<this.highlightDiv.length; i++)
1423         this.highlightDiv[i].style.display='none';
1424     }
1425     if (this.options.highlightMethod!='outline') {
1426       var cellList=this.getVisibleSelection();
1427       Rico.log("HideSelection "+cellList.length);
1428       for (i=0; i<cellList.length; i++)
1429         this.unhighlightCell(this.columns[cellList[i].column].cell(cellList[i].row));
1430     }
1431   },
1432
1433   ShowSelection: function() {
1434     if (this.options.highlightMethod!='class')
1435       this.updateSelectOutline();
1436     if (this.options.highlightMethod!='outline') {
1437       var cellList=this.getVisibleSelection();
1438       for (var i=0; i<cellList.length; i++)
1439         this.highlightCell(this.columns[cellList[i].column].cell(cellList[i].row));
1440     }
1441   },
1442
1443   ClearSelection: function() {
1444     Rico.log("ClearSelection");
1445     this.HideSelection();
1446     this.SelectIdxStart=null;
1447     this.SelectIdxEnd=null;
1448     this.SelectCtrl=[];
1449   },
1450
1451   selectCell: function(cell) {
1452     this.ClearSelection();
1453     this.SelectIdxStart=this.SelectIdxEnd=this.datasetIndex(cell);
1454     this.ShowSelection();
1455   },
1456
1457   AdjustSelection: function(cell) {
1458     var newIdx=this.datasetIndex(cell);
1459     if (this.SelectIdxStart.tabIdx != newIdx.tabIdx) return;
1460     this.HideSelection();
1461     this.SelectIdxEnd=newIdx;
1462     this.ShowSelection();
1463   },
1464
1465   RefreshSelection: function() {
1466     var cellList=this.getVisibleSelection();
1467     for (var i=0; i<cellList.length; i++) {
1468       this.columns[cellList[i].column].displayValue(cellList[i].row);
1469     }
1470   },
1471
1472   FillSelection: function(newVal,newStyle) {
1473     if (this.SelectIdxStart && this.SelectIdxEnd) {
1474       var r1=Math.min(this.SelectIdxEnd.row,this.SelectIdxStart.row);
1475       var r2=Math.max(this.SelectIdxEnd.row,this.SelectIdxStart.row);
1476       var c1=Math.min(this.SelectIdxEnd.column,this.SelectIdxStart.column);
1477       var c2=Math.max(this.SelectIdxEnd.column,this.SelectIdxStart.column);
1478       for (var r=r1; r<=r2; r++) {
1479         for (var c=c1; c<=c2; c++) {
1480           this.buffer.setValue(r,c,newVal,newStyle);
1481         }
1482       }
1483     }
1484     if (this.SelectCtrl) {
1485       for (var i=0; i<this.SelectCtrl.length; i++) {
1486         this.buffer.setValue(this.SelectCtrl[i].row,this.SelectCtrl[i].column,newVal,newStyle);
1487       }
1488     }
1489     this.RefreshSelection();
1490   },
1491
1492 /**
1493  * Process mouse down event
1494  * @param e event object
1495  */
1496   selectMouseDown: function(e) {
1497     if (this.highlightEnabled==false) return true;
1498     this.cancelMenu();
1499     var cell=Rico.eventElement(e);
1500     if (!Rico.eventLeftClick(e)) return true;
1501     cell=Rico.getParentByTagName(cell,'div','ricoLG_cell');
1502     if (!cell) return true;
1503     Rico.eventStop(e);
1504     var newIdx=this.datasetIndex(cell);
1505     if (newIdx.onBlankRow) return true;
1506     Rico.log("selectMouseDown @"+newIdx.row+','+newIdx.column);
1507     if (e.ctrlKey) {
1508       if (!this.SelectIdxStart || this.options.highlightMethod!='class') return true;
1509       if (!this.isSelected(cell)) {
1510         this.highlightCell(cell);
1511         this.SelectCtrl.push(this.datasetIndex(cell));
1512       } else {
1513         for (var i=0; i<this.SelectCtrl.length; i++) {
1514           if (this.SelectCtrl[i].row==newIdx.row && this.SelectCtrl[i].column==newIdx.column) {
1515             this.unhighlightCell(cell);
1516             this.SelectCtrl.splice(i,1);
1517             break;
1518           }
1519         }
1520       }
1521     } else if (e.shiftKey) {
1522       if (!this.SelectIdxStart) return true;
1523       this.AdjustSelection(cell);
1524     } else {
1525       this.selectCell(cell);
1526       this.pluginSelect();
1527     }
1528     return false;
1529   },
1530
1531   pluginSelect: function() {
1532     if (this.selectPluggedIn) return;
1533     var tBody=this.tbody[this.SelectIdxStart.tabIdx];
1534     Rico.eventBind(tBody,"mouseover", this.options.mouseOverHandler, false);
1535     Rico.eventBind(this.outerDiv,"mouseup",  this.options.mouseUpHandler,  false);
1536     this.selectPluggedIn=true;
1537   },
1538
1539   unplugSelect: function() {
1540     if (!this.selectPluggedIn) return;
1541     var tBody=this.tbody[this.SelectIdxStart.tabIdx];
1542     Rico.eventUnbind(tBody,"mouseover", this.options.mouseOverHandler , false);
1543     Rico.eventUnbind(this.outerDiv,"mouseup", this.options.mouseUpHandler , false);
1544     this.selectPluggedIn=false;
1545   },
1546
1547   selectMouseUp: function(e) {
1548     this.unplugSelect();
1549     var cell=Rico.eventElement(e);
1550     cell=Rico.getParentByTagName(cell,'div','ricoLG_cell');
1551     if (!cell) return;
1552     if (this.SelectIdxStart && this.SelectIdxEnd)
1553       this.AdjustSelection(cell);
1554     else
1555       this.ClearSelection();
1556   },
1557
1558   selectMouseOver: function(e) {
1559     var cell=Rico.eventElement(e);
1560     cell=Rico.getParentByTagName(cell,'div','ricoLG_cell');
1561     if (!cell) return;
1562     this.AdjustSelection(cell);
1563     Rico.eventStop(e);
1564   },
1565
1566   isSelected: function(cell) {
1567     if (this.options.highlightMethod!='outline') return Rico.hasClass(cell,this.options.highlightClass);
1568     if (!this.SelectIdxStart || !this.SelectIdxEnd) return false;
1569     var r1=Math.max(Math.min(this.SelectIdxEnd.row,this.SelectIdxStart.row), this.buffer.windowStart);
1570     var r2=Math.min(Math.max(this.SelectIdxEnd.row,this.SelectIdxStart.row), this.buffer.windowEnd-1);
1571     if (r1 > r2) return false;
1572     var c1=Math.min(this.SelectIdxEnd.column,this.SelectIdxStart.column);
1573     var c2=Math.max(this.SelectIdxEnd.column,this.SelectIdxStart.column);
1574     var curIdx=this.datasetIndex(cell);
1575     return (r1<=curIdx.row && curIdx.row<=r2 && c1<=curIdx.column && curIdx.column<=c2);
1576   },
1577
1578   highlightCell: function(cell) {
1579     Rico.addClass(cell,this.options.highlightClass);
1580   },
1581
1582   unhighlightCell: function(cell) {
1583     if (cell) Rico.removeClass(cell,this.options.highlightClass);
1584   },
1585
1586   selectRow: function(r) {
1587     for (var c=0; c<this.columns.length; c++)
1588       this.highlightCell(this.columns[c].cell(r));
1589   },
1590
1591   unselectRow: function(r) {
1592     for (var c=0; c<this.columns.length; c++)
1593       this.unhighlightCell(this.columns[c].cell(r));
1594   },
1595
1596   rowMouseOver: function(e) {
1597     if (!this.highlightEnabled) return;
1598     var cell=Rico.eventElement(e);
1599     cell=Rico.getParentByTagName(cell,'div','ricoLG_cell');
1600     if (!cell) return;
1601     var newIdx=this.winCellIndex(cell);
1602     if ((this.options.highlightSection & (newIdx.tabIdx+1))==0) return;
1603     this.highlight(newIdx);
1604   },
1605
1606   highlight: function(newIdx) {
1607     if (this.options.highlightMethod!='outline') this.cursorSetClass(newIdx);
1608     if (this.options.highlightMethod!='class') this.cursorOutline(newIdx);
1609     this.highlightIdx=newIdx;
1610   },
1611
1612   cursorSetClass: function(newIdx) {
1613     switch (this.options.highlightElem) {
1614       case 'menuCell':
1615       case 'cursorCell':
1616         if (this.highlightIdx) this.unhighlightCell(this.highlightIdx.cell);
1617         this.highlightCell(newIdx.cell);
1618         break;
1619       case 'menuRow':
1620       case 'cursorRow':
1621         if (this.highlightIdx) this.unselectRow(this.highlightIdx.row);
1622         var s1=this.options.highlightSection & 1;
1623         var s2=this.options.highlightSection & 2;
1624         var c0=s1 ? 0 : this.options.frozenColumns;
1625         var c1=s2 ? this.columns.length : this.options.frozenColumns;
1626         for (var c=c0; c<c1; c++)
1627           this.highlightCell(this.columns[c].cell(newIdx.row));
1628         break;
1629       default: return;
1630     }
1631   },
1632
1633   cursorOutline: function(newIdx) {
1634     var div;
1635     switch (this.options.highlightElem) {
1636       case 'menuCell':
1637       case 'cursorCell':
1638         div=this.highlightDiv[newIdx.tabIdx];
1639         div.style.left=(this.columns[newIdx.column].dataCell.offsetLeft-1)+'px';
1640         div.style.width=this.columns[newIdx.column].colWidth;
1641         this.highlightDiv[1-newIdx.tabIdx].style.display='none';
1642         break;
1643       case 'menuRow':
1644       case 'cursorRow':
1645         div=this.highlightDiv[0];
1646         var s1=this.options.highlightSection & 1;
1647         var s2=this.options.highlightSection & 2;
1648         div.style.left=s1 ? '0px' : this.frozenTabs.style.width;
1649         div.style.width=((s1 ? this.frozenTabs.offsetWidth : 0) + (s2 ? this.innerDiv.offsetWidth : 0) - 4)+'px';
1650         break;
1651       default: return;
1652     }
1653     div.style.top=(this.hdrHt+newIdx.row*this.rowHeight-1)+'px';
1654     div.style.height=(this.rowHeight-1)+'px';
1655     div.style.display='';
1656   },
1657
1658   unhighlight: function() {
1659     switch (this.options.highlightElem) {
1660       case 'menuCell':
1661         //this.highlightIdx=this.menuIdx;
1662         /*jsl:fallthru*/
1663       case 'cursorCell':
1664         if (this.highlightIdx) this.unhighlightCell(this.highlightIdx.cell);
1665         if (!this.highlightDiv) return;
1666         for (var i=0; i<2; i++)
1667           this.highlightDiv[i].style.display='none';
1668         break;
1669       case 'menuRow':
1670         //this.highlightIdx=this.menuIdx;
1671         /*jsl:fallthru*/
1672       case 'cursorRow':
1673         if (this.highlightIdx) this.unselectRow(this.highlightIdx.row);
1674         if (this.highlightDiv) this.highlightDiv[0].style.display='none';
1675         break;
1676     }
1677   },
1678
1679   resetContents: function() {
1680     Rico.log("resetContents");
1681     this.ClearSelection();
1682     this.buffer.clear();
1683     this.clearRows();
1684     this.clearBookmark();
1685   },
1686
1687   setImages: function() {
1688     for (var n=0; n<this.columns.length; n++)
1689       this.columns[n].setImage();
1690   },
1691
1692 /**
1693  * @return column index, or -1 if there are no sorted columns
1694  */
1695   findSortedColumn: function() {
1696     for (var n=0; n<this.columns.length; n++) {
1697       if (this.columns[n].isSorted()) return n;
1698     }
1699     return -1;
1700   },
1701
1702 /**
1703  * Searches options.columnSpecs colAttr for matching colValue
1704  * @return array of matching column indexes
1705  */
1706   findColumnsBySpec: function(colAttr, colValue) {
1707     var result=[];
1708     for (var n=0; n<this.options.columnSpecs.length; n++) {
1709       if (this.options.columnSpecs[n][colAttr] == colValue) result.push(n);
1710     }
1711     return result;
1712   },
1713
1714 /**
1715  * Set initial sort
1716  */
1717   setSortUI: function( columnIdOrNum, sortDirection ) {
1718     Rico.log("setSortUI: "+columnIdOrNum+' '+sortDirection);
1719     var colnum=this.findSortedColumn();
1720     if (colnum >= 0) {
1721       sortDirection=this.columns[colnum].getSortDirection();
1722     } else {
1723       if (typeof sortDirection!='string') {
1724         sortDirection=Rico.ColumnConst.SORT_ASC;
1725       } else {
1726         sortDirection=sortDirection.toUpperCase();
1727         if (sortDirection != Rico.ColumnConst.SORT_DESC) sortDirection=Rico.ColumnConst.SORT_ASC;
1728       }
1729       switch (typeof columnIdOrNum) {
1730         case 'string':
1731           colnum=this.findColumnsBySpec('id',columnIdOrNum);
1732           break;
1733         case 'number':
1734           colnum=columnIdOrNum;
1735           break;
1736       }
1737     }
1738     if (typeof(colnum)!='number' || colnum < 0) return;
1739     this.clearSort();
1740     this.columns[colnum].setSorted(sortDirection);
1741     this.buffer.sortBuffer(colnum);
1742   },
1743
1744 /**
1745  * clear sort flag on all columns
1746  */
1747   clearSort: function() {
1748     for (var x=0;x<this.columns.length;x++)
1749       this.columns[x].setUnsorted();
1750   },
1751
1752 /**
1753  * clear filters on all columns
1754  */
1755   clearFilters: function() {
1756     for (var x=0;x<this.columns.length;x++) {
1757       this.columns[x].setUnfiltered(true);
1758     }
1759     if (this.options.filterHandler) {
1760       this.options.filterHandler();
1761     }
1762   },
1763
1764 /**
1765  * returns number of columns with a user filter set
1766  */
1767   filterCount: function() {
1768     for (var x=0,cnt=0;x<this.columns.length;x++) {
1769       if (this.columns[x].isFiltered()) cnt++;
1770     }
1771     return cnt;
1772   },
1773
1774   sortHandler: function() {
1775     this.cancelMenu();
1776     this.ClearSelection();
1777     this.setImages();
1778     var n=this.findSortedColumn();
1779     if (n < 0) return;
1780     Rico.log("sortHandler: sorting column "+n);
1781     this.buffer.sortBuffer(n);
1782     this.clearRows();
1783     this.scrollDiv.scrollTop = 0;
1784     this.buffer.fetch(0);
1785   },
1786
1787   filterHandler: function() {
1788     Rico.log("filterHandler");
1789     this.cancelMenu();
1790     if (this.buffer.processingRequest) {
1791       this.queueFilter=true;
1792       return;
1793     }
1794     this.unplugScroll();
1795     this.ClearSelection();
1796     this.setImages();
1797     this.clearBookmark();
1798     this.clearRows();
1799     this.buffer.fetch(-1);
1800     Rico.runLater(10,this,'pluginScroll'); // resetting ht div can cause a scroll event, triggering an extra fetch
1801   },
1802
1803   clearBookmark: function() {
1804     if (this.bookmark) this.bookmark.innerHTML="&nbsp;";
1805   },
1806
1807   bookmarkHandler: function(firstrow,lastrow) {
1808     var newhtml;
1809     if (isNaN(firstrow) || !this.bookmark) return;
1810     var totrows=this.buffer.totalRows;
1811     if (totrows < lastrow) lastrow=totrows;
1812     if (totrows<=0) {
1813       newhtml = Rico.getPhraseById('bookmarkNoMatch');
1814     } else if (lastrow<0) {
1815       newhtml = Rico.getPhraseById('bookmarkNoRec');
1816     } else if (this.buffer.foundRowCount) {
1817       newhtml = Rico.getPhraseById('bookmarkExact',firstrow,lastrow,totrows);
1818     } else {
1819       newhtml = Rico.getPhraseById('bookmarkAbout',firstrow,lastrow,totrows);
1820     }
1821     this.bookmark.innerHTML = newhtml;
1822   },
1823
1824   clearRows: function() {
1825     if (this.isBlank==true) return;
1826     for (var c=0; c < this.columns.length; c++)
1827       this.columns[c].clearColumn();
1828     this.isBlank = true;
1829   },
1830
1831   refreshContents: function(startPos) {
1832     Rico.log("refreshContents1 "+this.tableId+": startPos="+startPos+" lastRow="+this.lastRowPos+" PartBlank="+this.isPartialBlank+" pageSize="+this.pageSize);
1833     this.hideMsg();
1834     this.cancelMenu();
1835     this.unhighlight(); // in case highlighting was manually invoked
1836     if (this.queueFilter) {
1837       Rico.log("refreshContents: cancelling refresh because filter has changed");
1838       this.queueFilter=false;
1839       this.filterHandler();
1840       return;
1841     }
1842     this.highlightEnabled=this.options.highlightSection!='none';
1843     var viewPrecedesBuffer = this.buffer.startPos > startPos;
1844     var contentStartPos = viewPrecedesBuffer ? this.buffer.startPos: startPos;
1845     this.contentStartPos = contentStartPos+1;
1846     var contentEndPos = Math.min(this.buffer.startPos + this.buffer.size, startPos + this.pageSize);
1847     this.buffer.setWindow(contentStartPos, contentEndPos);
1848     Rico.log('refreshContents2 '+this.tableId+': cStartPos='+contentStartPos+' cEndPos='+contentEndPos+' vPrecedesBuf='+viewPrecedesBuffer+' b.startPos='+this.buffer.startPos);
1849     if (startPos == this.lastRowPos && !this.isPartialBlank && !this.isBlank) return;
1850     this.isBlank = false;
1851     var onRefreshComplete = this.options.onRefreshComplete;
1852
1853     if ((startPos + this.pageSize < this.buffer.startPos) ||
1854         (this.buffer.startPos + this.buffer.size < startPos) ||
1855         (this.buffer.size == 0)) {
1856       this.clearRows();
1857       if (onRefreshComplete) onRefreshComplete(this.contentStartPos,contentEndPos);  // update bookmark
1858       return;
1859     }
1860
1861     Rico.log('refreshContents: contentStartPos='+contentStartPos+' contentEndPos='+contentEndPos+' viewPrecedesBuffer='+viewPrecedesBuffer);
1862     var rowSize = contentEndPos - contentStartPos;
1863     var blankSize = this.pageSize - rowSize;
1864     var blankOffset = viewPrecedesBuffer ? 0: rowSize;
1865     var contentOffset = viewPrecedesBuffer ? blankSize: 0;
1866
1867     for (var r=0; r < rowSize; r++) { //initialize what we have
1868       for (var c=0; c < this.columns.length; c++)
1869         this.columns[c].displayValue(r + contentOffset);
1870     }
1871     for (var i=0; i < blankSize; i++)     // blank out the rest
1872       this.blankRow(i + blankOffset);
1873     if (this.options.highlightElem=='selection') this.ShowSelection();
1874     this.isPartialBlank = blankSize > 0;
1875     this.lastRowPos = startPos;
1876     Rico.log("refreshContents complete, startPos="+startPos);
1877     if (onRefreshComplete) onRefreshComplete(this.contentStartPos,contentEndPos);  // update bookmark
1878   },
1879
1880   scrollToRow: function(rowOffset) {
1881      var p=this.rowToPixel(rowOffset);
1882      Rico.log("scrollToRow, rowOffset="+rowOffset+" pixel="+p);
1883      this.scrollDiv.scrollTop = p; // this causes a scroll event
1884      if ( this.options.onscroll )
1885         this.options.onscroll( this, rowOffset );
1886   },
1887
1888   scrollUp: function() {
1889      this.moveRelative(-1);
1890   },
1891
1892   scrollDown: function() {
1893      this.moveRelative(1);
1894   },
1895
1896   pageUp: function() {
1897      this.moveRelative(-this.pageSize);
1898   },
1899
1900   pageDown: function() {
1901      this.moveRelative(this.pageSize);
1902   },
1903
1904   adjustRow: function(rowOffset) {
1905      var notdisp=this.topOfLastPage();
1906      if (notdisp == 0 || !rowOffset) return 0;
1907      return Math.min(notdisp,rowOffset);
1908   },
1909
1910   rowToPixel: function(rowOffset) {
1911      return this.adjustRow(rowOffset) * this.rowHeight;
1912   },
1913
1914 /**
1915  * @returns row to display at top of scroll div
1916  */
1917   pixeltorow: function(p) {
1918      var notdisp=this.topOfLastPage();
1919      if (notdisp == 0) return 0;
1920      var prow=parseInt(p/this.rowHeight,10);
1921      return Math.min(notdisp,prow);
1922   },
1923
1924   moveRelative: function(relOffset) {
1925      var newoffset=Math.max(this.scrollDiv.scrollTop+relOffset*this.rowHeight,0);
1926      newoffset=Math.min(newoffset,this.scrollDiv.scrollHeight);
1927      //Rico.log("moveRelative, newoffset="+newoffset);
1928      this.scrollDiv.scrollTop=newoffset;
1929   },
1930
1931   pluginScroll: function() {
1932      if (this.scrollPluggedIn) return;
1933      Rico.log("pluginScroll: wheelEvent="+this.wheelEvent);
1934      Rico.eventBind(this.scrollDiv,"scroll",this.scrollEventFunc, false);
1935      for (var t=0; t<2; t++)
1936        Rico.eventBind(this.tabs[t],this.wheelEvent,this.wheelEventFunc, false);
1937      this.scrollPluggedIn=true;
1938   },
1939
1940   unplugScroll: function() {
1941      if (!this.scrollPluggedIn) return;
1942      Rico.log("unplugScroll");
1943      Rico.eventUnbind(this.scrollDiv,"scroll", this.scrollEventFunc , false);
1944      for (var t=0; t<2; t++)
1945        Rico.eventUnbind(this.tabs[t],this.wheelEvent,this.wheelEventFunc, false);
1946      this.scrollPluggedIn=false;
1947   },
1948
1949   handleWheel: function(e) {
1950     var delta = 0;
1951     if (e.wheelDelta) {
1952       if (Rico.isOpera)
1953         delta = e.wheelDelta/120;
1954       else if (Rico.isWebKit)
1955         delta = -e.wheelDelta/12;
1956       else
1957         delta = -e.wheelDelta/120;
1958     } else if (e.detail) {
1959       delta = e.detail/3; /* Mozilla/Gecko */
1960     }
1961     if (delta) this.moveRelative(delta);
1962     Rico.eventStop(e);
1963     return false;
1964   },
1965
1966   handleScroll: function(e) {
1967      if ( this.scrollTimeout )
1968        clearTimeout( this.scrollTimeout );
1969      this.setHorizontalScroll();
1970      var scrtop=this.scrollDiv.scrollTop;
1971      var vscrollDiff = this.lastScrollPos-scrtop;
1972      if (vscrollDiff == 0.00) return;
1973      var newrow=this.pixeltorow(scrtop);
1974      if (newrow == this.lastRowPos && !this.isPartialBlank && !this.isBlank) return;
1975      var stamp1 = new Date();
1976      Rico.log("handleScroll, newrow="+newrow+" scrtop="+scrtop);
1977      if (this.options.highlightElem=='selection') this.HideSelection();
1978      this.buffer.fetch(newrow);
1979      if (this.options.onscroll) this.options.onscroll(this, newrow);
1980      this.scrollTimeout = Rico.runLater(1200,this,'scrollIdle');
1981      this.lastScrollPos = this.scrollDiv.scrollTop;
1982      var stamp2 = new Date();
1983      //Rico.log("handleScroll, time="+(stamp2.getTime()-stamp1.getTime()));
1984   },
1985
1986   scrollIdle: function() {
1987      if ( this.options.onscrollidle )
1988         this.options.onscrollidle();
1989   }
1990
1991 };
1992
1993
1994 Rico.LiveGridColumn = function(grid,colIdx,hdrInfo,tabIdx) {
1995   this.initialize(grid,colIdx,hdrInfo,tabIdx);
1996 };
1997
1998 Rico.LiveGridColumn.prototype = 
1999 /** @lends Rico.LiveGridColumn# */
2000 {
2001 /**
2002  * Implements a LiveGrid column. Also contains static properties used by SimpleGrid columns.
2003  * @extends Rico.TableColumnBase
2004  * @constructs
2005  */
2006 initialize: function(liveGrid,colIdx,hdrInfo,tabIdx) {
2007   Rico.extend(this, new Rico.TableColumnBase());
2008   this.baseInit(liveGrid,colIdx,hdrInfo,tabIdx);
2009   this.buffer=liveGrid.buffer;
2010   if (typeof(this.format.type)!='string' || this.format.EntryType=='tinyMCE') this.format.type='html';
2011   if (typeof this.isNullable!='boolean') this.isNullable = /number|date/.test(this.format.type);
2012   this.isText = /html|text/.test(this.format.type);
2013   Rico.log(" sortable="+this.sortable+" filterable="+this.filterable+" hideable="+this.hideable+" isNullable="+this.isNullable+' isText='+this.isText);
2014   this.fixHeaders(this.liveGrid.tableId, this.options.hdrIconsFirst);
2015   if (this['format_'+this.format.type]) {
2016     this._format=this['format_'+this.format.type];
2017   }
2018   if (this.format.control) {
2019     // copy all properties/methods that start with '_'
2020     if (typeof this.format.control=='string') {
2021       this.format.control=eval(this.format.control);
2022     }
2023     for (var property in this.format.control) {
2024       if (property.charAt(0)=='_') {
2025         Rico.log("Copying control property "+property+ ' to ' + this);
2026         this[property] = this.format.control[property];
2027       }
2028     }
2029   }
2030 },
2031
2032 /**
2033  * Sorts the column in ascending order
2034  */
2035 sortAsc: function() {
2036   this.setColumnSort(Rico.ColumnConst.SORT_ASC);
2037 },
2038
2039 /**
2040  * Sorts the column in descending order
2041  */
2042 sortDesc: function() {
2043   this.setColumnSort(Rico.ColumnConst.SORT_DESC);
2044 },
2045
2046 /**
2047  * Sorts the column in the specified direction
2048  * @param direction must be one of Rico.ColumnConst.UNSORTED, .SORT_ASC, or .SORT_DESC
2049  */
2050 setColumnSort: function(direction) {
2051   this.liveGrid.clearSort();
2052   this.setSorted(direction);
2053   if (this.liveGrid.options.saveColumnInfo.sort)
2054     this.liveGrid.setCookie();
2055   if (this.options.sortHandler)
2056     this.options.sortHandler();
2057 },
2058
2059 /**
2060  * @returns true if this column is allowed to be sorted
2061  */
2062 isSortable: function() {
2063   return this.sortable;
2064 },
2065
2066 /**
2067  * @returns true if this column is currently sorted
2068  */
2069 isSorted: function() {
2070   return this.currentSort != Rico.ColumnConst.UNSORTED;
2071 },
2072
2073 /**
2074  * @returns Rico.ColumnConst.UNSORTED, .SORT_ASC, or .SORT_DESC
2075  */
2076 getSortDirection: function() {
2077   return this.currentSort;
2078 },
2079
2080 /**
2081  * toggle the sort sequence for this column
2082  */
2083 toggleSort: function() {
2084   if (this.buffer && this.buffer.totalRows==0) return;
2085   if (this.currentSort == Rico.ColumnConst.SORT_ASC)
2086     this.sortDesc();
2087   else
2088     this.sortAsc();
2089 },
2090
2091 /**
2092  * Flags that this column is not sorted
2093  */
2094 setUnsorted: function() {
2095   this.setSorted(Rico.ColumnConst.UNSORTED);
2096 },
2097
2098 /**
2099  * Flags that this column is sorted, but doesn't actually carry out the sort
2100  * @param direction must be one of Rico.ColumnConst.UNSORTED, .SORT_ASC, or .SORT_DESC
2101  */
2102 setSorted: function(direction) {
2103   this.currentSort = direction;
2104 },
2105
2106 /**
2107  * @returns true if this column is allowed to be filtered
2108  */
2109 canFilter: function() {
2110   return this.filterable;
2111 },
2112
2113 /**
2114  * @returns a textual representation of how this column is filtered
2115  */
2116 getFilterText: function() {
2117   var vals=[];
2118   for (var i=0; i<this.filterValues.length; i++) {
2119     var v=this.filterValues[i];
2120     vals.push(v=='' ? Rico.getPhraseById('filterBlank') : v);
2121   }
2122   switch (this.filterOp) {
2123     case 'EQ':   return '= '+vals.join(', ');
2124     case 'NE':   return Rico.getPhraseById('filterNot',vals.join(', '));
2125     case 'LT':   return '< '+vals[0];
2126     case 'GT':   return '> '+vals[0];
2127     case 'LE':   return '<= '+vals[0];
2128     case 'GE':   return '>= '+vals[0];
2129     case 'LIKE': return Rico.getPhraseById('filterLike',vals[0]);
2130     case 'NULL': return Rico.getPhraseById('filterEmpty');
2131     case 'NOTNULL': return Rico.getPhraseById('filterNotEmpty');
2132   }
2133   return '?';
2134 },
2135
2136 /**
2137  * @returns returns the query string representation of the filter
2138  */
2139 getFilterQueryParm: function() {
2140   if (this.filterType == Rico.ColumnConst.UNFILTERED) return '';
2141   var retval='&f['+this.index+'][op]='+this.filterOp;
2142   retval+='&f['+this.index+'][len]='+this.filterValues.length;
2143   for (var i=0; i<this.filterValues.length; i++) {
2144     retval+='&f['+this.index+']['+i+']='+escape(this.filterValues[i]);
2145   }
2146   return retval;
2147 },
2148
2149 /**
2150  * removes the filter from this column
2151  */
2152 setUnfiltered: function(skipHandler) {
2153   this.filterType = Rico.ColumnConst.UNFILTERED;
2154   if (this.liveGrid.options.saveColumnInfo.filter)
2155     this.liveGrid.setCookie();
2156   if (this.removeFilterFunc)
2157     this.removeFilterFunc();
2158   if (this.options.filterHandler && !skipHandler)
2159     this.options.filterHandler();
2160 },
2161
2162 setFilterEQ: function() {
2163   this.setUserFilter('EQ');
2164 },
2165 setFilterNE: function() {
2166   this.setUserFilter('NE');
2167 },
2168 addFilterNE: function() {
2169   this.filterValues.push(this.userFilter);
2170   if (this.liveGrid.options.saveColumnInfo.filter)
2171     this.liveGrid.setCookie();
2172   if (this.options.filterHandler)
2173     this.options.filterHandler();
2174 },
2175 setFilterGE: function() { this.setUserFilter('GE'); },
2176 setFilterLE: function() { this.setUserFilter('LE'); },
2177 setFilterKW: function(keyword) {
2178   if (keyword!='' && keyword!=null) {
2179     this.setFilter('LIKE',keyword,Rico.ColumnConst.USERFILTER);
2180   } else {
2181     this.setUnfiltered(false);
2182   }
2183 },
2184
2185 setUserFilter: function(relop) {
2186   this.setFilter(relop,this.userFilter,Rico.ColumnConst.USERFILTER);
2187 },
2188
2189 setSystemFilter: function(relop,filter) {
2190   this.setFilter(relop,filter,Rico.ColumnConst.SYSTEMFILTER);
2191 },
2192
2193 setFilter: function(relop,filter,type,removeFilterFunc) {
2194   this.filterValues = typeof(filter)=='object' ? filter : [filter];
2195   this.filterType = type;
2196   this.filterOp = relop;
2197   if (type == Rico.ColumnConst.USERFILTER && this.liveGrid.options.saveColumnInfo.filter)
2198     this.liveGrid.setCookie();
2199   this.removeFilterFunc=removeFilterFunc;
2200   if (this.options.filterHandler)
2201     this.options.filterHandler();
2202 },
2203
2204 isFiltered: function() {
2205   return this.filterType == Rico.ColumnConst.USERFILTER;
2206 },
2207
2208 filterChange: function(e) {
2209   var selbox=Rico.eventElement(e);
2210   if (selbox.value==this.liveGrid.options.FilterAllToken)
2211     this.setUnfiltered();
2212   else
2213     this.setFilter('EQ',selbox.value,Rico.ColumnConst.USERFILTER,function() {selbox.selectedIndex=0;});
2214 },
2215
2216 nFilterChange: function(e) {
2217   var selbox=Rico.eventElement(e);
2218   if (selbox.value==this.liveGrid.options.FilterAllToken) {
2219     this.setUnfiltered();
2220   } else {
2221     var op=selbox.value.substr(0,2);
2222     var value=selbox.value.substr(2);
2223     this.setFilter(op,value,Rico.ColumnConst.USERFILTER,function() {selbox.selectedIndex=0;});
2224   }
2225 },
2226
2227 filterClear: function(e) {\r
2228   this.filterField.value='';
2229   this.setUnfiltered();\r
2230 },
2231
2232 filterKeypress: function(e) {\r
2233   var txtbox=Rico.eventElement(e);
2234   if (typeof this.lastKeyFilter != 'string') this.lastKeyFilter='';\r
2235   if (this.lastKeyFilter==txtbox.value) return;\r
2236   var v=txtbox.value;\r
2237   Rico.log("filterKeypress: "+this.index+' '+v);\r
2238   this.lastKeyFilter=v;
2239   if (v=='' || v=='*')\r
2240     this.setUnfiltered();\r
2241   else {
2242     this.setFilter('LIKE', v, Rico.ColumnConst.USERFILTER, function() {txtbox.value='';});
2243   }\r
2244 },\r
2245
2246 mFilterSelectClick: function(e) {
2247   Rico.eventStop(e);
2248   if (this.mFilter.style.display!='none') {
2249     this.mFilterFinish(e);
2250     if (Rico.isIE && Rico.ieVersion <= 6) {
2251       this.filterField.focus();
2252     } else {
2253       this.filterField.blur();
2254     }
2255   } else {
2256     var offset=Rico.cumulativeOffset(this.filterField);
2257     this.mFilter.style.top=(offset.top+this.filterField.offsetHeight)+'px';
2258     this.mFilter.style.left=offset.left+'px';
2259     this.mFilter.style.width=Math.min(this.filterField.offsetWidth,parseInt(this.colWidth,10))+'px';
2260     Rico.show(this.mFilter);
2261     this.mFilterFocus.focus();
2262   }
2263 },
2264
2265 mFilterFinish: function(e) {
2266   if (!this.mFilterChange) {
2267     Rico.hide(this.mFilter);
2268     return;
2269   }
2270   if (this.mFilterInputs[0].checked) {
2271     this.mFilterReset();
2272     Rico.hide(this.mFilter);
2273     this.setUnfiltered();
2274     return;
2275   }
2276   var newValues=[];
2277   var newLabels=[];
2278   for (var i=1; i<this.mFilterInputs.length; i++) {
2279     if (this.mFilterInputs[i].checked) {
2280       newValues.push(this.mFilterInputs[i].value)
2281       newLabels.push(this.mFilterLabels[i].innerHTML)
2282     }
2283   }
2284   if (newValues.length > 0) {
2285     var newText=newLabels.join(', ');
2286     this.filterField.options[0].text=newText;
2287     this.filterField.title=newText;
2288     Rico.hide(this.mFilter);
2289     this.mFilterChange=false;
2290     var self=this;
2291     this.setFilter('EQ',newValues,Rico.ColumnConst.USERFILTER,function() { self.mFilterReset(); });
2292   } else {
2293     alert('Please select at least one value');
2294   }
2295 },
2296
2297 mFilterReset: function() {
2298   var newText=this.mFilterLabels[0].innerHTML;  // all
2299   this.filterField.options[0].text=newText;
2300   this.filterField.title=newText;
2301 },
2302
2303 mFilterAllClick: function(e) {
2304   var allChecked=this.mFilterInputs[0].checked;
2305   for (var i=1; i<this.mFilterInputs.length; i++) {
2306     this.mFilterInputs[i].checked=allChecked;
2307   }
2308   this.mFilterChange=true;
2309 },
2310
2311 mFilterOtherClick: function(e) {
2312   this.mFilterInputs[0].checked=false;
2313   this.mFilterChange=true;
2314 },
2315
2316 format_text: function(v) {
2317   if (typeof v!='string')
2318     return '&nbsp;';
2319   else
2320     return v.replace(/&/g, '&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
2321 },
2322
2323 format_number: function(v) {
2324   if (typeof v=='undefined' || v=='' || v==null)
2325     return '&nbsp;';
2326   else
2327     return Rico.formatNumber(v,this.format);
2328 },
2329
2330 format_datetime: function(v) {
2331   if (typeof v=='undefined' || v=='' || v==null)
2332     return '&nbsp;';
2333   else {
2334     var d=Rico.setISO8601(v);
2335     if (!d) return v;
2336     return (this.format.prefix || '')+Rico.formatDate(d,this.format.dateFmt || 'translateDateTime')+(this.format.suffix || '');
2337   }
2338 },
2339
2340 // converts GMT/UTC to local time
2341 format_utcaslocaltime: function(v) {
2342   if (typeof v=='undefined' || v=='' || v==null)
2343     return '&nbsp;';
2344   else {
2345     var tz=new Date();
2346     var d=Rico.setISO8601(v,-tz.getTimezoneOffset());
2347     if (!d) return v;
2348     return (this.format.prefix || '')+Rico.formatDate(d,this.format.dateFmt || 'translateDateTime')+(this.format.suffix || '');
2349   }
2350 },
2351
2352 format_date: function(v) {
2353   if (typeof v=='undefined' || v==null || v=='')
2354     return '&nbsp;';
2355   else {
2356     var d=Rico.setISO8601(v);
2357     if (!d) return v;
2358     return (this.format.prefix || '')+Rico.formatDate(d,this.format.dateFmt || 'translateDate')+(this.format.suffix || '');
2359   }
2360 },
2361
2362 fixHeaders: function(prefix, iconsfirst) {
2363   if (this.sortable) {
2364     var handler=Rico.eventHandle(this,'toggleSort');
2365     switch (this.options.headingSort) {
2366       case 'link':
2367         var a=Rico.wrapChildren(this.hdrCellDiv,'ricoSort',undefined,'a');
2368         a.href = "javascript:void(0)";
2369         Rico.eventBind(a,"click", handler);
2370         break;
2371       case 'hover':
2372         Rico.eventBind(this.hdrCellDiv,"click", handler);
2373         break;
2374     }
2375   }
2376   this.imgFilter = document.createElement('span');
2377   this.imgFilter.style.display='none';
2378   this.imgFilter.className='rico-icon ricoLG_filterCol';
2379   this.imgSort = document.createElement('span');
2380   this.imgSort.style.display='none';
2381   this.imgSort.style.verticalAlign='top';
2382   if (iconsfirst) {
2383     this.hdrCellDiv.insertBefore(this.imgSort,this.hdrCellDiv.firstChild);
2384     this.hdrCellDiv.insertBefore(this.imgFilter,this.hdrCellDiv.firstChild);
2385   } else {
2386     this.hdrCellDiv.appendChild(this.imgFilter);
2387     this.hdrCellDiv.appendChild(this.imgSort);
2388   }
2389   if (!this.format.filterUI) {
2390     Rico.eventBind(this.imgFilter, 'click', Rico.eventHandle(this,'filterClick'), false);
2391   }
2392 },
2393
2394 filterClick: function(e) {
2395   if (this.filterType==Rico.ColumnConst.USERFILTER && this.filterOp=='LIKE') {
2396     this.liveGrid.openKeyword(this.index);
2397   }
2398 },
2399
2400 getValue: function(windowRow) {
2401   return this.buffer.getWindowCell(windowRow,this.index);
2402 },
2403
2404 getBufferStyle: function(windowRow) {
2405   return this.buffer.getWindowStyle(windowRow,this.index);
2406 },
2407
2408 setValue: function(windowRow,newval) {
2409   this.buffer.setWindowValue(windowRow,this.index,newval);
2410 },
2411
2412 _format: function(v) {
2413   return v;
2414 },
2415
2416 _display: function(v,gridCell) {
2417   gridCell.innerHTML=this._format(v);
2418 },
2419
2420 _export: function(v) {
2421   return this._format(v);
2422 },
2423
2424 exportBuffer: function(bufRow) {
2425   return this._export(this.buffer.getValue(bufRow,this.index));
2426 },
2427
2428 displayValue: function(windowRow) {
2429   var bufval=this.getValue(windowRow);
2430   if (bufval==null) {
2431     this.clearCell(windowRow);
2432     return;
2433   }
2434   var gridCell=this.cell(windowRow);
2435   this._display(bufval,gridCell,windowRow);
2436   if (this.buffer.options.acceptStyle) {
2437     gridCell.style.cssText=this.getBufferStyle(windowRow);
2438   }
2439 }
2440
2441 };