?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Deleting the check_defaults test from 19_STABLE. MDL-14854
[moodle-linuxchix.git] / lib / yui / datatable / datatable-beta.js
blobb56afe45a1c21d8462748e609c8cef7057d1d0ad
1 /*
2 Copyright (c) 2007, Yahoo! Inc. All rights reserved.
3 Code licensed under the BSD License:
4 http://developer.yahoo.net/yui/license.txt
5 version: 2.3.0
6 */
7 /**
8 * The DataTable widget provides a progressively enhanced DHTML control for
9 * displaying tabular data across A-grade browsers.
10 *
11 * @module datatable
12 * @requires yahoo, dom, event, datasource
13 * @optional dragdrop
14 * @title DataTable Widget
15 * @beta
16 */
17
18 /****************************************************************************/
19 /****************************************************************************/
20 /****************************************************************************/
21
22 /**
23 * DataTable class for the YUI DataTable widget.
24 *
25 * @namespace YAHOO.widget
26 * @class DataTable
27 * @uses YAHOO.util.EventProvider
28 * @constructor
29 * @param elContainer {HTMLElement} Container element for the TABLE.
30 * @param aColumnDefs {Object[]} Array of object literal Column definitions.
31 * @param oDataSource {YAHOO.util.DataSource} DataSource instance.
32 * @param oConfigs {object} (optional) Object literal of configuration values.
33 */
34 YAHOO.widget.DataTable = function(elContainer,aColumnDefs,oDataSource,oConfigs) {
35 // Internal vars
36 this._nIndex = YAHOO.widget.DataTable._nCount;
37 this._sName = "instance" + this._nIndex;
38 this.id = "yui-dt"+this._nIndex;
39
40 // Initialize container element
41 this._initContainerEl(elContainer);
42 if(!this._elContainer) {
43 return;
44 }
45
46 // Initialize configs
47 this._initConfigs(oConfigs);
48
49 // Initialize ColumnSet
50 this._initColumnSet(aColumnDefs);
51 if(!this._oColumnSet) {
52 return;
53 }
54
55 // Initialize RecordSet
56 this._initRecordSet();
57 if(!this._oRecordSet) {
58 return;
59 }
60
61 // Initialize DataSource
62 this._initDataSource(oDataSource);
63 if(!this._oDataSource) {
64 return;
65 }
66
67 // Progressive enhancement special case
68 if(this._oDataSource.dataType == YAHOO.util.DataSource.TYPE_HTMLTABLE) {
69 this._oDataSource.sendRequest(this.get("initialRequest"), this._onDataReturnEnhanceTable, this);
70 }
71 else {
72 // Initialize DOM elements
73 this._initTableEl();
74 if(!this._elTable || !this._elThead || !this._elTbody) {
75 return;
76 }
77
78 // Call Element's constructor after DOM elements are created
79 // but *before* table is populated with data
80 YAHOO.widget.DataTable.superclass.constructor.call(this, this._elContainer, this._oConfigs);
81
82 //HACK: Set the Paginator values here via updatePaginator
83 if(this._oConfigs && this._oConfigs.paginator) {
84 this.updatePaginator(this._oConfigs.paginator);
85 }
86
87 // Send out for data in an asynchronous request
88 this._oDataSource.sendRequest(this.get("initialRequest"), this.onDataReturnInitializeTable, this);
89 }
90
91 // Initialize inline Cell editing
92 this._initCellEditorEl();
93
94 // Initialize Column sort
95 this._initColumnSort();
96
97 // Initialize DOM event listeners
98 this._initDomEvents();
99
100 YAHOO.widget.DataTable._nCount++;
101 };
102
103 if(YAHOO.util.Element) {
104 YAHOO.lang.extend(YAHOO.widget.DataTable, YAHOO.util.Element);
105 }
106 else {
107 }
108
109 /////////////////////////////////////////////////////////////////////////////
110 //
111 // Superclass methods
112 //
113 /////////////////////////////////////////////////////////////////////////////
114
115 /**
116 * Implementation of Element's abstract method. Sets up config values.
117 *
118 * @method initAttributes
119 * @param oConfigs {Object} (Optional) Object literal definition of configuration values.
120 * @private
121 */
122
123 YAHOO.widget.DataTable.prototype.initAttributes = function(oConfigs) {
124 oConfigs = oConfigs || {};
125 YAHOO.widget.DataTable.superclass.initAttributes.call(this, oConfigs);
126
127 /**
128 * @config summary
129 * @description Value for the SUMMARY attribute.
130 * @type String
131 */
132 this.setAttributeConfig("summary", {
133 value: null,
134 validator: YAHOO.lang.isString,
135 method: function(sSummary) {
136 this._elTable.summary = sSummary;
137 }
138 });
139
140 /**
141 * @config selectionMode
142 * @description Specifies row or cell selection mode. Accepts the following strings:
143 * <dl>
144 * <dt>"standard"</dt>
145 * <dd>Standard row selection with support for modifier keys to enable
146 * multiple selections.</dd>
147 *
148 * <dt>"single"</dt>
149 * <dd>Row selection with modifier keys disabled to not allow
150 * multiple selections.</dd>
151 *
152 * <dt>"singlecell"</dt>
153 * <dd>Cell selection with modifier keys disabled to not allow
154 * multiple selections.</dd>
155 *
156 * <dt>"cellblock"</dt>
157 * <dd>Cell selection with support for modifier keys to enable multiple
158 * selections in a block-fashion, like a spreadsheet.</dd>
159 *
160 * <dt>"cellrange"</dt>
161 * <dd>Cell selection with support for modifier keys to enable multiple
162 * selections in a range-fashion, like a calendar.</dd>
163 * </dl>
164 *
165 * @default "standard"
166 * @type String
167 */
168 this.setAttributeConfig("selectionMode", {
169 value: "standard",
170 validator: YAHOO.lang.isString
171 });
172
173 /**
174 * @config initialRequest
175 * @description Defines the initial request that gets sent to the DataSource.
176 * @type String
177 */
178 this.setAttributeConfig("initialRequest", {
179 value: "",
180 validator: YAHOO.lang.isString
181 });
182
183 /**
184 * @config sortedBy
185 * @description Object literal provides metadata for initial sort values if
186 * data will arrive pre-sorted:
187 * <dl>
188 * <dt>sortedBy.key</dt>
189 * <dd>Key of sorted Column</dd>
190 * <dt>sortedBy.dir</dt>
191 * <dd>Initial sort direction, either "asc" or "desc"</dd>
192 * </dl>
193 * @type Object
194 */
195 this.setAttributeConfig("sortedBy", {
196 value: null,
197 // TODO: accepted array for nested sorts
198 validator: function(oNewSortedBy) {
199 return (oNewSortedBy && (oNewSortedBy.constructor == Object) && oNewSortedBy.key);
200 },
201 method: function(oNewSortedBy) {
202 // Remove ASC/DESC from TH
203 var oOldSortedBy = this.get("sortedBy");
204 if(oOldSortedBy && (oOldSortedBy.constructor == Object) && oOldSortedBy.key) {
205 var oldColumn = this._oColumnSet.getColumn(oOldSortedBy.key);
206 var oldThEl = this.getThEl(oldColumn);
207 YAHOO.util.Dom.removeClass(oldThEl, YAHOO.widget.DataTable.CLASS_ASC);
208 YAHOO.util.Dom.removeClass(oldThEl, YAHOO.widget.DataTable.CLASS_DESC);
209 }
210
211 // Set ASC/DESC on TH
212 var column = (oNewSortedBy.column) ? oNewSortedBy.column : this._oColumnSet.getColumn(oNewSortedBy.key);
213 if(column) {
214 var newClass = (oNewSortedBy.dir && (oNewSortedBy.dir != "asc")) ?
215 YAHOO.widget.DataTable.CLASS_DESC :
216 YAHOO.widget.DataTable.CLASS_ASC;
217 YAHOO.util.Dom.addClass(this.id + "-col" + column.getId(), newClass);
218 }
219 }
220 });
221
222 /**
223 * @config paginator
224 * @description Object literal of pagination values.
225 * @default <br>
226 * { containers:[], // UI container elements <br>
227 * rowsPerPage:500, // 500 rows <br>
228 * currentPage:1, // page one <br>
229 * pageLinks:0, // show all links <br>
230 * pageLinksStart:1, // first link is page 1 <br>
231 * dropdownOptions:null, // no dropdown <br>
232 * links: [], // links elements <br>
233 * dropdowns: [] } //dropdown elements
234 *
235 * @type Object
236 */
237 this.setAttributeConfig("paginator", {
238 value: {
239 rowsPerPage:500, // 500 rows per page
240 currentPage:1, // show page one
241 startRecordIndex:0, // start with first Record
242 totalRecords:0, // how many Records total
243 totalPages:0, // how many pages total
244 rowsThisPage:0, // how many rows this page
245 pageLinks:0, // show all links
246 pageLinksStart:1, // first link is page 1
247 dropdownOptions: null, //no dropdown
248 containers:[], // Paginator container element references
249 dropdowns: [], //dropdown element references,
250 links: [] // links elements
251 },
252 validator: function(oNewPaginator) {
253 if(oNewPaginator && (oNewPaginator.constructor == Object)) {
254 // Check for incomplete set of values
255 if((oNewPaginator.rowsPerPage !== undefined) &&
256 (oNewPaginator.currentPage !== undefined) &&
257 (oNewPaginator.startRecordIndex !== undefined) &&
258 (oNewPaginator.totalRecords !== undefined) &&
259 (oNewPaginator.totalPages !== undefined) &&
260 (oNewPaginator.rowsThisPage !== undefined) &&
261 (oNewPaginator.pageLinks !== undefined) &&
262 (oNewPaginator.pageLinksStart !== undefined) &&
263 (oNewPaginator.dropdownOptions !== undefined) &&
264 (oNewPaginator.containers !== undefined) &&
265 (oNewPaginator.dropdowns !== undefined) &&
266 (oNewPaginator.links !== undefined)) {
267
268 // Validate each value
269 if(YAHOO.lang.isNumber(oNewPaginator.rowsPerPage) &&
270 YAHOO.lang.isNumber(oNewPaginator.currentPage) &&
271 YAHOO.lang.isNumber(oNewPaginator.startRecordIndex) &&
272 YAHOO.lang.isNumber(oNewPaginator.totalRecords) &&
273 YAHOO.lang.isNumber(oNewPaginator.totalPages) &&
274 YAHOO.lang.isNumber(oNewPaginator.rowsThisPage) &&
275 YAHOO.lang.isNumber(oNewPaginator.pageLinks) &&
276 YAHOO.lang.isNumber(oNewPaginator.pageLinksStart) &&
277 YAHOO.lang.isArray(oNewPaginator.dropdownOptions) &&
278 YAHOO.lang.isArray(oNewPaginator.containers) &&
279 YAHOO.lang.isArray(oNewPaginator.dropdowns) &&
280 YAHOO.lang.isArray(oNewPaginator.links)) {
281 return true;
282 }
283 }
284 }
285 return false;
286 }
287 });
288
289 /**
290 * @config paginated
291 * @description True if built-in client-side pagination is enabled
292 * @default false
293 * @type Boolean
294 */
295 this.setAttributeConfig("paginated", {
296 value: false,
297 validator: YAHOO.lang.isBoolean,
298 method: function(oParam) {
299 var oPaginator = this.get("paginator");
300 var aContainerEls = oPaginator.containers;
301
302 // Paginator is enabled
303 if(oParam) {
304 // No containers found, create two from scratch
305 if(aContainerEls.length === 0) {
306 // One before TABLE
307 var pag0 = document.createElement("span");
308 pag0.id = this.id + "-paginator0";
309 YAHOO.util.Dom.addClass(pag0, YAHOO.widget.DataTable.CLASS_PAGINATOR);
310 pag0 = this._elContainer.insertBefore(pag0, this._elTable);
311 aContainerEls.push(pag0);
312
313 // One after TABLE
314 var pag1 = document.createElement("span");
315 pag1.id = this.id + "-paginator1";
316 YAHOO.util.Dom.addClass(pag1, YAHOO.widget.DataTable.CLASS_PAGINATOR);
317 pag1 = this._elContainer.insertBefore(pag1, this._elTable.nextSibling);
318 aContainerEls.push(pag1);
319
320 // Add containers directly to tracker
321 this._configs.paginator.value.containers = [pag0, pag1];
322
323 }
324 else {
325 // Show each container
326 for(var i=0; i<aContainerEls.length; i++) {
327 aContainerEls[i].style.display = "";
328 }
329 }
330
331 // Links are enabled
332 if(oPaginator.pageLinks > -1) {
333 var aLinkEls = oPaginator.links;
334 // No links containers found, create from scratch
335 if(aLinkEls.length === 0) {
336 for(i=0; i<aContainerEls.length; i++) {
337 // Create one links container per Paginator container
338 var linkEl = document.createElement("span");
339 linkEl.id = "yui-dt-pagselect"+i;
340 linkEl = aContainerEls[i].appendChild(linkEl);
341
342 // Add event listener
343 //TODO: anon fnc
344 YAHOO.util.Event.addListener(linkEl,"click",this._onPaginatorLinkClick,this);
345
346 // Add directly to tracker
347 this._configs.paginator.value.links.push(linkEl);
348 }
349 }
350 }
351
352 // Show these options in the dropdown
353 var dropdownOptions = oPaginator.dropdownOptions || [];
354
355 for(i=0; i<aContainerEls.length; i++) {
356 // Create one SELECT element per Paginator container
357 var selectEl = document.createElement("select");
358 YAHOO.util.Dom.addClass(selectEl, YAHOO.widget.DataTable.CLASS_DROPDOWN);
359 selectEl = aContainerEls[i].appendChild(selectEl);
360 selectEl.id = "yui-dt-pagselect"+i;
361
362 // Add event listener
363 //TODO: anon fnc
364 YAHOO.util.Event.addListener(selectEl,"change",this._onPaginatorDropdownChange,this);
365
366 // Add DOM reference directly to tracker
367 this._configs.paginator.value.dropdowns.push(selectEl);
368
369 // Hide dropdown
370 if(!oPaginator.dropdownOptions) {
371 selectEl.style.display = "none";
372 }
373 }
374
375 //TODO: fire paginatorDisabledEvent & add to api doc
376 }
377 // Pagination is disabled
378 else {
379 // Containers found
380 if(aContainerEls.length > 0) {
381 // Destroy or just hide?
382
383 // Hide each container
384 for(i=0; i<aContainerEls.length; i++) {
385 aContainerEls[i].style.display = "none";
386 }
387
388 /*TODO?
389 // Destroy each container
390 for(i=0; i<aContainerEls.length; i++) {
391 YAHOO.util.Event.purgeElement(aContainerEls[i], true);
392 aContainerEls.innerHTML = null;
393 //TODO: remove container?
394 // aContainerEls[i].parentNode.removeChild(aContainerEls[i]);
395 }
396 */
397 }
398 //TODO: fire paginatorDisabledEvent & add to api doc
399 }
400 }
401 });
402
403 /**
404 * @config caption
405 * @description Value for the CAPTION element.
406 * @type String
407 */
408 this.setAttributeConfig("caption", {
409 value: null,
410 validator: YAHOO.lang.isString,
411 method: function(sCaption) {
412 // Create CAPTION element
413 if(!this._elCaption) {
414 if(!this._elTable.firstChild) {
415 this._elCaption = this._elTable.appendChild(document.createElement("caption"));
416 }
417 else {
418 this._elCaption = this._elTable.insertBefore(document.createElement("caption"), this._elTable.firstChild);
419 }
420 }
421 // Set CAPTION value
422 this._elCaption.innerHTML = sCaption;
423 }
424 });
425
426 /**
427 * @config scrollable
428 * @description True if primary TBODY should scroll while THEAD remains fixed.
429 * When enabling this feature, captions cannot be used, and the following
430 * features are not recommended: inline editing, resizeable columns.
431 * @default false
432 * @type Boolean
433 */
434 this.setAttributeConfig("scrollable", {
435 value: false,
436 validator: function(oParam) {
437 //TODO: validate agnst resizeable
438 return (YAHOO.lang.isBoolean(oParam) &&
439 // Not compatible with caption
440 !YAHOO.lang.isString(this.get("caption")));
441 },
442 method: function(oParam) {
443 if(oParam) {
444 //TODO: conf height
445 YAHOO.util.Dom.addClass(this._elContainer,YAHOO.widget.DataTable.CLASS_SCROLLABLE);
446 YAHOO.util.Dom.addClass(this._elTbody,YAHOO.widget.DataTable.CLASS_SCROLLBODY);
447 }
448 else {
449 YAHOO.util.Dom.removeClass(this._elContainer,YAHOO.widget.DataTable.CLASS_SCROLLABLE);
450 YAHOO.util.Dom.removeClass(this._elTbody,YAHOO.widget.DataTable.CLASS_SCROLLBODY);
451
452 }
453 }
454 });
455 };
456
457 /////////////////////////////////////////////////////////////////////////////
458 //
459 // Public constants
460 //
461 /////////////////////////////////////////////////////////////////////////////
462
463 /**
464 * Class name assigned to TABLE element.
465 *
466 * @property DataTable.CLASS_TABLE
467 * @type String
468 * @static
469 * @final
470 * @default "yui-dt-table"
471 */
472 YAHOO.widget.DataTable.CLASS_TABLE = "yui-dt-table";
473
474 /**
475 * Class name assigned to header container elements within each TH element.
476 *
477 * @property DataTable.CLASS_HEADER
478 * @type String
479 * @static
480 * @final
481 * @default "yui-dt-header"
482 */
483 YAHOO.widget.DataTable.CLASS_HEADER = "yui-dt-header";
484
485 /**
486 * Class name assigned to the primary TBODY element.
487 *
488 * @property DataTable.CLASS_BODY
489 * @type String
490 * @static
491 * @final
492 * @default "yui-dt-body"
493 */
494 YAHOO.widget.DataTable.CLASS_BODY = "yui-dt-body";
495
496 /**
497 * Class name assigned to the scrolling TBODY element of a fixed scrolling DataTable.
498 *
499 * @property DataTable.CLASS_SCROLLBODY
500 * @type String
501 * @static
502 * @final
503 * @default "yui-dt-scrollbody"
504 */
505 YAHOO.widget.DataTable.CLASS_SCROLLBODY = "yui-dt-scrollbody";
506
507 /**
508 * Class name assigned to display label elements.
509 *
510 * @property DataTable.CLASS_LABEL
511 * @type String
512 * @static
513 * @final
514 * @default "yui-dt-label"
515 */
516 YAHOO.widget.DataTable.CLASS_LABEL = "yui-dt-label";
517
518 /**
519 * Class name assigned to resizer handle elements.
520 *
521 * @property DataTable.CLASS_RESIZER
522 * @type String
523 * @static
524 * @final
525 * @default "yui-dt-resizer"
526 */
527 YAHOO.widget.DataTable.CLASS_RESIZER = "yui-dt-resizer";
528
529 /**
530 * Class name assigned to Editor container elements.
531 *
532 * @property DataTable.CLASS_EDITOR
533 * @type String
534 * @static
535 * @final
536 * @default "yui-dt-editor"
537 */
538 YAHOO.widget.DataTable.CLASS_EDITOR = "yui-dt-editor";
539
540 /**
541 * Class name assigned to paginator container elements.
542 *
543 * @property DataTable.CLASS_PAGINATOR
544 * @type String
545 * @static
546 * @final
547 * @default "yui-dt-paginator"
548 */
549 YAHOO.widget.DataTable.CLASS_PAGINATOR = "yui-dt-paginator";
550
551 /**
552 * Class name assigned to page number indicators.
553 *
554 * @property DataTable.CLASS_PAGE
555 * @type String
556 * @static
557 * @final
558 * @default "yui-dt-page"
559 */
560 YAHOO.widget.DataTable.CLASS_PAGE = "yui-dt-page";
561
562 /**
563 * Class name assigned to default indicators.
564 *
565 * @property DataTable.CLASS_DEFAULT
566 * @type String
567 * @static
568 * @final
569 * @default "yui-dt-default"
570 */
571 YAHOO.widget.DataTable.CLASS_DEFAULT = "yui-dt-default";
572
573 /**
574 * Class name assigned to previous indicators.
575 *
576 * @property DataTable.CLASS_PREVIOUS
577 * @type String
578 * @static
579 * @final
580 * @default "yui-dt-previous"
581 */
582 YAHOO.widget.DataTable.CLASS_PREVIOUS = "yui-dt-previous";
583
584 /**
585 * Class name assigned next indicators.
586 *
587 * @property DataTable.CLASS_NEXT
588 * @type String
589 * @static
590 * @final
591 * @default "yui-dt-next"
592 */
593 YAHOO.widget.DataTable.CLASS_NEXT = "yui-dt-next";
594
595 /**
596 * Class name assigned to first elements.
597 *
598 * @property DataTable.CLASS_FIRST
599 * @type String
600 * @static
601 * @final
602 * @default "yui-dt-first"
603 */
604 YAHOO.widget.DataTable.CLASS_FIRST = "yui-dt-first";
605
606 /**
607 * Class name assigned to last elements.
608 *
609 * @property DataTable.CLASS_LAST
610 * @type String
611 * @static
612 * @final
613 * @default "yui-dt-last"
614 */
615 YAHOO.widget.DataTable.CLASS_LAST = "yui-dt-last";
616
617 /**
618 * Class name assigned to even elements.
619 *
620 * @property DataTable.CLASS_EVEN
621 * @type String
622 * @static
623 * @final
624 * @default "yui-dt-even"
625 */
626 YAHOO.widget.DataTable.CLASS_EVEN = "yui-dt-even";
627
628 /**
629 * Class name assigned to odd elements.
630 *
631 * @property DataTable.CLASS_ODD
632 * @type String
633 * @static
634 * @final
635 * @default "yui-dt-odd"
636 */
637 YAHOO.widget.DataTable.CLASS_ODD = "yui-dt-odd";
638
639 /**
640 * Class name assigned to selected elements.
641 *
642 * @property DataTable.CLASS_SELECTED
643 * @type String
644 * @static
645 * @final
646 * @default "yui-dt-selected"
647 */
648 YAHOO.widget.DataTable.CLASS_SELECTED = "yui-dt-selected";
649
650 /**
651 * Class name assigned to highlighted elements.
652 *
653 * @property DataTable.CLASS_HIGHLIGHTED
654 * @type String
655 * @static
656 * @final
657 * @default "yui-dt-highlighted"
658 */
659 YAHOO.widget.DataTable.CLASS_HIGHLIGHTED = "yui-dt-highlighted";
660
661 /**
662 * Class name assigned to disabled elements.
663 *
664 * @property DataTable.CLASS_DISABLED
665 * @type String
666 * @static
667 * @final
668 * @default "yui-dt-disabled"
669 */
670 YAHOO.widget.DataTable.CLASS_DISABLED = "yui-dt-disabled";
671
672 /**
673 * Class name assigned to empty indicators.
674 *
675 * @property DataTable.CLASS_EMPTY
676 * @type String
677 * @static
678 * @final
679 * @default "yui-dt-empty"
680 */
681 YAHOO.widget.DataTable.CLASS_EMPTY = "yui-dt-empty";
682
683 /**
684 * Class name assigned to loading indicatorx.
685 *
686 * @property DataTable.CLASS_LOADING
687 * @type String
688 * @static
689 * @final
690 * @default "yui-dt-loading"
691 */
692 YAHOO.widget.DataTable.CLASS_LOADING = "yui-dt-loading";
693
694 /**
695 * Class name assigned to error indicators.
696 *
697 * @property DataTable.CLASS_ERROR
698 * @type String
699 * @static
700 * @final
701 * @default "yui-dt-error"
702 */
703 YAHOO.widget.DataTable.CLASS_ERROR = "yui-dt-error";
704
705 /**
706 * Class name assigned to editable elements.
707 *
708 * @property DataTable.CLASS_EDITABLE
709 * @type String
710 * @static
711 * @final
712 * @default "yui-dt-editable"
713 */
714 YAHOO.widget.DataTable.CLASS_EDITABLE = "yui-dt-editable";
715
716 /**
717 * Class name assigned to scrollable elements.
718 *
719 * @property DataTable.CLASS_SCROLLABLE
720 * @type String
721 * @static
722 * @final
723 * @default "yui-dt-scrollable"
724 */
725 YAHOO.widget.DataTable.CLASS_SCROLLABLE = "yui-dt-scrollable";
726
727 /**
728 * Class name assigned to sortable elements.
729 *
730 * @property DataTable.CLASS_SORTABLE
731 * @type String
732 * @static
733 * @final
734 * @default "yui-dt-sortable"
735 */
736 YAHOO.widget.DataTable.CLASS_SORTABLE = "yui-dt-sortable";
737
738 /**
739 * Class name assigned to ascending elements.
740 *
741 * @property DataTable.CLASS_ASC
742 * @type String
743 * @static
744 * @final
745 * @default "yui-dt-asc"
746 */
747 YAHOO.widget.DataTable.CLASS_ASC = "yui-dt-asc";
748
749 /**
750 * Class name assigned to descending elements.
751 *
752 * @property DataTable.CLASS_DESC
753 * @type String
754 * @static
755 * @final
756 * @default "yui-dt-desc"
757 */
758 YAHOO.widget.DataTable.CLASS_DESC = "yui-dt-desc";
759
760 /**
761 * Class name assigned to BUTTON container elements.
762 *
763 * @property DataTable.CLASS_BUTTON
764 * @type String
765 * @static
766 * @final
767 * @default "yui-dt-button"
768 */
769 YAHOO.widget.DataTable.CLASS_BUTTON = "yui-dt-button";
770
771 /**
772 * Class name assigned to SELECT container elements.
773 *
774 * @property DataTable.CLASS_DROPDOWN
775 * @type String
776 * @static
777 * @final
778 * @default "yui-dt-dropdown"
779 */
780 YAHOO.widget.DataTable.CLASS_DROPDOWN = "yui-dt-dropdown";
781
782 /**
783 * Class name assigned to INPUT TYPE=CHECKBOX container elements.
784 *
785 * @property DataTable.CLASS_CHECKBOX
786 * @type String
787 * @static
788 * @final
789 * @default "yui-dt-checkbox"
790 */
791 YAHOO.widget.DataTable.CLASS_CHECKBOX = "yui-dt-checkbox";
792
793 /**
794 * Message to display if DataTable has no data.
795 *
796 * @property DataTable.MSG_EMPTY
797 * @type String
798 * @static
799 * @final
800 * @default "No records found."
801 */
802 YAHOO.widget.DataTable.MSG_EMPTY = "No records found.";
803
804 /**
805 * Message to display while DataTable is loading data.
806 *
807 * @property DataTable.MSG_LOADING
808 * @type String
809 * @static
810 * @final
811 * @default "Loading data..."
812 */
813 YAHOO.widget.DataTable.MSG_LOADING = "Loading data...";
814
815 /**
816 * Message to display while DataTable has data error.
817 *
818 * @property DataTable.MSG_ERROR
819 * @type String
820 * @static
821 * @final
822 * @default "Data error."
823 */
824 YAHOO.widget.DataTable.MSG_ERROR = "Data error.";
825
826 /////////////////////////////////////////////////////////////////////////////
827 //
828 // Private member variables
829 //
830 /////////////////////////////////////////////////////////////////////////////
831
832 /**
833 * Internal class variable for indexing multiple DataTable instances.
834 *
835 * @property DataTable._nCount
836 * @type Number
837 * @private
838 * @static
839 */
840 YAHOO.widget.DataTable._nCount = 0;
841
842 /**
843 * Index assigned to instance.
844 *
845 * @property _nIndex
846 * @type Number
847 * @private
848 */
849 YAHOO.widget.DataTable.prototype._nIndex = null;
850
851 /**
852 * Counter for IDs assigned to TR elements.
853 *
854 * @property _nTrCount
855 * @type Number
856 * @private
857 */
858 YAHOO.widget.DataTable.prototype._nTrCount = 0;
859
860 /**
861 * Unique name assigned to instance.
862 *
863 * @property _sName
864 * @type String
865 * @private
866 */
867 YAHOO.widget.DataTable.prototype._sName = null;
868
869 /**
870 * DOM reference to the container element for the DataTable instance into which
871 * the TABLE element gets created.
872 *
873 * @property _elContainer
874 * @type HTMLElement
875 * @private
876 */
877 YAHOO.widget.DataTable.prototype._elContainer = null;
878
879 /**
880 * DOM reference to the CAPTION element for the DataTable instance.
881 *
882 * @property _elCaption
883 * @type HTMLElement
884 * @private
885 */
886 YAHOO.widget.DataTable.prototype._elCaption = null;
887
888 /**
889 * DOM reference to the TABLE element for the DataTable instance.
890 *
891 * @property _elTable
892 * @type HTMLElement
893 * @private
894 */
895 YAHOO.widget.DataTable.prototype._elTable = null;
896
897 /**
898 * DOM reference to the THEAD element for the DataTable instance.
899 *
900 * @property _elThead
901 * @type HTMLElement
902 * @private
903 */
904 YAHOO.widget.DataTable.prototype._elThead = null;
905
906 /**
907 * DOM reference to the primary TBODY element for the DataTable instance.
908 *
909 * @property _elTbody
910 * @type HTMLElement
911 * @private
912 */
913 YAHOO.widget.DataTable.prototype._elTbody = null;
914
915 /**
916 * DOM reference to the secondary TBODY element used to display DataTable messages.
917 *
918 * @property _elMsgTbody
919 * @type HTMLElement
920 * @private
921 */
922 YAHOO.widget.DataTable.prototype._elMsgTbody = null;
923
924 /**
925 * DOM reference to the secondary TBODY element's single TR element used to display DataTable messages.
926 *
927 * @property _elMsgTbodyRow
928 * @type HTMLElement
929 * @private
930 */
931 YAHOO.widget.DataTable.prototype._elMsgTbodyRow = null;
932
933 /**
934 * DOM reference to the secondary TBODY element's single TD element used to display DataTable messages.
935 *
936 * @property _elMsgTbodyCell
937 * @type HTMLElement
938 * @private
939 */
940 YAHOO.widget.DataTable.prototype._elMsgTbodyCell = null;
941
942 /**
943 * DataSource instance for the DataTable instance.
944 *
945 * @property _oDataSource
946 * @type YAHOO.util.DataSource
947 * @private
948 */
949 YAHOO.widget.DataTable.prototype._oDataSource = null;
950
951 /**
952 * ColumnSet instance for the DataTable instance.
953 *
954 * @property _oColumnSet
955 * @type YAHOO.widget.ColumnSet
956 * @private
957 */
958 YAHOO.widget.DataTable.prototype._oColumnSet = null;
959
960 /**
961 * RecordSet instance for the DataTable instance.
962 *
963 * @property _oRecordSet
964 * @type YAHOO.widget.RecordSet
965 * @private
966 */
967 YAHOO.widget.DataTable.prototype._oRecordSet = null;
968
969 /**
970 * ID string of first label link element of the current DataTable page, if any.
971 * Used for focusing sortable Columns with TAB.
972 *
973 * @property _sFirstLabelLinkId
974 * @type String
975 * @private
976 */
977 YAHOO.widget.DataTable.prototype._sFirstLabelLinkId = null;
978
979 /**
980 * ID string of first TR element of the current DataTable page.
981 *
982 * @property _sFirstTrId
983 * @type String
984 * @private
985 */
986 YAHOO.widget.DataTable.prototype._sFirstTrId = null;
987
988 /**
989 * ID string of the last TR element of the current DataTable page.
990 *
991 * @property _sLastTrId
992 * @type String
993 * @private
994 */
995 YAHOO.widget.DataTable.prototype._sLastTrId = null;
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028 /////////////////////////////////////////////////////////////////////////////
1029 //
1030 // Private methods
1031 //
1032 /////////////////////////////////////////////////////////////////////////////
1033
1034 /**
1035 * Sets focus on the given element.
1036 *
1037 * @method _focusEl
1038 * @param el {HTMLElement} Element.
1039 * @private
1040 */
1041 YAHOO.widget.DataTable.prototype._focusEl = function(el) {
1042 el = el || this._elTable;
1043 // http://developer.mozilla.org/en/docs/index.php?title=Key-navigable_custom_DHTML_widgets
1044 // The timeout is necessary in both IE and Firefox 1.5, to prevent scripts from doing
1045 // strange unexpected things as the user clicks on buttons and other controls.
1046 setTimeout(function() { el.focus(); },0);
1047 };
1048
1049
1050
1051
1052
1053 // INIT FUNCTIONS
1054
1055 /**
1056 * Initializes container element.
1057 *
1058 * @method _initContainerEl
1059 * @param elContainer {HTMLElement | String} HTML DIV element by reference or ID.
1060 * @private
1061 */
1062 YAHOO.widget.DataTable.prototype._initContainerEl = function(elContainer) {
1063 this._elContainer = null;
1064 elContainer = YAHOO.util.Dom.get(elContainer);
1065 if(elContainer && elContainer.tagName && (elContainer.tagName.toLowerCase() == "div")) {
1066 this._elContainer = elContainer;
1067 }
1068 };
1069
1070 /**
1071 * Initializes object literal of config values.
1072 *
1073 * @method _initConfigs
1074 * @param oConfig {Object} Object literal of config values.
1075 * @private
1076 */
1077 YAHOO.widget.DataTable.prototype._initConfigs = function(oConfigs) {
1078 if(oConfigs) {
1079 if(oConfigs.constructor != Object) {
1080 oConfigs = null;
1081 }
1082 // Backward compatibility
1083 else if(YAHOO.lang.isBoolean(oConfigs.paginator)) {
1084 }
1085 this._oConfigs = oConfigs;
1086 }
1087 };
1088
1089 /**
1090 * Initializes ColumnSet.
1091 *
1092 * @method _initColumnSet
1093 * @param aColumnDefs {Object[]} Array of object literal Column definitions.
1094 * @private
1095 */
1096 YAHOO.widget.DataTable.prototype._initColumnSet = function(aColumnDefs) {
1097 this._oColumnSet = null;
1098 if(YAHOO.lang.isArray(aColumnDefs)) {
1099 this._oColumnSet = new YAHOO.widget.ColumnSet(aColumnDefs);
1100 }
1101 // Backward compatibility
1102 else if(aColumnDefs instanceof YAHOO.widget.ColumnSet) {
1103 this._oColumnSet = aColumnDefs;
1104 }
1105 };
1106
1107 /**
1108 * Initializes DataSource.
1109 *
1110 * @method _initDataSource
1111 * @param oDataSource {YAHOO.util.DataSource} DataSource instance.
1112 * @private
1113 */
1114 YAHOO.widget.DataTable.prototype._initDataSource = function(oDataSource) {
1115 this._oDataSource = null;
1116 if(oDataSource && (oDataSource instanceof YAHOO.util.DataSource)) {
1117 this._oDataSource = oDataSource;
1118 }
1119 // Backward compatibility
1120 else {
1121 var tmpTable = null;
1122 var tmpContainer = this._elContainer;
1123 // Peek in container child nodes to see if TABLE already exists
1124 if(tmpContainer.hasChildNodes()) {
1125 var tmpChildren = tmpContainer.childNodes;
1126 for(i=0; i<tmpChildren.length; i++) {
1127 if(tmpChildren[i].tagName && tmpChildren[i].tagName.toLowerCase() == "table") {
1128 tmpTable = tmpChildren[i];
1129 break;
1130 }
1131 }
1132 if(tmpTable) {
1133 var tmpFieldsArray = [];
1134 for(i=0; i<this._oColumnSet.keys.length; i++) {
1135 tmpFieldsArray.push({key:this._oColumnSet.keys[i].key});
1136 }
1137
1138 this._oDataSource = new YAHOO.util.DataSource(tmpTable);
1139 this._oDataSource.responseType = YAHOO.util.DataSource.TYPE_HTMLTABLE;
1140 this._oDataSource.responseSchema = {fields: tmpFieldsArray};
1141 }
1142 }
1143 }
1144 };
1145
1146 /**
1147 * Initializes RecordSet.
1148 *
1149 * @method _initRecordSet
1150 * @private
1151 */
1152 YAHOO.widget.DataTable.prototype._initRecordSet = function() {
1153 if(this._oRecordSet) {
1154 this._oRecordSet.reset();
1155 }
1156 else {
1157 this._oRecordSet = new YAHOO.widget.RecordSet();
1158 }
1159 };
1160
1161 /**
1162 * Creates HTML markup for TABLE, THEAD and TBODY elements.
1163 *
1164 * @method _initTableEl
1165 * @private
1166 */
1167 YAHOO.widget.DataTable.prototype._initTableEl = function() {
1168 // Clear the container
1169 YAHOO.util.Event.purgeElement(this._elContainer, true);
1170 this._elContainer.innerHTML = "";
1171
1172 // Create TABLE
1173 this._elTable = this._elContainer.appendChild(document.createElement("table"));
1174 var elTable = this._elTable;
1175 elTable.tabIndex = 0;
1176 elTable.id = this.id + "-table";
1177 YAHOO.util.Dom.addClass(elTable, YAHOO.widget.DataTable.CLASS_TABLE);
1178
1179 // Create THEAD
1180 this._initTheadEl(elTable, this._oColumnSet);
1181
1182
1183 // Create TBODY for messages
1184 var elMsgTbody = document.createElement("tbody");
1185 var elMsgRow = elMsgTbody.appendChild(document.createElement("tr"));
1186 YAHOO.util.Dom.addClass(elMsgRow,YAHOO.widget.DataTable.CLASS_FIRST);
1187 YAHOO.util.Dom.addClass(elMsgRow,YAHOO.widget.DataTable.CLASS_LAST);
1188 this._elMsgRow = elMsgRow;
1189 var elMsgCell = elMsgRow.appendChild(document.createElement("td"));
1190 elMsgCell.colSpan = this._oColumnSet.keys.length;
1191 YAHOO.util.Dom.addClass(elMsgCell,YAHOO.widget.DataTable.CLASS_FIRST);
1192 YAHOO.util.Dom.addClass(elMsgCell,YAHOO.widget.DataTable.CLASS_LAST);
1193 this._elMsgTd = elMsgCell;
1194 this._elMsgTbody = elTable.appendChild(elMsgTbody);
1195 this.showTableMessage(YAHOO.widget.DataTable.MSG_LOADING, YAHOO.widget.DataTable.CLASS_LOADING);
1196
1197 // Create TBODY for data
1198 this._elTbody = elTable.appendChild(document.createElement("tbody"));
1199 YAHOO.util.Dom.addClass(this._elTbody,YAHOO.widget.DataTable.CLASS_BODY);
1200 };
1201
1202 /**
1203 * Populates THEAD element with TH cells as defined by ColumnSet.
1204 *
1205 * @method _initTheadEl
1206 * @private
1207 */
1208 YAHOO.widget.DataTable.prototype._initTheadEl = function() {
1209 var i,oColumn, colId;
1210 var oColumnSet = this._oColumnSet;
1211 this._sFirstLabelLinkId = null;
1212
1213 // Create THEAD
1214 var elThead = document.createElement("thead");
1215
1216 // Iterate through each row of Column headers...
1217 var colTree = oColumnSet.tree;
1218 for(i=0; i<colTree.length; i++) {
1219 var elTheadRow = elThead.appendChild(document.createElement("tr"));
1220 elTheadRow.id = this.id+"-hdrow"+i;
1221
1222 var elTheadCell;
1223 // ...and create THEAD cells
1224 for(var j=0; j<colTree[i].length; j++) {
1225 oColumn = colTree[i][j];
1226 colId = oColumn.getId();
1227 elTheadCell = elTheadRow.appendChild(document.createElement("th"));
1228 elTheadCell.id = this.id + "-col" + colId;
1229 this._initThEl(elTheadCell,oColumn,i,j);
1230 }
1231
1232 // Set FIRST/LAST on THEAD rows
1233 if(i === 0) {
1234 YAHOO.util.Dom.addClass(elTheadRow, YAHOO.widget.DataTable.CLASS_FIRST);
1235 }
1236 if(i === (colTree.length-1)) {
1237 YAHOO.util.Dom.addClass(elTheadRow, YAHOO.widget.DataTable.CLASS_LAST);
1238 }
1239 }
1240
1241 this._elThead = this._elTable.appendChild(elThead);
1242
1243 // Set FIRST/LAST on THEAD cells using the values in ColumnSet headers array
1244 var aFirstHeaders = oColumnSet.headers[0].split(" ");
1245 var aLastHeaders = oColumnSet.headers[oColumnSet.headers.length-1].split(" ");
1246 for(i=0; i<aFirstHeaders.length; i++) {
1247 YAHOO.util.Dom.addClass(YAHOO.util.Dom.get(this.id+"-col"+aFirstHeaders[i]), YAHOO.widget.DataTable.CLASS_FIRST);
1248 }
1249 for(i=0; i<aLastHeaders.length; i++) {
1250 YAHOO.util.Dom.addClass(YAHOO.util.Dom.get(this.id+"-col"+aLastHeaders[i]), YAHOO.widget.DataTable.CLASS_LAST);
1251 }
1252
1253 // Add Resizer only after DOM has been updated
1254 var foundDD = (YAHOO.util.DD) ? true : false;
1255 var needDD = false;
1256 for(i=0; i<this._oColumnSet.keys.length; i++) {
1257 oColumn = this._oColumnSet.keys[i];
1258 colId = oColumn.getId();
1259 var elTheadCellId = YAHOO.util.Dom.get(this.id + "-col" + colId);
1260 if(oColumn.resizeable) {
1261 if(foundDD) {
1262 //TODO: fix fixed width tables
1263 // Skip the last column for fixed-width tables
1264 if(!this.fixedWidth || (this.fixedWidth &&
1265 (oColumn.getKeyIndex() != this._oColumnSet.keys.length-1))) {
1266 // TODO: better way to get elTheadContainer
1267 var elThContainer = YAHOO.util.Dom.getElementsByClassName(YAHOO.widget.DataTable.CLASS_HEADER,"div",elTheadCellId)[0];
1268 var elThResizer = elThContainer.appendChild(document.createElement("span"));
1269 elThResizer.id = this.id + "-resizer" + colId;
1270 YAHOO.util.Dom.addClass(elThResizer,YAHOO.widget.DataTable.CLASS_RESIZER);
1271 oColumn.ddResizer = new YAHOO.util.ColumnResizer(
1272 this, oColumn, elTheadCellId, elThResizer.id, elThResizer.id);
1273 var cancelClick = function(e) {
1274 YAHOO.util.Event.stopPropagation(e);
1275 };
1276 YAHOO.util.Event.addListener(elThResizer,"click",cancelClick);
1277 }
1278 if(this.fixedWidth) {
1279 //TODO: fix fixedWidth
1280 //elThContainer.style.overflow = "hidden";
1281 //TODO: better way to get elTheadText
1282 var elThLabel = (YAHOO.util.Dom.getElementsByClassName(YAHOO.widget.DataTable.CLASS_LABEL,"span",elTheadCellId))[0];
1283 elThLabel.style.overflow = "hidden";
1284 }
1285 }
1286 else {
1287 needDD = true;
1288 }
1289 }
1290 }
1291 if(needDD) {
1292 }
1293
1294 };
1295
1296 /**
1297 * Populates TH cell as defined by Column.
1298 *
1299 * @method _initThEl
1300 * @param elTheadCell {HTMLElement} TH cell element reference.
1301 * @param oColumn {YAHOO.widget.Column} Column object.
1302 * @param row {number} Row index.
1303 * @param col {number} Column index.
1304 * @private
1305 */
1306 YAHOO.widget.DataTable.prototype._initThEl = function(elTheadCell,oColumn,row,col) {
1307 // Clear out the cell of prior content
1308 // TODO: purgeListeners and other validation-related things
1309 var index = this._nIndex;
1310 var colId = oColumn.getId();
1311 elTheadCell.yuiColumnId = colId;
1312 if(oColumn.abbr) {
1313 elTheadCell.abbr = oColumn.abbr;
1314 }
1315 if(oColumn.width) {
1316 elTheadCell.style.width = oColumn.width;
1317 }
1318
1319 var aCustomClasses;
1320 if(YAHOO.lang.isString(oColumn.className)) {
1321 aCustomClasses = [oColumn.className];
1322 }
1323 else if(YAHOO.lang.isArray(oColumn.className)) {
1324 aCustomClasses = oColumn.className;
1325 }
1326 if(aCustomClasses) {
1327 for(var i=0; i<aCustomClasses.length; i++) {
1328 YAHOO.util.Dom.addClass(elTheadCell,aCustomClasses[i]);
1329 }
1330 }
1331
1332 YAHOO.util.Dom.addClass(elTheadCell, "yui-dt-col-"+oColumn.key);
1333
1334 elTheadCell.innerHTML = "";
1335 elTheadCell.rowSpan = oColumn.getRowspan();
1336 elTheadCell.colSpan = oColumn.getColspan();
1337
1338 var elTheadContainer = elTheadCell.appendChild(document.createElement("div"));
1339 elTheadContainer.id = this.id + "-container" + colId;
1340 YAHOO.util.Dom.addClass(elTheadContainer,YAHOO.widget.DataTable.CLASS_HEADER);
1341 var elTheadLabel = elTheadContainer.appendChild(document.createElement("span"));
1342 elTheadLabel.id = this.id + "-label" + colId;
1343 YAHOO.util.Dom.addClass(elTheadLabel,YAHOO.widget.DataTable.CLASS_LABEL);
1344
1345 var sLabel = YAHOO.lang.isValue(oColumn.label) ? oColumn.label : oColumn.key;
1346 if(oColumn.sortable) {
1347 YAHOO.util.Dom.addClass(elTheadCell,YAHOO.widget.DataTable.CLASS_SORTABLE);
1348 //TODO: Make sortLink customizeable
1349 //TODO: Make title configurable
1350 //TODO: Separate label from an accessibility link that says
1351 // "Click to sort ascending" and push it offscreen
1352 var sLabelLinkId = this.id + "-labellink" + colId;
1353 var sortLink = "?key=" + oColumn.key;
1354 elTheadLabel.innerHTML = "<a id=\"" + sLabelLinkId + "\" href=\"" + sortLink + "\" title=\"Click to sort\" class=\"" + YAHOO.widget.DataTable.CLASS_SORTABLE + "\">" + sLabel + "</a>";
1355 if(!this._sFirstLabelLinkId) {
1356 this._sFirstLabelLinkId = sLabelLinkId;
1357 }
1358 }
1359 else {
1360 elTheadLabel.innerHTML = sLabel;
1361 }
1362 };
1363
1364 /**
1365 * Creates HTML markup for Cell Editor.
1366 *
1367 * @method _initCellEditorEl
1368 * @private
1369 */
1370 YAHOO.widget.DataTable.prototype._initCellEditorEl = function() {
1371 // Attach Cell Editor container element to body
1372 var elCellEditor = document.createElement("div");
1373 elCellEditor.id = this.id + "-celleditor";
1374 elCellEditor.style.display = "none";
1375 YAHOO.util.Dom.addClass(elCellEditor, YAHOO.widget.DataTable.CLASS_EDITOR);
1376 elCellEditor = document.body.appendChild(elCellEditor);
1377
1378 // Internal tracker of Cell Editor values
1379 var oCellEditor = {};
1380 oCellEditor.container = elCellEditor;
1381 oCellEditor.value = null;
1382 oCellEditor.isActive = false;
1383 this._oCellEditor = oCellEditor;
1384
1385 // Handle ESC key
1386 this.subscribe("editorKeydownEvent", function(oArgs) {
1387 var e = oArgs.event;
1388 var elTarget = YAHOO.util.Event.getTarget(e);
1389
1390 // ESC hides Cell Editor
1391 if((e.keyCode == 27)) {
1392 this.cancelCellEditor();
1393 }
1394 });
1395 };
1396
1397 /**
1398 * Initializes Column sorting.
1399 *
1400 * @method _initColumnSort
1401 * @private
1402 */
1403 YAHOO.widget.DataTable.prototype._initColumnSort = function() {
1404 this.subscribe("headerCellClickEvent", this.onEventSortColumn);
1405 };
1406
1407 /**
1408 * Initializes DOM event listeners.
1409 *
1410 * @method _initDomEvents
1411 * @private
1412 */
1413 YAHOO.widget.DataTable.prototype._initDomEvents = function() {
1414 var elTable = this._elTable;
1415 var elThead = this._elThead;
1416 var elTbody = this._elTbody;
1417 var elContainer = this._elContainer;
1418
1419 YAHOO.util.Event.addListener(document, "click", this._onDocumentClick, this);
1420 YAHOO.util.Event.addListener(document, "keydown", this._onDocumentKeydown, this);
1421
1422 YAHOO.util.Event.addListener(elTable, "focus", this._onTableFocus, this);
1423 YAHOO.util.Event.addListener(elTable, "mouseover", this._onTableMouseover, this);
1424 YAHOO.util.Event.addListener(elTable, "mouseout", this._onTableMouseout, this);
1425 YAHOO.util.Event.addListener(elTable, "mousedown", this._onTableMousedown, this);
1426 YAHOO.util.Event.addListener(elTable, "keydown", this._onTableKeydown, this);
1427 YAHOO.util.Event.addListener(elTable, "keypress", this._onTableKeypress, this);
1428
1429 // Since we can't listen for click and dblclick on the same element...
1430 YAHOO.util.Event.addListener(elTable, "dblclick", this._onTableDblclick, this);
1431 YAHOO.util.Event.addListener(elThead, "click", this._onTheadClick, this);
1432 YAHOO.util.Event.addListener(elTbody, "click", this._onTbodyClick, this);
1433
1434 YAHOO.util.Event.addListener(elContainer, "scroll", this._onScroll, this); // for IE
1435 YAHOO.util.Event.addListener(elTbody, "scroll", this._onScroll, this); // for everyone else
1436 };
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474 // DOM MUTATION FUNCTIONS
1475
1476
1477
1478
1479 /**
1480 * Adds a TR element to the primary TBODY at the page row index if given, otherwise
1481 * at the end of the page. Formats TD elements within the TR element using data
1482 * from the given Record.
1483 *
1484 * @method _addTrEl
1485 * @param oRecord {YAHOO.widget.Record} Record instance.
1486 * @param index {Number} (optional) The page row index at which to add the TR
1487 * element.
1488 * @return {String} ID of the added TR element, or null.
1489 * @private
1490 */
1491 YAHOO.widget.DataTable.prototype._addTrEl = function(oRecord, index) {
1492 this.hideTableMessage();
1493
1494 // It's an append if no index provided, or index is negative or too big
1495 var append = (!YAHOO.lang.isNumber(index) || (index < 0) ||
1496 (index >= (this._elTbody.rows.length))) ? true : false;
1497
1498 var oColumnSet = this._oColumnSet;
1499 var oRecordSet = this._oRecordSet;
1500 var isSortedBy = this.get("sortedBy");
1501 var sortedColKeyIndex = null;
1502 var sortedDir, newClass;
1503 if(isSortedBy) {
1504 sortedColKeyIndex = (isSortedBy.column) ?
1505 isSortedBy.column.getKeyIndex() :
1506 this._oColumnSet.getColumn(isSortedBy.key).getKeyIndex();
1507 sortedDir = isSortedBy.dir;
1508 newClass = (sortedDir === "desc") ? YAHOO.widget.DataTable.CLASS_DESC :
1509 YAHOO.widget.DataTable.CLASS_ASC;
1510
1511 }
1512
1513
1514 var elRow = (append) ? this._elTbody.appendChild(document.createElement("tr")) :
1515 this._elTbody.insertBefore(document.createElement("tr"),this._elTbody.rows[index]);
1516
1517 elRow.id = this.id+"-bdrow"+this._nTrCount;
1518 this._nTrCount++;
1519 elRow.yuiRecordId = oRecord.getId();
1520
1521 // Create TD cells
1522 for(var j=0; j<oColumnSet.keys.length; j++) {
1523 var oColumn = oColumnSet.keys[j];
1524 var elCell = elRow.appendChild(document.createElement("td"));
1525 elCell.id = elRow.id+"-cell"+j;
1526 elCell.yuiColumnId = oColumn.getId();
1527 elCell.headers = oColumnSet.headers[j];
1528 // For SF2 cellIndex bug: http://www.webreference.com/programming/javascript/ppk2/3.html
1529 elCell.yuiCellIndex = j;
1530
1531 // Update UI
1532 this.formatCell(elCell, oRecord, oColumn);
1533
1534 // Set FIRST/LAST on TD
1535 if (j === 0) {
1536 YAHOO.util.Dom.addClass(elCell, YAHOO.widget.DataTable.CLASS_FIRST);
1537 }
1538 else if (j === this._oColumnSet.keys.length-1) {
1539 YAHOO.util.Dom.addClass(elCell, YAHOO.widget.DataTable.CLASS_LAST);
1540 }
1541
1542 // Remove ASC/DESC
1543 YAHOO.util.Dom.removeClass(elCell, YAHOO.widget.DataTable.CLASS_ASC);
1544 YAHOO.util.Dom.removeClass(elCell, YAHOO.widget.DataTable.CLASS_DESC);
1545
1546 // Set ASC/DESC on TD
1547 if(j === sortedColKeyIndex) {
1548 newClass = (sortedDir === "desc") ?
1549 YAHOO.widget.DataTable.CLASS_DESC :
1550 YAHOO.widget.DataTable.CLASS_ASC;
1551 YAHOO.util.Dom.addClass(elCell, newClass);
1552 }
1553
1554
1555 /*p.abx {word-wrap:break-word;}
1556 ought to solve the problem for Safari (the long words will wrap in your
1557 tds, instead of overflowing to the next td.
1558 (this is supported by IE win as well, so hide it if needed).
1559
1560 One thing, though: it doesn't work in combination with
1561 'white-space:nowrap'.*/
1562
1563 // need a div wrapper for safari?
1564 //TODO: fix fixedWidth
1565 if(this.fixedWidth) {
1566 elCell.style.overflow = "hidden";
1567 //elCell.style.width = "20px";
1568 }
1569 }
1570
1571 return elRow.id;
1572 };
1573
1574 /**
1575 * Formats all TD elements of given TR element with data from the given Record.
1576 *
1577 * @method _updateTrEl
1578 * @param elRow {HTMLElement} The TR element to update.
1579 * @param oRecord {YAHOO.widget.Record} The associated Record instance.
1580 * @return {String} ID of the updated TR element, or null.
1581 * @private
1582 */
1583 YAHOO.widget.DataTable.prototype._updateTrEl = function(elRow, oRecord) {
1584 this.hideTableMessage();
1585
1586 var isSortedBy = this.get("sortedBy");
1587 var sortedColKeyIndex = null;
1588 var sortedDir, newClass;
1589 if(isSortedBy) {
1590 sortedColKeyIndex = (isSortedBy.column) ?
1591 isSortedBy.column.getKeyIndex() :
1592 this._oColumnSet.getColumn(isSortedBy.key).getKeyIndex();
1593 sortedDir = isSortedBy.dir;
1594 newClass = (sortedDir === "desc") ? YAHOO.widget.DataTable.CLASS_DESC :
1595 YAHOO.widget.DataTable.CLASS_ASC;
1596 }
1597
1598 // Update TD elements with new data
1599 for(var j=0; j<elRow.cells.length; j++) {
1600 var oColumn = this._oColumnSet.keys[j];
1601 var elCell = elRow.cells[j];
1602 this.formatCell(elCell, oRecord, oColumn);
1603
1604 // Remove ASC/DESC
1605 YAHOO.util.Dom.removeClass(elCell, YAHOO.widget.DataTable.CLASS_ASC);
1606 YAHOO.util.Dom.removeClass(elCell, YAHOO.widget.DataTable.CLASS_DESC);
1607
1608 // Set ASC/DESC on TD
1609 if(j === sortedColKeyIndex) {
1610 YAHOO.util.Dom.addClass(elCell, newClass);
1611 }
1612 }
1613
1614 // Update Record ID
1615 elRow.yuiRecordId = oRecord.getId();
1616
1617 return elRow.id;
1618 };
1619
1620
1621 /**
1622 * Deletes TR element by DOM reference or by DataTable page row index.
1623 *
1624 * @method _deleteTrEl
1625 * @param row {HTMLElement | Number} TR element reference or Datatable page row index.
1626 * @return {Boolean} Returns true if successful, else returns false.
1627 * @private
1628 */
1629 YAHOO.widget.DataTable.prototype._deleteTrEl = function(row) {
1630 var rowIndex;
1631
1632 // Get page row index for the element
1633 if(!YAHOO.lang.isNumber(row)) {
1634 rowIndex = YAHOO.util.Dom.get(row).sectionRowIndex;
1635 }
1636 else {
1637 rowIndex = row;
1638 }
1639 if(YAHOO.lang.isNumber(rowIndex) && (rowIndex > -2) && (rowIndex < this._elTbody.rows.length)) {
1640 this._elTbody.deleteRow(rowIndex);
1641 return true;
1642 }
1643 else {
1644 return false;
1645 }
1646 };
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674 // CSS/STATE FUNCTIONS
1675
1676
1677
1678
1679 /**
1680 * Assigns the class YAHOO.widget.DataTable.CLASS_FIRST to the first TR element
1681 * of the DataTable page and updates internal tracker.
1682 *
1683 * @method _setFirstRow
1684 * @private
1685 */
1686 YAHOO.widget.DataTable.prototype._setFirstRow = function() {
1687 var rowEl = this.getFirstTrEl();
1688 if(rowEl) {
1689 // Remove FIRST
1690 if(this._sFirstTrId) {
1691 YAHOO.util.Dom.removeClass(this._sFirstTrId, YAHOO.widget.DataTable.CLASS_FIRST);
1692 }
1693 // Set FIRST
1694 YAHOO.util.Dom.addClass(rowEl, YAHOO.widget.DataTable.CLASS_FIRST);
1695 this._sFirstTrId = rowEl.id;
1696 }
1697 else {
1698 this._sFirstTrId = null;
1699 }
1700 };
1701
1702 /**
1703 * Assigns the class YAHOO.widget.DataTable.CLASS_LAST to the last TR element
1704 * of the DataTable page and updates internal tracker.
1705 *
1706 * @method _setLastRow
1707 * @private
1708 */
1709 YAHOO.widget.DataTable.prototype._setLastRow = function() {
1710 var rowEl = this.getLastTrEl();
1711 if(rowEl) {
1712 // Unassign previous class
1713 if(this._sLastTrId) {
1714 YAHOO.util.Dom.removeClass(this._sLastTrId, YAHOO.widget.DataTable.CLASS_LAST);
1715 }
1716 // Assign class
1717 YAHOO.util.Dom.addClass(rowEl, YAHOO.widget.DataTable.CLASS_LAST);
1718 this._sLastTrId = rowEl.id;
1719 }
1720 else {
1721 this._sLastTrId = null;
1722 }
1723 };
1724
1725 /**
1726 * Assigns the classes YAHOO.widget.DataTable.CLASS_EVEN and
1727 * YAHOO.widget.DataTable.CLASS_ODD to alternating TR elements of the DataTable
1728 * page. For performance, a subset of rows may be specified.
1729 *
1730 * @method _setRowStripes
1731 * @param row {HTMLElement | String | Number} (optional) HTML TR element reference
1732 * or string ID, or page row index of where to start striping.
1733 * @param range {Number} (optional) If given, how many rows to stripe, otherwise
1734 * stripe all the rows until the end.
1735 * @private
1736 */
1737 YAHOO.widget.DataTable.prototype._setRowStripes = function(row, range) {
1738 // Default values stripe all rows
1739 var allRows = this._elTbody.rows;
1740 var nStartIndex = 0;
1741 var nEndIndex = allRows.length;
1742
1743 // Stripe a subset
1744 if((row !== null) && (row !== undefined)) {
1745 // Validate given start row
1746 var elStartRow = this.getTrEl(row);
1747 if(elStartRow) {
1748 nStartIndex = elStartRow.sectionRowIndex;
1749
1750 // Validate given range
1751 if(YAHOO.lang.isNumber(range) && (range > 1)) {
1752 nEndIndex = nStartIndex + range;
1753 }
1754 }
1755 }
1756
1757 for(var i=nStartIndex; i<nEndIndex; i++) {
1758 if(i%2) {
1759 YAHOO.util.Dom.removeClass(allRows[i], YAHOO.widget.DataTable.CLASS_EVEN);
1760 YAHOO.util.Dom.addClass(allRows[i], YAHOO.widget.DataTable.CLASS_ODD);
1761 }
1762 else {
1763 YAHOO.util.Dom.removeClass(allRows[i], YAHOO.widget.DataTable.CLASS_ODD);
1764 YAHOO.util.Dom.addClass(allRows[i], YAHOO.widget.DataTable.CLASS_EVEN);
1765 }
1766 }
1767 };
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813 /////////////////////////////////////////////////////////////////////////////
1814 //
1815 // Private DOM Event Handlers
1816 //
1817 /////////////////////////////////////////////////////////////////////////////
1818
1819 /**
1820 * Handles scroll events on the CONTAINER (for IE) and TBODY elements (for everyone else).
1821 *
1822 * @method _onScroll
1823 * @param e {HTMLEvent} The scroll event.
1824 * @param oSelf {YAHOO.widget.DataTable} DataTable instance.
1825 * @private
1826 */
1827 YAHOO.widget.DataTable.prototype._onScroll = function(e, oSelf) {
1828 var elTarget = YAHOO.util.Event.getTarget(e);
1829 var elTag = elTarget.tagName.toLowerCase();
1830
1831 if(oSelf._oCellEditor.isActive) {
1832 oSelf.fireEvent("editorBlurEvent", {editor:oSelf._oCellEditor});
1833 oSelf.cancelCellEditor();
1834 }
1835
1836 oSelf.fireEvent("tableScrollEvent", {event:e, target:elTarget});
1837 };
1838
1839 /**
1840 * Handles click events on the DOCUMENT.
1841 *
1842 * @method _onDocumentClick
1843 * @param e {HTMLEvent} The click event.
1844 * @param oSelf {YAHOO.widget.DataTable} DataTable instance.
1845 * @private
1846 */
1847 YAHOO.widget.DataTable.prototype._onDocumentClick = function(e, oSelf) {
1848 var elTarget = YAHOO.util.Event.getTarget(e);
1849 var elTag = elTarget.tagName.toLowerCase();
1850
1851 if(!YAHOO.util.Dom.isAncestor(oSelf._elTable, elTarget)) {
1852 oSelf.fireEvent("tableBlurEvent");
1853
1854 // Fires editorBlurEvent when click is not within the TABLE.
1855 // For cases when click is within the TABLE, due to timing issues,
1856 // the editorBlurEvent needs to get fired by the lower-level DOM click
1857 // handlers below rather than by the TABLE click handler directly.
1858 if(oSelf._oCellEditor && oSelf._oCellEditor.isActive) {
1859 // Only if the click was not within the Cell Editor container
1860 if(!YAHOO.util.Dom.isAncestor(oSelf._oCellEditor.container, elTarget) &&
1861 (oSelf._oCellEditor.container.id !== elTarget.id)) {
1862 oSelf.fireEvent("editorBlurEvent", {editor:oSelf._oCellEditor});
1863 }
1864 }
1865 }
1866 };
1867
1868 /**
1869 * Handles keydown events on the DOCUMENT.
1870 *
1871 * @method _onDocumentKeydown
1872 * @param e {HTMLEvent} The keydown event.
1873 * @param oSelf {YAHOO.widget.DataTable} DataTable instance.
1874 * @private
1875 */
1876 YAHOO.widget.DataTable.prototype._onDocumentKeydown = function(e, oSelf) {
1877 var elTarget = YAHOO.util.Event.getTarget(e);
1878 var elTag = elTarget.tagName.toLowerCase();
1879
1880 if(oSelf._oCellEditor && oSelf._oCellEditor.isActive &&
1881 YAHOO.util.Dom.isAncestor(oSelf._oCellEditor.container, elTarget)) {
1882 oSelf.fireEvent("editorKeydownEvent", {editor:oSelf._oCellEditor, event:e});
1883 }
1884 };
1885
1886 /**
1887 * Handles focus events on the TABLE element.
1888 *
1889 * @method _onTableFocus
1890 * @param e {HTMLEvent} The focus event.
1891 * @param oSelf {YAHOO.widget.DataTable} DataTable instance.
1892 * @private
1893 */
1894 YAHOO.widget.DataTable.prototype._onTableMouseover = function(e, oSelf) {
1895 oSelf.fireEvent("tableFocusEvent");
1896 };
1897
1898 /**
1899 * Handles mouseover events on the TABLE element.
1900 *
1901 * @method _onTableMouseover
1902 * @param e {HTMLEvent} The mouseover event.
1903 * @param oSelf {YAHOO.widget.DataTable} DataTable instance.
1904 * @private
1905 */
1906 YAHOO.widget.DataTable.prototype._onTableMouseover = function(e, oSelf) {
1907 var elTarget = YAHOO.util.Event.getTarget(e);
1908 var elTag = elTarget.tagName.toLowerCase();
1909
1910 while(elTarget && (elTag != "table")) {
1911 switch(elTag) {
1912 case "body":
1913 break;
1914 case "a":
1915 break;
1916 case "td":
1917 oSelf.fireEvent("cellMouseoverEvent",{target:elTarget,event:e});
1918 break;
1919 case "span":
1920 if(YAHOO.util.Dom.hasClass(elTarget, YAHOO.widget.DataTable.CLASS_LABEL)) {
1921 oSelf.fireEvent("headerLabelMouseoverEvent",{target:elTarget,event:e});
1922 }
1923 break;
1924 case "th":
1925 oSelf.fireEvent("headerCellMouseoverEvent",{target:elTarget,event:e});
1926 break;
1927 case "tr":
1928 if(elTarget.parentNode.tagName.toLowerCase() == "thead") {
1929 oSelf.fireEvent("headerRowMouseoverEvent",{target:elTarget,event:e});
1930 }
1931 else {
1932 oSelf.fireEvent("rowMouseoverEvent",{target:elTarget,event:e});
1933 }
1934 break;
1935 default:
1936 break;
1937 }
1938 elTarget = elTarget.parentNode;
1939 if(elTarget) {
1940 elTag = elTarget.tagName.toLowerCase();
1941 }
1942 }
1943 oSelf.fireEvent("tableMouseoverEvent",{target:(elTarget || oSelf._elTable),event:e});
1944 };
1945
1946 /**
1947 * Handles mouseout events on the TABLE element.
1948 *
1949 * @method _onTableMouseout
1950 * @param e {HTMLEvent} The mouseout event.
1951 * @param oSelf {YAHOO.widget.DataTable} DataTable instance.
1952 * @private
1953 */
1954 YAHOO.widget.DataTable.prototype._onTableMouseout = function(e, oSelf) {
1955 var elTarget = YAHOO.util.Event.getTarget(e);
1956 var elTag = elTarget.tagName.toLowerCase();
1957
1958 while(elTarget && (elTag != "table")) {
1959 switch(elTag) {
1960 case "body":
1961 break;
1962 case "a":
1963 break;
1964 case "td":
1965 oSelf.fireEvent("cellMouseoutEvent",{target:elTarget,event:e});
1966 break;
1967 case "span":
1968 if(YAHOO.util.Dom.hasClass(elTarget, YAHOO.widget.DataTable.CLASS_LABEL)) {
1969 oSelf.fireEvent("headerLabelMouseoutEvent",{target:elTarget,event:e});
1970 }
1971 break;
1972 case "th":
1973 oSelf.fireEvent("headerCellMouseoutEvent",{target:elTarget,event:e});
1974 break;
1975 case "tr":
1976 if(elTarget.parentNode.tagName.toLowerCase() == "thead") {
1977 oSelf.fireEvent("headerRowMouseoutEvent",{target:elTarget,event:e});
1978 }
1979 else {
1980 oSelf.fireEvent("rowMouseoutEvent",{target:elTarget,event:e});
1981 }
1982 break;
1983 default:
1984 break;
1985 }
1986 elTarget = elTarget.parentNode;
1987 if(elTarget) {
1988 elTag = elTarget.tagName.toLowerCase();
1989 }
1990 }
1991 oSelf.fireEvent("tableMouseoutEvent",{target:(elTarget || oSelf._elTable),event:e});
1992 };
1993
1994 /**
1995 * Handles mousedown events on the TABLE element.
1996 *
1997 * @method _onTableMousedown
1998 * @param e {HTMLEvent} The mousedown event.
1999 * @param oSelf {YAHOO.widget.DataTable} DataTable instance.
2000 * @private
2001 */
2002 YAHOO.widget.DataTable.prototype._onTableMousedown = function(e, oSelf) {
2003 var elTarget = YAHOO.util.Event.getTarget(e);
2004 var elTag = elTarget.tagName.toLowerCase();
2005
2006 while(elTarget && (elTag != "table")) {
2007 switch(elTag) {
2008 case "body":
2009 break;
2010 case "a":
2011 break;
2012 case "td":
2013 oSelf.fireEvent("cellMousedownEvent",{target:elTarget,event:e});
2014 break;
2015 case "span":
2016 if(YAHOO.util.Dom.hasClass(elTarget, YAHOO.widget.DataTable.CLASS_LABEL)) {
2017 oSelf.fireEvent("headerLabelMousedownEvent",{target:elTarget,event:e});
2018 }
2019 break;
2020 case "th":
2021 oSelf.fireEvent("headerCellMousedownEvent",{target:elTarget,event:e});
2022 break;
2023 case "tr":
2024 if(elTarget.parentNode.tagName.toLowerCase() == "thead") {
2025 oSelf.fireEvent("headerRowMousedownEvent",{target:elTarget,event:e});
2026 }
2027 else {
2028 oSelf.fireEvent("rowMousedownEvent",{target:elTarget,event:e});
2029 }
2030 break;
2031 default:
2032 break;
2033 }
2034 elTarget = elTarget.parentNode;
2035 if(elTarget) {
2036 elTag = elTarget.tagName.toLowerCase();
2037 }
2038 }
2039 oSelf.fireEvent("tableMousedownEvent",{target:(elTarget || oSelf._elTable),event:e});
2040 };
2041
2042 /**
2043 * Handles dblclick events on the TABLE element.
2044 *
2045 * @method _onTableDblclick
2046 * @param e {HTMLEvent} The dblclick event.
2047 * @param oSelf {YAHOO.widget.DataTable} DataTable instance.
2048 * @private
2049 */
2050 YAHOO.widget.DataTable.prototype._onTableDblclick = function(e, oSelf) {
2051 var elTarget = YAHOO.util.Event.getTarget(e);
2052 var elTag = elTarget.tagName.toLowerCase();
2053
2054 while(elTarget && (elTag != "table")) {
2055 switch(elTag) {
2056 case "body":
2057 break;
2058 case "td":
2059 oSelf.fireEvent("cellDblclickEvent",{target:elTarget,event:e});
2060 break;
2061 case "span":
2062 if(YAHOO.util.Dom.hasClass(elTarget, YAHOO.widget.DataTable.CLASS_LABEL)) {
2063 oSelf.fireEvent("headerLabelDblclickEvent",{target:elTarget,event:e});
2064 }
2065 break;
2066 case "th":
2067 oSelf.fireEvent("headerCellDblclickEvent",{target:elTarget,event:e});
2068 break;
2069 case "tr":
2070 if(elTarget.parentNode.tagName.toLowerCase() == "thead") {
2071 oSelf.fireEvent("headerRowDblclickEvent",{target:elTarget,event:e});
2072 }
2073 else {
2074 oSelf.fireEvent("rowDblclickEvent",{target:elTarget,event:e});
2075 }
2076 break;
2077 default:
2078 break;
2079 }
2080 elTarget = elTarget.parentNode;
2081 if(elTarget) {
2082 elTag = elTarget.tagName.toLowerCase();
2083 }
2084 }
2085 oSelf.fireEvent("tableDblclickEvent",{target:(elTarget || oSelf._elTable),event:e});
2086 };
2087
2088 /**
2089 * Handles keydown events on the TABLE element. Handles arrow selection.
2090 *
2091 * @method _onTableKeydown
2092 * @param e {HTMLEvent} The key event.
2093 * @param oSelf {YAHOO.widget.DataTable} DataTable instance.
2094 * @private
2095 */
2096 YAHOO.widget.DataTable.prototype._onTableKeydown = function(e, oSelf) {
2097 var bSHIFT = e.shiftKey;
2098 var elTarget = YAHOO.util.Event.getTarget(e);
2099
2100 // Ignore actions in the THEAD
2101 if(YAHOO.util.Dom.isAncestor(oSelf._elThead, elTarget)) {
2102 return;
2103 }
2104
2105 var nKey = YAHOO.util.Event.getCharCode(e);
2106
2107 // TAB to first label link if any
2108 if(nKey === 9 && !bSHIFT && (elTarget.id === oSelf._elTable.id)) {
2109 if(oSelf._sFirstLabelLinkId) {
2110 YAHOO.util.Event.stopEvent(e);
2111 oSelf._focusEl(YAHOO.util.Dom.get(oSelf._sFirstLabelLinkId));
2112 }
2113 return;
2114 }
2115
2116 // Something is currently selected
2117 var lastSelectedId = oSelf._sLastSelectedId;
2118 var lastSelectedEl = YAHOO.util.Dom.get(lastSelectedId);
2119 if(lastSelectedEl && oSelf.isSelected(lastSelectedEl)) {
2120 //TODO: handle tab, backspace, delete
2121
2122 // Handle arrow selection
2123 if((nKey > 36) && (nKey < 41)) {
2124 YAHOO.util.Event.stopEvent(e);
2125 }
2126 else {
2127 return;
2128 }
2129
2130 var sMode = oSelf.get("selectionMode");
2131 var allRows = oSelf._elTbody.rows;
2132 var anchorId = oSelf._sSelectionAnchorId;
2133 var anchorEl = YAHOO.util.Dom.get(anchorId);
2134 var newSelectedEl, trIndex, tdIndex, startIndex, endIndex, i, anchorPos;
2135
2136 ////////////////////////////////////////////////////////////////////////
2137 //
2138 // SHIFT cell block selection
2139 //
2140 ////////////////////////////////////////////////////////////////////////
2141 if(bSHIFT && (sMode == "cellblock")) {
2142 trIndex = lastSelectedEl.parentNode.sectionRowIndex;
2143 tdIndex = lastSelectedEl.yuiCellIndex;
2144
2145 // Arrow DOWN
2146 if(nKey == 40) {
2147 // Is the anchor cell above, below, or same row
2148 if(anchorEl.parentNode.sectionRowIndex > trIndex) {
2149 anchorPos = 1;
2150 }
2151 else if(anchorEl.parentNode.sectionRowIndex < trIndex) {
2152 anchorPos = -1;
2153 }
2154 else {
2155 anchorPos = 0;
2156 }
2157
2158 // Is the anchor cell left or right
2159 startIndex = Math.min(anchorEl.yuiCellIndex, tdIndex);
2160 endIndex = Math.max(anchorEl.yuiCellIndex, tdIndex);
2161
2162 // Selecting away from anchor cell
2163 if(anchorPos <= 0) {
2164 // Select the horiz block on the next row
2165 if(trIndex < allRows.length-1) {
2166 for(i=startIndex; i<=endIndex; i++) {
2167 newSelectedEl = allRows[trIndex+1].cells[i];
2168 oSelf.selectCell(newSelectedEl);
2169 }
2170 oSelf._sLastSelectedId = allRows[trIndex+1].cells[tdIndex].id;
2171 }
2172 }
2173 // Unselecting towards anchor cell
2174 else {
2175 // Unselect the horiz block on this row towards the next row
2176 for(i=startIndex; i<=endIndex; i++) {
2177 oSelf.unselectCell(allRows[trIndex].cells[i]);
2178 }
2179 oSelf._sLastSelectedId = allRows[trIndex+1].cells[tdIndex].id;
2180 }
2181 }
2182 // Arrow up
2183 else if(nKey == 38) {
2184 // Is the anchor cell above, below, or same row
2185 if(anchorEl.parentNode.sectionRowIndex > trIndex) {
2186 anchorPos = 1;
2187 }
2188 else if(anchorEl.parentNode.sectionRowIndex < trIndex) {
2189 anchorPos = -1;
2190 }
2191 else {
2192 anchorPos = 0;
2193 }
2194
2195 // Is the anchor cell left or right?
2196 startIndex = Math.min(anchorEl.yuiCellIndex, tdIndex);
2197 endIndex = Math.max(anchorEl.yuiCellIndex, tdIndex);
2198
2199 // Selecting away from anchor cell
2200 if(anchorPos >= 0) {
2201 // Select the horiz block on the previous row
2202 if(trIndex > 0) {
2203 for(i=startIndex; i<=endIndex; i++) {
2204 newSelectedEl = allRows[trIndex-1].cells[i];
2205 oSelf.selectCell(newSelectedEl);
2206 }
2207 oSelf._sLastSelectedId = allRows[trIndex-1].cells[tdIndex].id;
2208 }
2209 }
2210 // Unselecting towards anchor cell
2211 else {
2212 // Unselect the horiz block on this row towards the previous row
2213 for(i=startIndex; i<=endIndex; i++) {
2214 oSelf.unselectCell(allRows[trIndex].cells[i]);
2215 }
2216 oSelf._sLastSelectedId = allRows[trIndex-1].cells[tdIndex].id;
2217 }
2218 }
2219 // Arrow right
2220 else if(nKey == 39) {
2221 // Is the anchor cell left, right, or same column
2222 if(anchorEl.yuiCellIndex > tdIndex) {
2223 anchorPos = 1;
2224 }
2225 else if(anchorEl.yuiCellIndex < tdIndex) {
2226 anchorPos = -1;
2227 }
2228 else {
2229 anchorPos = 0;
2230 }
2231
2232 // Selecting away from anchor cell
2233 if(anchorPos <= 0) {
2234 //Select the next vert block to the right
2235 if(tdIndex < allRows[trIndex].cells.length-1) {
2236 startIndex = Math.min(anchorEl.parentNode.sectionRowIndex, trIndex);
2237 endIndex = Math.max(anchorEl.parentNode.sectionRowIndex, trIndex);
2238 for(i=startIndex; i<=endIndex; i++) {
2239 newSelectedEl = allRows[i].cells[tdIndex+1];
2240 oSelf.selectCell(newSelectedEl);
2241 }
2242 oSelf._sLastSelectedId = allRows[trIndex].cells[tdIndex+1].id;
2243 }
2244 }
2245 // Unselecting towards anchor cell
2246 else {
2247 // Unselect the vert block on this column towards the right
2248 startIndex = Math.min(anchorEl.parentNode.sectionRowIndex, trIndex);
2249 endIndex = Math.max(anchorEl.parentNode.sectionRowIndex, trIndex);
2250 for(i=startIndex; i<=endIndex; i++) {
2251 oSelf.unselectCell(allRows[i].cells[tdIndex]);
2252 }
2253 oSelf._sLastSelectedId = allRows[trIndex].cells[tdIndex+1].id;
2254 }
2255 }
2256 // Arrow left
2257 else if(nKey == 37) {
2258 // Is the anchor cell left, right, or same column
2259 if(anchorEl.yuiCellIndex > tdIndex) {
2260 anchorPos = 1;
2261 }
2262 else if(anchorEl.yuiCellIndex < tdIndex) {
2263 anchorPos = -1;
2264 }
2265 else {
2266 anchorPos = 0;
2267 }
2268
2269 // Selecting away from anchor cell
2270 if(anchorPos >= 0) {
2271 //Select the previous vert block to the left
2272 if(tdIndex > 0) {
2273 startIndex = Math.min(anchorEl.parentNode.sectionRowIndex, trIndex);
2274 endIndex = Math.max(anchorEl.parentNode.sectionRowIndex, trIndex);
2275 for(i=startIndex; i<=endIndex; i++) {
2276 newSelectedEl = allRows[i].cells[tdIndex-1];
2277 oSelf.selectCell(newSelectedEl);
2278 }
2279 oSelf._sLastSelectedId = allRows[trIndex].cells[tdIndex-1].id;
2280 }
2281 }
2282 // Unselecting towards anchor cell
2283 else {
2284 // Unselect the vert block on this column towards the left
2285 startIndex = Math.min(anchorEl.parentNode.sectionRowIndex, trIndex);
2286 endIndex = Math.max(anchorEl.parentNode.sectionRowIndex, trIndex);
2287 for(i=startIndex; i<=endIndex; i++) {
2288 oSelf.unselectCell(allRows[i].cells[tdIndex]);
2289 }
2290 oSelf._sLastSelectedId = allRows[trIndex].cells[tdIndex-1].id;
2291 }
2292 }
2293 }
2294 ////////////////////////////////////////////////////////////////////////
2295 //
2296 // SHIFT cell range selection
2297 //
2298 ////////////////////////////////////////////////////////////////////////
2299 else if(bSHIFT && (sMode == "cellrange")) {
2300 trIndex = lastSelectedEl.parentNode.sectionRowIndex;
2301 tdIndex = lastSelectedEl.yuiCellIndex;
2302
2303 // Is the anchor cell above, below, or same row
2304 if(anchorEl.parentNode.sectionRowIndex > trIndex) {
2305 anchorPos = 1;
2306 }
2307 else if(anchorEl.parentNode.sectionRowIndex < trIndex) {
2308 anchorPos = -1;
2309 }
2310 else {
2311 anchorPos = 0;
2312 }
2313
2314 // Arrow down
2315 if(nKey == 40) {
2316 // Selecting away from anchor cell
2317 if(anchorPos <= 0) {
2318 // Select all cells to the end of this row
2319 for(i=tdIndex+1; i<allRows[trIndex].cells.length; i++){
2320 newSelectedEl = allRows[trIndex].cells[i];
2321 oSelf.selectCell(newSelectedEl);
2322 }
2323
2324 // Select some of the cells on the next row down
2325 if(trIndex < allRows.length-1) {
2326 for(i=0; i<=tdIndex; i++){
2327 newSelectedEl = allRows[trIndex+1].cells[i];
2328 oSelf.selectCell(newSelectedEl);
2329 }
2330 }
2331 }
2332 // Unselecting towards anchor cell
2333 else {
2334 // Unselect all cells to the end of this row
2335 for(i=tdIndex; i<allRows[trIndex].cells.length; i++){
2336 oSelf.unselectCell(allRows[trIndex].cells[i]);
2337 }
2338
2339 // Unselect some of the cells on the next row down
2340 for(i=0; i<tdIndex; i++){
2341 oSelf.unselectCell(allRows[trIndex+1].cells[i]);
2342 }
2343 oSelf._sLastSelectedId = allRows[trIndex+1].cells[tdIndex].id;
2344 }
2345 }
2346 // Arrow up
2347 else if(nKey == 38) {
2348 // Selecting away from anchor cell
2349 if(anchorPos >= 0) {
2350 // Select all the cells to the beginning of this row
2351 for(i=tdIndex-1; i>-1; i--){
2352 newSelectedEl = allRows[trIndex].cells[i];
2353 oSelf.selectCell(newSelectedEl);
2354 }
2355
2356 // Select some of the cells from the end of the previous row
2357 if(trIndex > 0) {
2358 for(i=allRows[trIndex].cells.length-1; i>=tdIndex; i--){
2359 newSelectedEl = allRows[trIndex-1].cells[i];
2360 oSelf.selectCell(newSelectedEl);
2361 }
2362 }
2363 }
2364 // Unselecting towards anchor cell
2365 else {
2366 // Unselect all the cells to the beginning of this row
2367 for(i=tdIndex; i>-1; i--){
2368 oSelf.unselectCell(allRows[trIndex].cells[i]);
2369 }
2370
2371 // Unselect some of the cells from the end of the previous row
2372 for(i=allRows[trIndex].cells.length-1; i>tdIndex; i--){
2373 oSelf.unselectCell(allRows[trIndex-1].cells[i]);
2374 }
2375 oSelf._sLastSelectedId = allRows[trIndex-1].cells[tdIndex].id;
2376 }
2377 }
2378 // Arrow right
2379 else if(nKey == 39) {
2380 // Selecting away from anchor cell
2381 if(anchorPos < 0) {
2382 // Select the next cell to the right
2383 if(tdIndex < allRows[trIndex].cells.length-1) {
2384 newSelectedEl = allRows[trIndex].cells[tdIndex+1];
2385 oSelf.selectCell(newSelectedEl);
2386 }
2387 // Select the first cell of the next row
2388 else if(trIndex < allRows.length-1) {
2389 newSelectedEl = allRows[trIndex+1].cells[0];
2390 oSelf.selectCell(newSelectedEl);
2391 }
2392 }
2393 // Unselecting towards anchor cell
2394 else if(anchorPos > 0) {
2395 oSelf.unselectCell(allRows[trIndex].cells[tdIndex]);
2396
2397 // Unselect this cell towards the right
2398 if(tdIndex < allRows[trIndex].cells.length-1) {
2399 oSelf._sLastSelectedId = allRows[trIndex].cells[tdIndex+1].id;
2400 }
2401 // Unselect this cells towards the first cell of the next row
2402 else {
2403 oSelf._sLastSelectedId = allRows[trIndex+1].cells[0].id;
2404 }
2405 }
2406 // Anchor is on this row
2407 else {
2408 // Selecting away from anchor
2409 if(anchorEl.yuiCellIndex <= tdIndex) {
2410 // Select the next cell to the right
2411 if(tdIndex < allRows[trIndex].cells.length-1) {
2412 newSelectedEl = allRows[trIndex].cells[tdIndex+1];
2413 oSelf.selectCell(newSelectedEl);
2414 }
2415 // Select the first cell on the next row
2416 else if(trIndex < allRows.length-1){
2417 newSelectedEl = allRows[trIndex+1].cells[0];
2418 oSelf.selectCell(newSelectedEl);
2419 }
2420 }
2421 // Unselecting towards anchor
2422 else {
2423 // Unselect this cell towards the right
2424 oSelf.unselectCell(allRows[trIndex].cells[tdIndex]);
2425 oSelf._sLastSelectedId = allRows[trIndex].cells[tdIndex+1].id;
2426 }
2427 }
2428 }
2429 // Arrow left
2430 else if(nKey == 37) {
2431 // Unselecting towards the anchor
2432 if(anchorPos < 0) {
2433 oSelf.unselectCell(allRows[trIndex].cells[tdIndex]);
2434
2435 // Unselect this cell towards the left
2436 if(tdIndex > 0) {
2437 oSelf._sLastSelectedId = allRows[trIndex].cells[tdIndex-1].id;
2438 }
2439 // Unselect this cell towards the last cell of the previous row
2440 else {
2441 oSelf._sLastSelectedId = allRows[trIndex-1].cells[allRows[trIndex-1].cells.length-1].id;
2442 }
2443 }
2444 // Selecting towards the anchor
2445 else if(anchorPos > 0) {
2446 // Select the next cell to the left
2447 if(tdIndex > 0) {
2448 newSelectedEl = allRows[trIndex].cells[tdIndex-1];
2449 oSelf.selectCell(newSelectedEl);
2450 }
2451 // Select the last cell of the previous row
2452 else if(trIndex > 0){
2453 newSelectedEl = allRows[trIndex-1].cells[allRows[trIndex-1].cells.length-1];
2454 oSelf.selectCell(newSelectedEl);
2455 }
2456 }
2457 // Anchor is on this row
2458 else {
2459 // Selecting away from anchor cell
2460 if(anchorEl.yuiCellIndex >= tdIndex) {
2461 // Select the next cell to the left
2462 if(tdIndex > 0) {
2463 newSelectedEl = allRows[trIndex].cells[tdIndex-1];
2464 oSelf.selectCell(newSelectedEl);
2465 }
2466 // Select the last cell of the previous row
2467 else if(trIndex > 0){
2468 newSelectedEl = allRows[trIndex-1].cells[allRows[trIndex-1].cells.length-1];
2469 oSelf.selectCell(newSelectedEl);
2470 }
2471 }
2472 // Unselecting towards anchor cell
2473 else {
2474 oSelf.unselectCell(allRows[trIndex].cells[tdIndex]);
2475
2476 // Unselect this cell towards the left
2477 if(tdIndex > 0) {
2478 oSelf._sLastSelectedId = allRows[trIndex].cells[tdIndex-1].id;
2479 }
2480 // Unselect this cell towards the last cell of the previous row
2481 else {
2482 oSelf._sLastSelectedId = allRows[trIndex-1].cells[allRows[trIndex-1].cells.length-1].id;
2483 }
2484 }
2485 }
2486 }
2487 }
2488 ////////////////////////////////////////////////////////////////////////
2489 //
2490 // Simple single cell selection
2491 //
2492 ////////////////////////////////////////////////////////////////////////
2493 else if((sMode == "cellblock") || (sMode == "cellrange") || (sMode == "singlecell")) {
2494 trIndex = lastSelectedEl.parentNode.sectionRowIndex;
2495 tdIndex = lastSelectedEl.yuiCellIndex;
2496
2497 // Arrow down
2498 if(nKey == 40) {
2499 oSelf.unselectAllCells();
2500
2501 // Select the next cell down
2502 if(trIndex < allRows.length-1) {
2503 newSelectedEl = allRows[trIndex+1].cells[tdIndex];
2504 oSelf.selectCell(newSelectedEl);
2505 }
2506 // Select only the bottom cell
2507 else {
2508 newSelectedEl = lastSelectedEl;
2509 oSelf.selectCell(newSelectedEl);
2510 }
2511
2512 oSelf._sSelectionAnchorId = newSelectedEl.id;
2513 }
2514 // Arrow up
2515 else if(nKey == 38) {
2516 oSelf.unselectAllCells();
2517
2518 // Select the next cell up
2519 if(trIndex > 0) {
2520 newSelectedEl = allRows[trIndex-1].cells[tdIndex];
2521 oSelf.selectCell(newSelectedEl);
2522 }
2523 // Select only the top cell
2524 else {
2525 newSelectedEl = lastSelectedEl;
2526 oSelf.selectCell(newSelectedEl);
2527 }
2528
2529 oSelf._sSelectionAnchorId = newSelectedEl.id;
2530 }
2531 // Arrow right
2532 else if(nKey == 39) {
2533 oSelf.unselectAllCells();
2534
2535 // Select the next cell to the right
2536 if(tdIndex < lastSelectedEl.parentNode.cells.length-1) {
2537 newSelectedEl = lastSelectedEl.parentNode.cells[tdIndex+1];
2538 oSelf.selectCell(newSelectedEl);
2539 }
2540 // Select only the right cell
2541 else {
2542 newSelectedEl = lastSelectedEl;
2543 oSelf.selectCell(newSelectedEl);
2544 }
2545
2546 oSelf._sSelectionAnchorId = newSelectedEl.id;
2547 }
2548 // Arrow left
2549 else if(nKey == 37) {
2550 oSelf.unselectAllCells();
2551
2552 // Select the next cell to the left
2553 if(tdIndex > 0) {
2554 newSelectedEl = lastSelectedEl.parentNode.cells[tdIndex-1];
2555 oSelf.selectCell(newSelectedEl);
2556 }
2557 // Select only the left cell
2558 else {
2559 newSelectedEl = lastSelectedEl;
2560 oSelf.selectCell(newSelectedEl);
2561 }
2562
2563 oSelf._sSelectionAnchorId = newSelectedEl.id;
2564 }
2565 }
2566 ////////////////////////////////////////////////////////////////////////
2567 //
2568 // SHIFT row selection
2569 //
2570 ////////////////////////////////////////////////////////////////////////
2571 else if(bSHIFT && (sMode != "single")) {
2572 trIndex = lastSelectedEl.sectionRowIndex;
2573
2574 if(anchorEl.sectionRowIndex > trIndex) {
2575 anchorPos = 1;
2576 }
2577 else if(anchorEl.sectionRowIndex < trIndex) {
2578 anchorPos = -1;
2579 }
2580 else {
2581 anchorPos = 0;
2582 }
2583
2584 // Arrow down
2585 if(nKey == 40) {
2586 // Selecting away from anchor row
2587 if(anchorPos <= 0) {
2588 // Select the next row down
2589 if(trIndex < allRows.length-1) {
2590 oSelf.selectRow(trIndex+1);
2591 }
2592 }
2593 // Unselecting toward anchor row
2594 else {
2595 // Unselect this row towards the anchor row down
2596 oSelf.unselectRow(lastSelectedEl);
2597 oSelf._sLastSelectedId = allRows[trIndex+1].id;
2598 }
2599
2600 }
2601 // Arrow up
2602 else if(nKey == 38) {
2603 // Selecting away from anchor row
2604 if(anchorPos >= 0) {
2605 // Select the next row up
2606 if(trIndex > 0) {
2607 oSelf.selectRow(trIndex-1);
2608 }
2609 }
2610 // Unselect this row towards the anchor row up
2611 else {
2612 oSelf.unselectRow(lastSelectedEl);
2613 oSelf._sLastSelectedId = allRows[trIndex-1].id;
2614 }
2615 }
2616 // Arrow right
2617 else if(nKey == 39) {
2618 // Do nothing
2619 }
2620 // Arrow left
2621 else if(nKey == 37) {
2622 // Do nothing
2623 }
2624 }
2625 ////////////////////////////////////////////////////////////////////////
2626 //
2627 // Simple single row selection
2628 //
2629 ////////////////////////////////////////////////////////////////////////
2630 else {
2631 trIndex = lastSelectedEl.sectionRowIndex;
2632
2633 // Arrow down
2634 if(nKey == 40) {
2635 oSelf.unselectAllRows();
2636
2637 // Select the next row
2638 if(trIndex < allRows.length-1) {
2639 newSelectedEl = allRows[trIndex+1];
2640 oSelf.selectRow(newSelectedEl);
2641 }
2642 // Select only the last row
2643 else {
2644 newSelectedEl = lastSelectedEl;
2645 oSelf.selectRow(lastSelectedEl);
2646 }
2647
2648 oSelf._sSelectionAnchorId = newSelectedEl.id;
2649 }
2650 // Arrow up
2651 else if(nKey == 38) {
2652 oSelf.unselectAllRows();
2653
2654 // Select the previous row
2655 if(trIndex > 0) {
2656 newSelectedEl = allRows[trIndex-1];
2657 oSelf.selectRow(newSelectedEl);
2658 }
2659 // Select only the first row
2660 else {
2661 newSelectedEl = lastSelectedEl;
2662 oSelf.selectRow(newSelectedEl);
2663 }
2664
2665 oSelf._sSelectionAnchorId = newSelectedEl.id;
2666 }
2667 // Arrow right
2668 else if(nKey == 39) {
2669 // Do nothing
2670 }
2671 // Arrow left
2672 else if(nKey == 37) {
2673 // Do nothing
2674 }
2675 }
2676 }
2677 };
2678
2679 /**
2680 * Handles keypress events on the TABLE. Mainly to support stopEvent on Mac.
2681 *
2682 * @method _onTableKeypress
2683 * @param e {HTMLEvent} The key event.
2684 * @param oSelf {YAHOO.widget.DataTable} DataTable instance.
2685 * @private
2686 */
2687 YAHOO.widget.DataTable.prototype._onTableKeypress = function(e, oSelf) {
2688 var isMac = (navigator.userAgent.toLowerCase().indexOf("mac") != -1);
2689 if(isMac) {
2690 var nKey = YAHOO.util.Event.getCharCode(e);
2691 // arrow down
2692 if(nKey == 40) {
2693 YAHOO.util.Event.stopEvent(e);
2694 }
2695 // arrow up
2696 else if(nKey == 38) {
2697 YAHOO.util.Event.stopEvent(e);
2698 }
2699 }
2700 };
2701
2702 /**
2703 * Handles click events on the THEAD element.
2704 *
2705 * @method _onTheadClick
2706 * @param e {HTMLEvent} The click event.
2707 * @param oSelf {YAHOO.widget.DataTable} DataTable instance.
2708 * @private
2709 */
2710 YAHOO.widget.DataTable.prototype._onTheadClick = function(e, oSelf) {
2711 var elTarget = YAHOO.util.Event.getTarget(e);
2712 var elTag = elTarget.tagName.toLowerCase();
2713
2714 if(oSelf._oCellEditor && oSelf._oCellEditor.isActive) {
2715 oSelf.fireEvent("editorBlurEvent", {editor:oSelf._oCellEditor});
2716 }
2717
2718 while(elTarget && (elTag != "thead")) {
2719 switch(elTag) {
2720 case "body":
2721 break;
2722 case "span":
2723 if(YAHOO.util.Dom.hasClass(elTarget, YAHOO.widget.DataTable.CLASS_LABEL)) {
2724 oSelf.fireEvent("headerLabelClickEvent",{target:elTarget,event:e});
2725 }
2726 break;
2727 case "th":
2728 oSelf.fireEvent("headerCellClickEvent",{target:elTarget,event:e});
2729 break;
2730 case "tr":
2731 oSelf.fireEvent("headerRowClickEvent",{target:elTarget,event:e});
2732 break;
2733 default:
2734 break;
2735 }
2736 elTarget = elTarget.parentNode;
2737 if(elTarget) {
2738 elTag = elTarget.tagName.toLowerCase();
2739 }
2740 }
2741 oSelf.fireEvent("tableClickEvent",{target:(elTarget || oSelf._elTable),event:e});
2742 };
2743
2744 /**
2745 * Handles click events on the primary TBODY element.
2746 *
2747 * @method _onTbodyClick
2748 * @param e {HTMLEvent} The click event.
2749 * @param oSelf {YAHOO.widget.DataTable} DataTable instance.
2750 * @private
2751 */
2752 YAHOO.widget.DataTable.prototype._onTbodyClick = function(e, oSelf) {
2753 var elTarget = YAHOO.util.Event.getTarget(e);
2754 var elTag = elTarget.tagName.toLowerCase();
2755
2756 if(oSelf._oCellEditor && oSelf._oCellEditor.isActive) {
2757 oSelf.fireEvent("editorBlurEvent", {editor:oSelf._oCellEditor});
2758 }
2759
2760 while(elTarget && (elTag != "table")) {
2761 switch(elTag) {
2762 case "body":
2763 break;
2764 case "input":
2765 if(elTarget.type.toLowerCase() == "checkbox") {
2766 oSelf.fireEvent("checkboxClickEvent",{target:elTarget,event:e});
2767 }
2768 else if(elTarget.type.toLowerCase() == "radio") {
2769 oSelf.fireEvent("radioClickEvent",{target:elTarget,event:e});
2770 }
2771 break;
2772 case "a":
2773 oSelf.fireEvent("linkClickEvent",{target:elTarget,event:e});
2774 break;
2775 case "button":
2776 oSelf.fireEvent("buttonClickEvent",{target:elTarget,event:e});
2777 break;
2778 case "td":
2779 oSelf.fireEvent("cellClickEvent",{target:elTarget,event:e});
2780 break;
2781 case "tr":
2782 oSelf.fireEvent("rowClickEvent",{target:elTarget,event:e});
2783 break;
2784 default:
2785 break;
2786 }
2787 elTarget = elTarget.parentNode;
2788 if(elTarget) {
2789 elTag = elTarget.tagName.toLowerCase();
2790 }
2791 }
2792 oSelf.fireEvent("tableClickEvent",{target:(elTarget || oSelf._elTable),event:e});
2793 };
2794
2795 /*TODO: delete
2796 * Handles keyup events on the TBODY. Executes deletion.
2797 *
2798 * @method _onTbodyKeyup
2799 * @param e {HTMLEvent} The key event.
2800 * @param oSelf {YAHOO.widget.DataTable} DataTable instance.
2801 * @private
2802 */
2803 /*YAHOO.widget.DataTable.prototype._onTbodyKeyup = function(e, oSelf) {
2804 var nKey = YAHOO.util.Event.getCharCode(e);
2805 // delete
2806 if(nKey == 46) {//TODO: if something is selected
2807 //TODO: delete row
2808 }
2809 };*/
2810
2811 /**
2812 * Handles click events on paginator links.
2813 *
2814 * @method _onPaginatorLinkClick
2815 * @param e {HTMLEvent} The click event.
2816 * @param oSelf {YAHOO.widget.DataTable} DataTable instance.
2817 * @private
2818 */
2819 YAHOO.widget.DataTable.prototype._onPaginatorLinkClick = function(e, oSelf) {
2820 var elTarget = YAHOO.util.Event.getTarget(e);
2821 var elTag = elTarget.tagName.toLowerCase();
2822
2823 if(oSelf._oCellEditor && oSelf._oCellEditor.isActive) {
2824 oSelf.fireEvent("editorBlurEvent", {editor:oSelf._oCellEditor});
2825 }
2826
2827 while(elTarget && (elTag != "table")) {
2828 switch(elTag) {
2829 case "body":
2830 return;
2831 case "a":
2832 YAHOO.util.Event.stopEvent(e);
2833 //TODO: after the showPage call, figure out which link
2834 //TODO: was clicked and reset focus to the new version of it
2835 switch(elTarget.className) {
2836 case YAHOO.widget.DataTable.CLASS_PAGE:
2837 oSelf.showPage(parseInt(elTarget.innerHTML,10));
2838 return;
2839 case YAHOO.widget.DataTable.CLASS_FIRST:
2840 oSelf.showPage(1);
2841 return;
2842 case YAHOO.widget.DataTable.CLASS_LAST:
2843 oSelf.showPage(oSelf.get("paginator").totalPages);
2844 return;
2845 case YAHOO.widget.DataTable.CLASS_PREVIOUS:
2846 oSelf.showPage(oSelf.get("paginator").currentPage - 1);
2847 return;
2848 case YAHOO.widget.DataTable.CLASS_NEXT:
2849 oSelf.showPage(oSelf.get("paginator").currentPage + 1);
2850 return;
2851 }
2852 break;
2853 default:
2854 return;
2855 }
2856 elTarget = elTarget.parentNode;
2857 if(elTarget) {
2858 elTag = elTarget.tagName.toLowerCase();
2859 }
2860 else {
2861 return;
2862 }
2863 }
2864 };
2865
2866 /**
2867 * Handles change events on paginator SELECT element.
2868 *
2869 * @method _onPaginatorDropdownChange
2870 * @param e {HTMLEvent} The change event.
2871 * @param oSelf {YAHOO.widget.DataTable} DataTable instance.
2872 * @private
2873 */
2874 YAHOO.widget.DataTable.prototype._onPaginatorDropdownChange = function(e, oSelf) {
2875 var elTarget = YAHOO.util.Event.getTarget(e);
2876 var newValue = elTarget[elTarget.selectedIndex].value;
2877
2878 var newRowsPerPage = YAHOO.lang.isValue(parseInt(newValue,10)) ? parseInt(newValue,10) : null;
2879 if(newRowsPerPage !== null) {
2880 var newStartRecordIndex = (oSelf.get("paginator").currentPage-1) * newRowsPerPage;
2881 oSelf.updatePaginator({rowsPerPage:newRowsPerPage, startRecordIndex:newStartRecordIndex});
2882 oSelf.refreshView();
2883 }
2884 else {
2885 }
2886 };
2887
2888 /**
2889 * Handles change events on SELECT elements within DataTable.
2890 *
2891 * @method _onDropdownChange
2892 * @param e {HTMLEvent} The change event.
2893 * @param oSelf {YAHOO.widget.DataTable} DataTable instance.
2894 * @private
2895 */
2896 YAHOO.widget.DataTable.prototype._onDropdownChange = function(e, oSelf) {
2897 var elTarget = YAHOO.util.Event.getTarget(e);
2898 //TODO: pass what args?
2899 //var value = elTarget[elTarget.selectedIndex].value;
2900 oSelf.fireEvent("dropdownChangeEvent", {event:e, target:elTarget});
2901 };
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941 /////////////////////////////////////////////////////////////////////////////
2942 //
2943 // Public member variables
2944 //
2945 /////////////////////////////////////////////////////////////////////////////
2946
2947
2948 /////////////////////////////////////////////////////////////////////////////
2949 //
2950 // Public methods
2951 //
2952 /////////////////////////////////////////////////////////////////////////////
2953
2954 // OBJECT ACCESSORS
2955
2956 /**
2957 * Public accessor to the unique name of the DataSource instance.
2958 *
2959 * @method toString
2960 * @return {String} Unique name of the DataSource instance.
2961 */
2962
2963 YAHOO.widget.DataTable.prototype.toString = function() {
2964 return "DataTable " + this._sName;
2965 };
2966
2967 /**
2968 * Returns the DataTable instance's DataSource instance.
2969 *
2970 * @method getDataSource
2971 * @return {YAHOO.util.DataSource} DataSource instance.
2972 */
2973 YAHOO.widget.DataTable.prototype.getDataSource = function() {
2974 return this._oDataSource;
2975 };
2976
2977 /**
2978 * Returns the DataTable instance's ColumnSet instance.
2979 *
2980 * @method getColumnSet
2981 * @return {YAHOO.widget.ColumnSet} ColumnSet instance.
2982 */
2983 YAHOO.widget.DataTable.prototype.getColumnSet = function() {
2984 return this._oColumnSet;
2985 };
2986
2987 /**
2988 * Returns the DataTable instance's RecordSet instance.
2989 *
2990 * @method getRecordSet
2991 * @return {YAHOO.widget.RecordSet} RecordSet instance.
2992 */
2993 YAHOO.widget.DataTable.prototype.getRecordSet = function() {
2994 return this._oRecordSet;
2995 };
2996
2997 /**
2998 * Returns the DataTable instance's Cell Editor as an object literal with the
2999 * following properties:
3000 * <dl>
3001 * <dt>cell</dt>
3002 * <dd>Cell element being edited</dd>
3003 *
3004 * <dt>column</dt>
3005 * <dd>Associated Column instance</dd>
3006 *
3007 * <dt>container</dt>
3008 * <dd>Reference to editor's container DIV element</dd>
3009 *
3010 * <dt>isActive</dt>
3011 * <dd>True if cell is currently being edited</dd>
3012 *
3013 * <dt>record</dt>
3014 * <dd>Associated Record instance</dd>
3015 *
3016 * <dt>validator</dt>
3017 * <dd>Associated validator function</dd>
3018 *
3019 * <dt>value</dt>
3020 * <dd>Current input value</dd>
3021 * </dl>
3022 *
3023 *
3024 *
3025 *
3026 *
3027 *
3028 * @method getCellEditor
3029 * @return {Object} Cell Editor object literal values.
3030 */
3031 YAHOO.widget.DataTable.prototype.getCellEditor = function() {
3032 return this._oCellEditor;
3033 };
3034
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077 // DOM ACCESSORS
3078
3079 /**
3080 * Returns DOM reference to the DataTable's TABLE element.
3081 *
3082 * @method getTableEl
3083 * @return {HTMLElement} Reference to TABLE element.
3084 */
3085 YAHOO.widget.DataTable.prototype.getTableEl = function() {
3086 return this._elTable;
3087 };
3088
3089 /**
3090 * Returns DOM reference to the DataTable's THEAD element.
3091 *
3092 * @method getTheadEl
3093 * @return {HTMLElement} Reference to THEAD element.
3094 */
3095 YAHOO.widget.DataTable.prototype.getTheadEl = function() {
3096 return this._elThead;
3097 };
3098
3099 /**
3100 * Returns DOM reference to the DataTable's primary TBODY element.
3101 *
3102 * @method getTbodyEl
3103 * @return {HTMLElement} Reference to TBODY element.
3104 */
3105 YAHOO.widget.DataTable.prototype.getTbodyEl = function() {
3106 return this._elTbody;
3107 };
3108 // Backward compatibility
3109 YAHOO.widget.DataTable.prototype.getBody = function() {
3110 return this.getTbodyEl();
3111 };
3112
3113 /**
3114 * Returns DOM reference to the DataTable's secondary TBODY element that is
3115 * used to display messages.
3116 *
3117 * @method getMsgTbodyEl
3118 * @return {HTMLElement} Reference to TBODY element.
3119 */
3120 YAHOO.widget.DataTable.prototype.getMsgTbodyEl = function() {
3121 return this._elMsgTbody;
3122 };
3123
3124 /**
3125 * Returns DOM reference to the TD element within the secondary TBODY that is
3126 * used to display messages.
3127 *
3128 * @method getMsgTdEl
3129 * @return {HTMLElement} Reference to TD element.
3130 */
3131 YAHOO.widget.DataTable.prototype.getMsgTdEl = function() {
3132 return this._elMsgTd;
3133 };
3134
3135 /**
3136 * Returns the corresponding TR reference for a given DOM element, ID string or
3137 * directly page row index. If the given identifier is a child of a TR element,
3138 * then DOM tree is traversed until a parent TR element is returned, otherwise
3139 * null.
3140 *
3141 * @method getTrEl
3142 * @param row {HTMLElement | String | Number | YAHOO.widget.Record} Which row to
3143 * get: by element reference, ID string, page row index, or Record.
3144 * @return {HTMLElement} Reference to TR element, or null.
3145 */
3146 YAHOO.widget.DataTable.prototype.getTrEl = function(row) {
3147 var allRows = this._elTbody.rows;
3148
3149 // By Record
3150 if(row instanceof YAHOO.widget.Record) {
3151 var nTrIndex = this.getTrIndex(row);
3152 return allRows[nTrIndex];
3153 }
3154 // By page row index
3155 else if(YAHOO.lang.isNumber(row) && (row > -1) && (row < allRows.length)) {
3156 return allRows[row];
3157 }
3158 // By ID string or element reference
3159 else {
3160 var elRow;
3161 var el = YAHOO.util.Dom.get(row);
3162
3163 // Validate HTML element
3164 if(el && (el.ownerDocument == document)) {
3165 // Validate TR element
3166 if(el.tagName.toLowerCase() != "tr") {
3167 // Traverse up the DOM to find the corresponding TR element
3168 elRow = YAHOO.util.Dom.getAncestorByTagName(el,"tr");
3169 }
3170 else {
3171 elRow = el;
3172 }
3173
3174 // Make sure the TR is in this TBODY
3175 if(elRow && (elRow.parentNode == this._elTbody)) {
3176 // Now we can return the TR element
3177 return elRow;
3178 }
3179 }
3180 }
3181
3182 return null;
3183 };
3184 // Backward compatibility
3185 YAHOO.widget.DataTable.prototype.getRow = function(index) {
3186 return this.getTrEl(index);
3187 };
3188
3189 /**
3190 * Returns DOM reference to the first TR element in the DataTable page, or null.
3191 *
3192 * @method getFirstTrEl
3193 * @return {HTMLElement} Reference to TR element.
3194 */
3195 YAHOO.widget.DataTable.prototype.getFirstTrEl = function() {
3196 return this._elTbody.rows[0] || null;
3197 };
3198
3199 /**
3200 * Returns DOM reference to the last TR element in the DataTable page, or null.
3201 *
3202 * @method getLastTrEl
3203 * @return {HTMLElement} Reference to last TR element.
3204 */
3205 YAHOO.widget.DataTable.prototype.getLastTrEl = function() {
3206 var allRows = this._elTbody.rows;
3207 if(allRows.length > 0) {
3208 return allRows[allRows.length-1] || null;
3209 }
3210 };
3211
3212 /**
3213 * Returns DOM reference to the given TD element.
3214 *
3215 * @method getTdEl
3216 * @param cell {HTMLElement | String} DOM element reference or string ID.
3217 * @return {HTMLElement} Reference to TD element.
3218 */
3219 YAHOO.widget.DataTable.prototype.getTdEl = function(cell) {
3220 var elCell;
3221 var el = YAHOO.util.Dom.get(cell);
3222
3223 // Validate HTML element
3224 if(el && (el.ownerDocument == document)) {
3225 // Validate TD element
3226 if(el.tagName.toLowerCase() != "td") {
3227 // Traverse up the DOM to find the corresponding TR element
3228 elCell = YAHOO.util.Dom.getAncestorByTagName(el, "td");
3229 }
3230 else {
3231 elCell = el;
3232 }
3233
3234 // Make sure the TD is in this TBODY
3235 if(elCell && (elCell.parentNode.parentNode == this._elTbody)) {
3236 // Now we can return the TD element
3237 return elCell;
3238 }
3239 }
3240
3241 return null;
3242 };
3243
3244 /**
3245 * Returns DOM reference to the TH element at given DataTable page coordinates, or null.
3246 *
3247 * @method getThEl
3248 * @param header {HTMLElement | String | YAHOO.widget.Column} DOM element
3249 * reference or string ID, or Column instance.
3250 * @return {HTMLElement} Reference to TH element.
3251 */
3252 YAHOO.widget.DataTable.prototype.getThEl = function(header) {
3253 var elHeader;
3254
3255 // Validate Column instance
3256 if(header instanceof YAHOO.widget.Column) {
3257 var oColumn = header;
3258 elHeader = YAHOO.util.Dom.get(this.id + "-col" + oColumn.getId());
3259 if(elHeader) {
3260 return elHeader;
3261 }
3262 }
3263 // Validate HTML element
3264 else {
3265 var el = YAHOO.util.Dom.get(header);
3266
3267 if(el && (el.ownerDocument == document)) {
3268 // Validate TH element
3269 if(el.tagName.toLowerCase() != "th") {
3270 // Traverse up the DOM to find the corresponding TR element
3271 elHeader = YAHOO.util.Dom.getAncestorByTagName(el,"th");
3272 }
3273 else {
3274 elHeader = el;
3275 }
3276
3277 // Make sure the TH is in this THEAD
3278 if(elHeader && (elHeader.parentNode.parentNode == this._elThead)) {
3279 // Now we can return the TD element
3280 return elHeader;
3281 }
3282 }
3283 }
3284
3285 return null;
3286 };
3287
3288 /**
3289 * Returns the page row index of given row. Returns null if the row is not in
3290 * view on the current DataTable page.
3291 *
3292 * @method getTrIndex
3293 * @param row {HTMLElement | String | YAHOO.widget.Record | Number} DOM or ID
3294 * string reference to an element within the DataTable page, a Record instance,
3295 * or a Record's RecordSet index.
3296 * @return {Number} Page row index, or null if row does not exist or is not in view.
3297 */
3298 YAHOO.widget.DataTable.prototype.getTrIndex = function(row) {
3299 var nRecordIndex;
3300
3301 // By Record
3302 if(row instanceof YAHOO.widget.Record) {
3303 nRecordIndex = this._oRecordSet.getRecordIndex(row);
3304 }
3305 // Calculate page row index from Record index
3306 else if(YAHOO.lang.isNumber(row)) {
3307 nRecordIndex = row;
3308 }
3309 if(YAHOO.lang.isNumber(nRecordIndex)) {
3310 // DataTable is paginated
3311 if(this.get("paginated")) {
3312 // Get the first and last Record on this page
3313 var startRecordIndex = this.get("paginator").startRecordIndex;
3314 var endRecordIndex = startRecordIndex + this.get("paginator").rowsPerPage - 1;
3315 // This Record is in view
3316 if((nRecordIndex >= startRecordIndex) && (nRecordIndex <= endRecordIndex)) {
3317 return nRecordIndex - startRecordIndex;
3318 }
3319 // This Record is not in view
3320 else {
3321 return null;
3322 }
3323 }
3324 // Not paginated, just return the Record index
3325 else {
3326 return nRecordIndex;
3327 }
3328
3329 }
3330 // By element reference or ID string
3331 else {
3332 // Validate TR element
3333 elRow = this.getTrEl(row);
3334 if(elRow && (elRow.ownerDocument == document) &&
3335 (elRow.parentNode == this._elTbody)) {
3336 return elRow.sectionRowIndex;
3337 }
3338 }
3339
3340 return null;
3341 };
3342
3343
3344
3345
3346
3347
3348
3349
3350
3351
3352
3353
3354
3355
3356
3357
3358
3359
3360
3361
3362
3363
3364
3365
3366
3367
3368
3369
3370
3371
3372
3373
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383
3384
3385
3386
3387
3388 // TABLE FUNCTIONS
3389
3390 /**
3391 * Resets a RecordSet with the given data and populates the page view
3392 * with the new data. Any previous data and selection states are cleared.
3393 * However, sort states are not cleared, so if the given data is in a particular
3394 * sort order, implementers should take care to reset the sortedBy property. If
3395 * pagination is enabled, the currentPage is shown and Paginator UI updated,
3396 * otherwise all rows are displayed as a single page. For performance, existing
3397 * DOM elements are reused when possible.
3398 *
3399 * @method initializeTable
3400 * @param oData {Object | Object[]} An object literal of data or an array of
3401 * object literals containing data.
3402 */
3403 YAHOO.widget.DataTable.prototype.initializeTable = function(oData) {
3404 // Clear the RecordSet
3405 this._oRecordSet.reset();
3406
3407 // Add data to RecordSet
3408 var records = this._oRecordSet.addRecords(oData);
3409
3410 // Clear selections
3411 this._unselectAllTrEls();
3412 this._unselectAllTdEls();
3413 this._aSelections = null;
3414 this._sLastSelectedId = null;
3415 this._sSelectionAnchorId = null;
3416
3417 // Refresh the view
3418 this.refreshView();
3419 this.fireEvent("initEvent");
3420 };
3421
3422 /**
3423 * Refreshes the view with existing Records from the RecordSet while
3424 * maintaining sort, pagination, and selection states. For performance, reuses
3425 * existing DOM elements when possible while deleting extraneous elements.
3426 *
3427 * @method refreshView
3428 */
3429 YAHOO.widget.DataTable.prototype.refreshView = function() {
3430 var i, j, k, l, aRecords;
3431 var oPaginator = this.updatePaginator();
3432
3433 // Paginator is enabled, show a subset of Records and update Paginator UI
3434 if(this.get("paginated")) {
3435 var rowsPerPage = oPaginator.rowsPerPage;
3436 var startRecordIndex = (oPaginator.currentPage - 1) * rowsPerPage;
3437 aRecords = this._oRecordSet.getRecords(startRecordIndex, rowsPerPage);
3438 this.formatPaginators();
3439 }
3440 // Show all records
3441 else {
3442 aRecords = this._oRecordSet.getRecords();
3443 }
3444
3445 var elTbody = this._elTbody;
3446 var elRows = elTbody.rows;
3447
3448 // Has rows
3449 if(YAHOO.lang.isArray(aRecords) && (aRecords.length > 0)) {
3450 this.hideTableMessage();
3451
3452 // Keep track of selected rows
3453 var aSelectedRows = this.getSelectedRows();
3454 // Keep track of selected cells
3455 var aSelectedCells = this.getSelectedCells();
3456 // Anything to reinstate?
3457 var bReselect = (aSelectedRows.length>0) || (aSelectedCells.length > 0);
3458
3459 // Remove extra rows from the bottom so as to preserve ID order
3460 while(elTbody.hasChildNodes() && (elRows.length > aRecords.length)) {
3461 elTbody.deleteRow(-1);
3462 }
3463
3464 // Unselect all TR and TD elements in the UI
3465 if(bReselect) {
3466 this._unselectAllTrEls();
3467 this._unselectAllTdEls();
3468 }
3469
3470 // From the top, update in-place existing rows
3471 for(i=0; i<elRows.length; i++) {
3472 this._updateTrEl(elRows[i], aRecords[i]);
3473 }
3474
3475 // Add TR elements as necessary
3476 for(i=elRows.length; i<aRecords.length; i++) {
3477 this._addTrEl(aRecords[i]);
3478 }
3479
3480 // Reinstate selected and sorted classes
3481 var allRows = elTbody.rows;
3482 if(bReselect) {
3483 // Loop over each row
3484 for(j=0; j<allRows.length; j++) {
3485 var thisRow = allRows[j];
3486 var sMode = this.get("selectionMode");
3487 if ((sMode == "standard") || (sMode == "single")) {
3488 // Set SELECTED
3489 for(k=0; k<aSelectedRows.length; k++) {
3490 if(aSelectedRows[k] === thisRow.yuiRecordId) {
3491 YAHOO.util.Dom.addClass(thisRow, YAHOO.widget.DataTable.CLASS_SELECTED);
3492 if(j === allRows.length-1) {
3493 this._sLastSelectedId = thisRow.id;
3494 this._sSelectionAnchorId = thisRow.id;
3495 }
3496 }
3497 }
3498 }
3499 else {
3500 // Loop over each cell
3501 for(k=0; k<thisRow.cells.length; k++) {
3502 var thisCell = thisRow.cells[k];
3503 // Set SELECTED
3504 for(l=0; l<aSelectedCells.length; l++) {
3505 if((aSelectedCells[l].recordId === thisRow.yuiRecordId) &&
3506 (aSelectedCells[l].columnId === thisCell.yuiColumnId)) {
3507 YAHOO.util.Dom.addClass(thisCell, YAHOO.widget.DataTable.CLASS_SELECTED);
3508 if(k === thisRow.cells.length-1) {
3509 this._sLastSelectedId = thisCell.id;
3510 this._sSelectionAnchorId = thisCell.id;
3511 }
3512 }
3513 }
3514 }
3515 }
3516 }
3517 }
3518
3519 // Set FIRST/LAST, EVEN/ODD
3520 this._setFirstRow();
3521 this._setLastRow();
3522 this._setRowStripes();
3523
3524 this.fireEvent("refreshEvent");
3525 }
3526 // Empty
3527 else {
3528 // Remove all rows
3529 while(elTbody.hasChildNodes()) {
3530 elTbody.deleteRow(-1);
3531 }
3532
3533 this.showTableMessage(YAHOO.widget.DataTable.MSG_EMPTY, YAHOO.widget.DataTable.CLASS_EMPTY);
3534 }
3535 };
3536
3537 /**
3538 * Nulls out the entire DataTable instance and related objects, removes attached
3539 * event listeners, and clears out DOM elements inside the container. After
3540 * calling this method, the instance reference should be expliclitly nulled by
3541 * implementer, as in myDataTable = null. Use with caution!
3542 *
3543 * @method destroy
3544 */
3545 YAHOO.widget.DataTable.prototype.destroy = function() {
3546 // Destroy Cell Editor
3547 YAHOO.util.Event.purgeElement(this._oCellEditor.container, true);
3548 document.body.removeChild(this._oCellEditor.container);
3549
3550 var instanceName = this.toString();
3551 var elContainer = this._elContainer;
3552
3553 // Unhook custom events
3554 this._oRecordSet.unsubscribeAll();
3555 this.unsubscribeAll();
3556
3557 // Unhook DOM events
3558 YAHOO.util.Event.purgeElement(elContainer, true);
3559
3560 // Remove DOM elements
3561 elContainer.innerHTML = "";
3562
3563 // Null out objects
3564 for(var param in this) {
3565 if(this.hasOwnProperty(param)) {
3566 this[param] = null;
3567 }
3568 }
3569
3570 };
3571
3572 /**
3573 * Displays message within secondary TBODY.
3574 *
3575 * @method showTableMessage
3576 * @param sHTML {String} (optional) Value for innerHTML.
3577 * @param sClassName {String} (optional) Classname.
3578 */
3579 YAHOO.widget.DataTable.prototype.showTableMessage = function(sHTML, sClassName) {
3580 var elCell = this._elMsgTd;
3581 if(YAHOO.lang.isString(sHTML)) {
3582 elCell.innerHTML = sHTML;
3583 }
3584 if(YAHOO.lang.isString(sClassName)) {
3585 YAHOO.util.Dom.addClass(elCell, sClassName);
3586 }
3587 this._elMsgTbody.style.display = "";
3588 this.fireEvent("tableMsgShowEvent", {html:sHTML, className:sClassName});
3589 };
3590
3591 /**
3592 * Hides secondary TBODY.
3593 *
3594 * @method hideTableMessage
3595 */
3596 YAHOO.widget.DataTable.prototype.hideTableMessage = function() {
3597 if(this._elMsgTbody.style.display != "none") {
3598 this._elMsgTbody.style.display = "none";
3599 this.fireEvent("tableMsgHideEvent");
3600 }
3601 };
3602
3603 /**
3604 * Brings focus to DataTable instance.
3605 *
3606 * @method focus
3607 */
3608 YAHOO.widget.DataTable.prototype.focus = function() {
3609 this._focusEl(this._elTable);
3610 };
3611
3612
3613
3614
3615
3616
3617
3618
3619
3620
3621
3622
3623
3624
3625
3626
3627
3628
3629
3630
3631
3632
3633
3634
3635
3636
3637
3638
3639
3640
3641
3642
3643
3644
3645
3646
3647
3648
3649
3650
3651
3652
3653
3654
3655
3656
3657
3658
3659
3660
3661
3662
3663
3664
3665
3666
3667
3668
3669
3670
3671
3672
3673
3674
3675
3676
3677 // RECORDSET FUNCTIONS
3678
3679 /**
3680 * Returns Record index for given TR element or page row index.
3681 *
3682 * @method getRecordIndex
3683 * @param row {YAHOO.widget.Record | HTMLElement | Number} Record instance, TR
3684 * element reference or page row index.
3685 * @return {Number} Record's RecordSet index, or null.
3686 */
3687 YAHOO.widget.DataTable.prototype.getRecordIndex = function(row) {
3688 var nTrIndex;
3689
3690 if(!YAHOO.lang.isNumber(row)) {
3691 // By Record
3692 if(row instanceof YAHOO.widget.Record) {
3693 return this._oRecordSet.getRecordIndex(row);
3694 }
3695 // By element reference
3696 else {
3697 // Find the TR element
3698 var el = this.getTrEl(row);
3699 if(el) {
3700 nTrIndex = el.sectionRowIndex;
3701 }
3702 }
3703 }
3704 // By page row index
3705 else {
3706 nTrIndex = row;
3707 }
3708
3709 if(YAHOO.lang.isNumber(nTrIndex)) {
3710 if(this.get("paginated")) {
3711 return this.get("paginator").startRecordIndex + nTrIndex;
3712 }
3713 else {
3714 return nTrIndex;
3715 }
3716 }
3717
3718 return null;
3719 };
3720
3721 /**
3722 * For the given identifier, returns the associated Record instance.
3723 *
3724 * @method getRecord
3725 * @param row {HTMLElement | String | Number} RecordSet position index, DOM
3726 * reference or ID string to an element within the DataTable page.
3727 * @return {YAHOO.widget.Record} Record instance.
3728 */
3729 YAHOO.widget.DataTable.prototype.getRecord = function(row) {
3730 var nRecordIndex = row;
3731
3732 // By element reference or ID string
3733 if(!YAHOO.lang.isNumber(nRecordIndex)) {
3734 // Validate TR element
3735 var elRow = this.getTrEl(row);
3736 if(elRow) {
3737 nRecordIndex = this.getRecordIndex(row);
3738 }
3739 }
3740 // By Record index
3741 if(YAHOO.lang.isNumber(nRecordIndex)) {
3742 return this._oRecordSet.getRecord(nRecordIndex);
3743 }
3744
3745 return null;
3746 };
3747
3748
3749
3750
3751
3752
3753
3754
3755
3756
3757
3758
3759
3760
3761
3762
3763
3764
3765
3766
3767
3768
3769
3770
3771
3772
3773
3774
3775
3776
3777
3778
3779
3780
3781
3782
3783
3784
3785
3786
3787
3788
3789
3790
3791
3792
3793 // COLUMN FUNCTIONS
3794
3795 /**
3796 * For the given identifier, returns the associated Column instance.
3797 *
3798 * @method getColumn
3799 * @param column {HTMLElement | String | Number} ColumnSet.keys position index, DOM
3800 * reference or ID string to an element within the DataTable page.
3801 * @return {YAHOO.widget.Column} Column instance.
3802 */
3803 YAHOO.widget.DataTable.prototype.getColumn = function(column) {
3804 var nColumnIndex = column;
3805
3806 // By element reference or ID string
3807 if(!YAHOO.lang.isNumber(nColumnIndex)) {
3808 // Validate TD element
3809 var elCell = this.getTdEl(column);
3810 if(elCell) {
3811 nColumnIndex = elCell.yuiColumnId;
3812 }
3813 // Validate TH element
3814 else {
3815 elCell = this.getThEl(column);
3816 if(elCell) {
3817 nColumnIndex = elCell.yuiColumnId;
3818 }
3819 }
3820 }
3821
3822 // By Column index
3823 if(YAHOO.lang.isNumber(nColumnIndex)) {
3824 return this._oColumnSet.getColumn(nColumnIndex);
3825 }
3826
3827 return null;
3828 };
3829
3830 /**
3831 * Sorts given Column.
3832 *
3833 * @method sortColumn
3834 * @param oColumn {YAHOO.widget.Column} Column instance.
3835 */
3836 YAHOO.widget.DataTable.prototype.sortColumn = function(oColumn) {
3837 if(!oColumn) {
3838 return;
3839 }
3840 if(!oColumn instanceof YAHOO.widget.Column) {
3841 //TODO: accept the TH or TH.key
3842 //TODO: Get the column based on TH.yuiColumnId
3843 return;
3844 }
3845 if(oColumn.sortable) {
3846 // What is the default sort direction?
3847 var sortDir = (oColumn.sortOptions && oColumn.sortOptions.defaultOrder) ? oColumn.sortOptions.defaultOrder : "asc";
3848
3849 // Already sorted?
3850 var oSortedBy = this.get("sortedBy");
3851 if(oSortedBy && (oSortedBy.key === oColumn.key)) {
3852 if(oSortedBy.dir) {
3853 sortDir = (oSortedBy.dir == "asc") ? "desc" : "asc";
3854 }
3855 else {
3856 sortDir = (sortDir == "asc") ? "desc" : "asc";
3857 }
3858 }
3859
3860 // Is there a custom sort handler function defined?
3861 var sortFnc = (oColumn.sortOptions && YAHOO.lang.isFunction(oColumn.sortOptions.sortFunction)) ?
3862 oColumn.sortOptions.sortFunction : function(a, b, desc) {
3863 var sorted = YAHOO.util.Sort.compare(a.getData(oColumn.key),b.getData(oColumn.key), desc);
3864 if(sorted === 0) {
3865 return YAHOO.util.Sort.compare(a.getId(),b.getId(), desc);
3866 }
3867 else {
3868 return sorted;
3869 }
3870 };
3871
3872 // Do the actual sort
3873 var desc = (sortDir == "desc") ? true : false;
3874 this._oRecordSet.sortRecords(sortFnc, desc);
3875
3876 // Update sortedBy tracker
3877 this.set("sortedBy", {key:oColumn.key, dir:sortDir, column:oColumn});
3878
3879 // Reset to first page
3880 //TODO: Keep selection in view
3881 this.updatePaginator({currentPage:1});
3882
3883 // Update the UI
3884 this.refreshView();
3885
3886 this.fireEvent("columnSortEvent",{column:oColumn,dir:sortDir});
3887 }
3888 else {
3889 //TODO
3890 }
3891 };
3892
3893
3894
3895
3896
3897
3898
3899
3900
3901
3902
3903
3904
3905
3906
3907
3908
3909
3910
3911
3912
3913
3914
3915
3916
3917
3918
3919
3920
3921
3922
3923
3924
3925
3926
3927
3928
3929
3930
3931
3932
3933
3934
3935
3936
3937 // ROW FUNCTIONS
3938
3939
3940 /**
3941 * Adds one new Record of data into the RecordSet at the index if given,
3942 * otherwise at the end. If the new Record is in page view, the
3943 * corresponding DOM elements are also updated.
3944 *
3945 * @method addRow
3946 * @param oData {Object} Object literal of data for the row.
3947 * @param index {Number} (optional) RecordSet position index at which to add data.
3948 */
3949 YAHOO.widget.DataTable.prototype.addRow = function(oData, index) {
3950 if(oData && (oData.constructor == Object)) {
3951 var oRecord = this._oRecordSet.addRecord(oData, index);
3952 if(oRecord) {
3953 var nTrIndex = this.getTrIndex(oRecord);
3954
3955 // Row is in view
3956 if(YAHOO.lang.isNumber(nTrIndex)) {
3957 // Paginated so just refresh the view to keep pagination state
3958 if(this.get("paginated")) {
3959 this.refreshView();
3960 }
3961 // Add the TR element
3962 else {
3963 var newTrId = this._addTrEl(oRecord, nTrIndex);
3964 if(newTrId) {
3965 // Is this an insert or an append?
3966 var append = (YAHOO.lang.isNumber(nTrIndex) &&
3967 (nTrIndex == this._elTbody.rows.length-1)) ? true : false;
3968
3969 // Stripe the one new row
3970 if(append) {
3971 if((this._elTbody.rows.length-1)%2) {
3972 YAHOO.util.Dom.addClass(newTrId, YAHOO.widget.DataTable.CLASS_ODD);
3973 }
3974 else {
3975 YAHOO.util.Dom.addClass(newTrId, YAHOO.widget.DataTable.CLASS_EVEN);
3976 }
3977 }
3978 // Restripe all the rows after the new one
3979 else {
3980 this._setRowStripes(nTrIndex);
3981 }
3982
3983 // If new row is at the bottom
3984 if(append) {
3985 this._setLastRow();
3986 }
3987 // If new row is at the top
3988 else if(YAHOO.lang.isNumber(index) && (nTrIndex === 0)) {
3989 this._setFirstRow();
3990 }
3991 }
3992 }
3993 }
3994 // Record is not in view so just update pagination UI
3995 else {
3996 this.updatePaginator();
3997 }
3998
3999 // TODO: what args to pass?
4000 this.fireEvent("rowAddEvent", {record:oRecord});
4001
4002 // For log message
4003 nTrIndex = (YAHOO.lang.isValue(nTrIndex))? nTrIndex : "n/a";
4004
4005 return;
4006 }
4007 }
4008 };
4009
4010 /**
4011 * Convenience method to add multiple rows.
4012 *
4013 * @method addRows
4014 * @param aData {Object[]} Array of object literal data for the rows.
4015 * @param index {Number} (optional) RecordSet position index at which to add data.
4016 */
4017 YAHOO.widget.DataTable.prototype.addRows = function(aData, index) {
4018 if(YAHOO.lang.isArray(aData)) {
4019 var i;
4020 if(YAHOO.lang.isNumber(index)) {
4021 for(i=aData.length-1; i>-1; i--) {
4022 this.addRow(aData[i], index);
4023 }
4024 }
4025 else {
4026 for(i=0; i<aData.length; i++) {
4027 this.addRow(aData[i]);
4028 }
4029 }
4030 }
4031 else {
4032 }
4033 };
4034
4035 /**
4036 * For the given row, updates the associated Record with the given data. If the
4037 * row is in view, the corresponding DOM elements are also updated.
4038 *
4039 * @method updateRow
4040 * @param row {YAHOO.widget.Record | Number | HTMLElement | String}
4041 * Which row to update: By Record instance, by Record's RecordSet
4042 * position index, by HTMLElement reference to the TR element, or by ID string
4043 * of the TR element.
4044 * @param oData {Object} Object literal of data for the row.
4045 */
4046 YAHOO.widget.DataTable.prototype.updateRow = function(row, oData) {
4047 var oldRecord, updatedRecord, elRow;
4048
4049 // Get the Record directly
4050 if((row instanceof YAHOO.widget.Record) || (YAHOO.lang.isNumber(row))) {
4051 // Get the Record directly
4052 oldRecord = this._oRecordSet.getRecord(row);
4053
4054 // Is this row in view?
4055 elRow = this.getTrEl(oldRecord);
4056 }
4057 // Get the Record by TR element
4058 else {
4059 elRow = this.getTrEl(row);
4060 if(elRow) {
4061 oldRecord = this._oRecordSet.getRecord(this.getRecordIndex(elRow));
4062 }
4063 }
4064
4065 // Update the Record
4066 if(oldRecord) {
4067 // Copy data from the Record for the event that gets fired later
4068 var oRecordData = oldRecord.getData();
4069 var oldData = {};
4070 for(var param in oRecordData) {
4071 oldData[param] = oRecordData[param];
4072 }
4073
4074 updatedRecord = this._oRecordSet.updateRecord(oldRecord, oData);
4075 }
4076 else {
4077 return;
4078
4079 }
4080
4081 // Update the TR only if row is in view
4082 if(elRow) {
4083 this._updateTrEl(elRow, updatedRecord);
4084 }
4085
4086 this.fireEvent("rowUpdateEvent", {record:updatedRecord, oldData:oldData});
4087 };
4088
4089 /**
4090 * Deletes the given row's Record from the RecordSet. If the row is in view, the
4091 * corresponding DOM elements are also deleted.
4092 *
4093 * @method deleteRow
4094 * @param row {HTMLElement | String | Number} DOM element reference or ID string
4095 * to DataTable page element or RecordSet index.
4096 */
4097 YAHOO.widget.DataTable.prototype.deleteRow = function(row) {
4098 // Get the Record index...
4099 var nRecordIndex = null;
4100 // ...by Record index
4101 if(YAHOO.lang.isNumber(row)) {
4102 nRecordIndex = row;
4103 }
4104 // ...by element reference
4105 else {
4106 var elRow = YAHOO.util.Dom.get(row);
4107 elRow = this.getTrEl(elRow);
4108 if(elRow) {
4109 nRecordIndex = this.getRecordIndex(elRow);
4110 }
4111 }
4112 if(nRecordIndex !== null) {
4113 var oRecord = this._oRecordSet.getRecord(nRecordIndex);
4114 if(oRecord) {
4115 var nRecordId = oRecord.getId();
4116
4117 // Remove from selection tracker if there
4118 var tracker = this._aSelections || [];
4119 for(var j=0; j<tracker.length; j++) {
4120 if((YAHOO.lang.isNumber(tracker[j]) && (tracker[j] === nRecordId)) ||
4121 ((tracker[j].constructor == Object) && (tracker[j].recordId === nRecordId))) {
4122 tracker.splice(j,1);
4123 }
4124 }
4125
4126 // Copy data from the Record for the event that gets fired later
4127 var oRecordData = oRecord.getData();
4128 var oData = {};
4129 for(var param in oRecordData) {
4130 oData[param] = oRecordData[param];
4131 }
4132
4133 // Delete Record from RecordSet
4134 this._oRecordSet.deleteRecord(nRecordIndex);
4135
4136 // If row is in view, delete the TR element
4137 var nTrIndex = this.getTrIndex(nRecordIndex);
4138 if(YAHOO.lang.isNumber(nTrIndex)) {
4139 var isLast = (nTrIndex == this.getLastTrEl().sectionRowIndex) ?
4140 true : false;
4141 this._deleteTrEl(nTrIndex);
4142
4143 // Empty body
4144 if(this._elTbody.rows.length === 0) {
4145 this.showTableMessage(YAHOO.widget.DataTable.MSG_EMPTY, YAHOO.widget.DataTable.CLASS_EMPTY);
4146 }
4147 // Update UI
4148 else {
4149 // Set FIRST/LAST
4150 if(nTrIndex === 0) {
4151 this._setFirstRow();
4152 }
4153 if(isLast) {
4154 this._setLastRow();
4155 }
4156 // Set EVEN/ODD
4157 if(nTrIndex != this._elTbody.rows.length) {
4158 this._setRowStripes(nTrIndex);
4159 }
4160 }
4161 }
4162
4163 this.fireEvent("rowDeleteEvent", {recordIndex:nRecordIndex,
4164 oldData:oData, trElIndex:nTrIndex});
4165 }
4166 }
4167 else {
4168 }
4169 };
4170
4171 /**
4172 * Convenience method to delete multiple rows.
4173 *
4174 * @method deleteRows
4175 * @param row {HTMLElement | String | Number} DOM element reference or ID string
4176 * to DataTable page element or RecordSet index.
4177 * @param count {Number} (optional) How many rows to delete. A negative value
4178 * will delete towards the beginning.
4179 */
4180 YAHOO.widget.DataTable.prototype.deleteRows = function(row, count) {
4181 // Get the Record index...
4182 var nRecordIndex = null;
4183 // ...by Record index
4184 if(YAHOO.lang.isNumber(row)) {
4185 nRecordIndex = row;
4186 }
4187 // ...by element reference
4188 else {
4189 var elRow = YAHOO.util.Dom.get(row);
4190 elRow = this.getTrEl(elRow);
4191 if(elRow) {
4192 nRecordIndex = this.getRecordIndex(elRow);
4193 }
4194 }
4195 if(nRecordIndex !== null) {
4196 if(count && YAHOO.lang.isNumber(count)) {
4197 // Start with highest index and work down
4198 var startIndex = (count > 0) ? nRecordIndex + count -1 : nRecordIndex;
4199 var endIndex = (count > 0) ? nRecordIndex : nRecordIndex + count + 1;
4200 for(var i=startIndex; i>endIndex-1; i--) {
4201 this.deleteRow(i);
4202 }
4203 }
4204 else {
4205 this.deleteRow(nRecordIndex);
4206 }
4207 }
4208 else {
4209 }
4210 };
4211
4212
4213
4214
4215
4216
4217
4218
4219
4220
4221
4222
4223
4224
4225
4226
4227
4228
4229
4230
4231
4232
4233
4234
4235
4236
4237
4238
4239
4240
4241
4242
4243
4244
4245
4246
4247
4248
4249
4250
4251
4252
4253
4254
4255
4256
4257 // CELL FUNCTIONS
4258
4259 /**
4260 * Outputs markup into the given TD based on given Record.
4261 *
4262 * @method formatCell
4263 * @param elCell {HTMLElement} TD Element.
4264 * @param oRecord {YAHOO.widget.Record} (Optional) Record instance.
4265 * @param oColumn {YAHOO.widget.Column} (Optional) Column instance.
4266 * @return {HTML} Markup.
4267 */
4268 YAHOO.widget.DataTable.prototype.formatCell = function(elCell, oRecord, oColumn) {
4269 if(!(oRecord instanceof YAHOO.widget.Record)) {
4270 oRecord = this.getRecord(elCell);
4271 }
4272 if(!(oColumn instanceof YAHOO.widget.Column)) {
4273 oColumn = this._oColumnSet.getColumn(elCell.yuiColumnId);
4274 }
4275
4276 if(oRecord && oColumn) {
4277 var oData = oRecord.getData(oColumn.key);
4278
4279 var fnFormatter;
4280 if(YAHOO.lang.isString(oColumn.formatter)) {
4281 switch(oColumn.formatter) {
4282 case "button":
4283 fnFormatter = YAHOO.widget.DataTable.formatButton;
4284 break;
4285 case "checkbox":
4286 fnFormatter = YAHOO.widget.DataTable.formatCheckbox;
4287 break;
4288 case "currency":
4289 fnFormatter = YAHOO.widget.DataTable.formatCurrency;
4290 break;
4291 case "date":
4292 fnFormatter = YAHOO.widget.DataTable.formatDate;
4293 break;
4294 case "dropdown":
4295 fnFormatter = YAHOO.widget.DataTable.formatDropdown;
4296 break;
4297 case "email":
4298 fnFormatter = YAHOO.widget.DataTable.formatEmail;
4299 break;
4300 case "link":
4301 fnFormatter = YAHOO.widget.DataTable.formatLink;
4302 break;
4303 case "number":
4304 fnFormatter = YAHOO.widget.DataTable.formatNumber;
4305 break;
4306 case "radio":
4307 fnFormatter = YAHOO.widget.DataTable.formatRadio;
4308 break;
4309 case "text":
4310 fnFormatter = YAHOO.widget.DataTable.formatText;
4311 break;
4312 case "textarea":
4313 fnFormatter = YAHOO.widget.DataTable.formatTextarea;
4314 break;
4315 case "textbox":
4316 fnFormatter = YAHOO.widget.DataTable.formatTextbox;
4317 break;
4318 case "html":
4319 // This is the default
4320 break;
4321 default:
4322 fnFormatter = null;
4323 }
4324 }
4325 else if(YAHOO.lang.isFunction(oColumn.formatter)) {
4326 fnFormatter = oColumn.formatter;
4327 }
4328
4329 // Apply special formatter
4330 if(fnFormatter) {
4331 fnFormatter.call(this, elCell, oRecord, oColumn, oData);
4332 }
4333 else {
4334 elCell.innerHTML = (YAHOO.lang.isValue(oData)) ? oData.toString() : "";
4335 }
4336
4337 // Add custom classNames
4338 var aCustomClasses = null;
4339 if(YAHOO.lang.isString(oColumn.className)) {
4340 aCustomClasses = [oColumn.className];
4341 }
4342 else if(YAHOO.lang.isArray(oColumn.className)) {
4343 aCustomClasses = oColumn.className;
4344 }
4345 if(aCustomClasses) {
4346 for(var i=0; i<aCustomClasses.length; i++) {
4347 YAHOO.util.Dom.addClass(elCell, aCustomClasses[i]);
4348 }
4349 }
4350
4351 YAHOO.util.Dom.addClass(elCell, "yui-dt-col-"+oColumn.key);
4352
4353 // Is editable?
4354 if(oColumn.editor) {
4355 YAHOO.util.Dom.addClass(elCell,YAHOO.widget.DataTable.CLASS_EDITABLE);
4356 }
4357
4358 this.fireEvent("cellFormatEvent", {record:oRecord, key:oColumn.key, el:elCell});
4359 }
4360 else {
4361 }
4362 };
4363
4364
4365 /**
4366 * Formats a BUTTON element.
4367 *
4368 * @method DataTable.formatButton
4369 * @param el {HTMLElement} The element to format with markup.
4370 * @param oRecord {YAHOO.widget.Record} Record instance.
4371 * @param oColumn {YAHOO.widget.Column} Column instance.
4372 * @param oData {Object | Boolean} Data value for the cell. By default, the value
4373 * is what gets written to the BUTTON.
4374 * @static
4375 */
4376 YAHOO.widget.DataTable.formatButton= function(el, oRecord, oColumn, oData) {
4377 var sValue = YAHOO.lang.isValue(oData) ? oData : "Click";
4378 //TODO: support YAHOO.widget.Button
4379 //if(YAHOO.widget.Button) {
4380
4381 //}
4382 //else {
4383 el.innerHTML = "<button type=\"button\" class=\""+
4384 YAHOO.widget.DataTable.CLASS_BUTTON + "\">" + sValue + "</button>";
4385 //}
4386 };
4387
4388 /**
4389 * Formats a CHECKBOX element.
4390 *
4391 * @method DataTable.formatCheckbox
4392 * @param el {HTMLElement} The element to format with markup.
4393 * @param oRecord {YAHOO.widget.Record} Record instance.
4394 * @param oColumn {YAHOO.widget.Column} Column instance.
4395 * @param oData {Object | Boolean} Data value for the cell. Can be a simple
4396 * Boolean to indicate whether checkbox is checked or not. Can be object literal
4397 * {checked:bBoolean, label:sLabel}. Other forms of oData require a custom
4398 * formatter.
4399 * @static
4400 */
4401 YAHOO.widget.DataTable.formatCheckbox = function(el, oRecord, oColumn, oData) {
4402 var bChecked = oData;
4403 bChecked = (bChecked) ? " checked" : "";
4404 el.innerHTML = "<input type=\"checkbox\"" + bChecked +
4405 " class=\"" + YAHOO.widget.DataTable.CLASS_CHECKBOX + "\">";
4406 };
4407
4408 /**
4409 * Formats currency. Default unit is USD.
4410 *
4411 * @method DataTable.formatCurrency
4412 * @param el {HTMLElement} The element to format with markup.
4413 * @param oRecord {YAHOO.widget.Record} Record instance.
4414 * @param oColumn {YAHOO.widget.Column} Column instance.
4415 * @param oData {Number} Data value for the cell.
4416 * @static
4417 */
4418 YAHOO.widget.DataTable.formatCurrency = function(el, oRecord, oColumn, oData) {
4419 if(YAHOO.lang.isNumber(oData)) {
4420 var nAmount = oData;
4421 var markup;
4422
4423 // Round to the penny
4424 nAmount = Math.round(nAmount*100)/100;
4425
4426 // Default currency is USD
4427 markup = "$"+nAmount;
4428
4429 // Normalize digits
4430 var dotIndex = markup.indexOf(".");
4431 if(dotIndex < 0) {
4432 markup += ".00";
4433 }
4434 else {
4435 while(dotIndex > markup.length-3) {
4436 markup += "0";
4437 }
4438 }
4439 el.innerHTML = markup;
4440 }
4441 else {
4442 el.innerHTML = YAHOO.lang.isValue(oData) ? oData : "";
4443 }
4444 };
4445
4446 /**
4447 * Formats JavaScript Dates.
4448 *
4449 * @method DataTable.formatDate
4450 * @param el {HTMLElement} The element to format with markup.
4451 * @param oRecord {YAHOO.widget.Record} Record instance.
4452 * @param oColumn {YAHOO.widget.Column} Column instance.
4453 * @param oData {Object} Data value for the cell, or null.
4454 * @static
4455 */
4456 YAHOO.widget.DataTable.formatDate = function(el, oRecord, oColumn, oData) {
4457 var oDate = oData;
4458 if(oDate instanceof Date) {
4459 el.innerHTML = (oDate.getMonth()+1) + "/" + oDate.getDate() + "/" + oDate.getFullYear();
4460 }
4461 else {
4462 el.innerHTML = YAHOO.lang.isValue(oData) ? oData : "";
4463 }
4464 };
4465
4466 /**
4467 * Formats SELECT elements.
4468 *
4469 * @method DataTable.formatDropdown
4470 * @param el {HTMLElement} The element to format with markup.
4471 * @param oRecord {YAHOO.widget.Record} Record instance.
4472 * @param oColumn {YAHOO.widget.Column} Column instance.
4473 * @param oData {Object} Data value for the cell, or null.
4474 * @static
4475 */
4476 YAHOO.widget.DataTable.formatDropdown = function(el, oRecord, oColumn, oData) {
4477 var selectedValue = (YAHOO.lang.isValue(oData)) ? oData : oRecord.getData(oColumn.key);
4478 var options = (YAHOO.lang.isArray(oColumn.dropdownOptions)) ?
4479 oColumn.dropdownOptions : null;
4480
4481 var selectEl;
4482 var collection = el.getElementsByTagName("select");
4483
4484 // Create the form element only once, so we can attach the onChange listener
4485 if(collection.length === 0) {
4486 // Create SELECT element
4487 selectEl = document.createElement("select");
4488 YAHOO.util.Dom.addClass(selectEl, YAHOO.widget.DataTable.CLASS_DROPDOWN);
4489 selectEl = el.appendChild(selectEl);
4490
4491 // Add event listener
4492 //TODO: static method doesn't have access to the datatable instance...
4493 YAHOO.util.Event.addListener(selectEl,"change",oDataTable._onDropdownChange,oDataTable);
4494 }
4495
4496 selectEl = collection[0];
4497
4498 // Update the form element
4499 if(selectEl) {
4500 // Clear out previous options
4501 selectEl.innerHTML = "";
4502
4503 // We have options to populate
4504 if(options) {
4505 // Create OPTION elements
4506 for(var i=0; i<options.length; i++) {
4507 var option = options[i];
4508 var optionEl = document.createElement("option");
4509 optionEl.value = (YAHOO.lang.isValue(option.value)) ?
4510 option.value : option;
4511 optionEl.innerHTML = (YAHOO.lang.isValue(option.text)) ?
4512 option.text : option;
4513 optionEl = selectEl.appendChild(optionEl);
4514 }
4515 }
4516 // Selected value is our only option
4517 else {
4518 selectEl.innerHTML = "<option value=\"" + selectedValue + "\">" + selectedValue + "</option>";
4519 }
4520 }
4521 else {
4522 el.innerHTML = YAHOO.lang.isValue(oData) ? oData : "";
4523 }
4524 };
4525
4526 /**
4527 * Formats emails.
4528 *
4529 * @method DataTable.formatEmail
4530 * @param el {HTMLElement} The element to format with markup.
4531 * @param oRecord {YAHOO.widget.Record} Record instance.
4532 * @param oColumn {YAHOO.widget.Column} Column instance.
4533 * @param oData {Object} Data value for the cell, or null.
4534 * @static
4535 */
4536 YAHOO.widget.DataTable.formatEmail = function(el, oRecord, oColumn, oData) {
4537 if(YAHOO.lang.isString(oData)) {
4538 el.innerHTML = "<a href=\"mailto:" + oData + "\">" + oData + "</a>";
4539 }
4540 else {
4541 el.innerHTML = YAHOO.lang.isValue(oData) ? oData : "";
4542 }
4543 };
4544
4545 /**
4546 * Formats links.
4547 *
4548 * @method DataTable.formatLink
4549 * @param el {HTMLElement} The element to format with markup.
4550 * @param oRecord {YAHOO.widget.Record} Record instance.
4551 * @param oColumn {YAHOO.widget.Column} Column instance.
4552 * @param oData {Object} Data value for the cell, or null.
4553 * @static
4554 */
4555 YAHOO.widget.DataTable.formatLink = function(el, oRecord, oColumn, oData) {
4556 if(YAHOO.lang.isString(oData)) {
4557 el.innerHTML = "<a href=\"" + oData + "\">" + oData + "</a>";
4558 }
4559 else {
4560 el.innerHTML = YAHOO.lang.isValue(oData) ? oData : "";
4561 }
4562 };
4563
4564 /**
4565 * Formats numbers.
4566 *
4567 * @method DataTable.formatNumber
4568 * @param el {HTMLElement} The element to format with markup.
4569 * @param oRecord {YAHOO.widget.Record} Record instance.
4570 * @param oColumn {YAHOO.widget.Column} Column instance.
4571 * @param oData {Object} Data value for the cell, or null.
4572 * @static
4573 */
4574 YAHOO.widget.DataTable.formatNumber = function(el, oRecord, oColumn, oData) {
4575 if(YAHOO.lang.isNumber(oData)) {
4576 el.innerHTML = oData;
4577 }
4578 else {
4579 el.innerHTML = YAHOO.lang.isValue(oData) ? oData : "";
4580 }
4581 };
4582
4583 /**
4584 * Formats INPUT TYPE=RADIO elements.
4585 *
4586 * @method DataTable.formatRadio
4587 * @param el {HTMLElement} The element to format with markup.
4588 * @param oRecord {YAHOO.widget.Record} Record instance.
4589 * @param oColumn {YAHOO.widget.Column} Column instance.
4590 * @param oData {Object} (Optional) Data value for the cell.
4591 * @static
4592 */
4593 YAHOO.widget.DataTable.formatRadio = function(el, oRecord, oColumn, oData) {
4594 var bChecked = oData;
4595 bChecked = (bChecked) ? " checked" : "";
4596 el.innerHTML = "<input type=\"radio\"" + bChecked +
4597 " name=\"" + oColumn.getId() + "-radio\"" +
4598 " class=\"" + YAHOO.widget.DataTable.CLASS_CHECKBOX + "\">";
4599 };
4600
4601 /**
4602 * Formats text strings.
4603 *
4604 * @method DataTable.formatText
4605 * @param el {HTMLElement} The element to format with markup.
4606 * @param oRecord {YAHOO.widget.Record} Record instance.
4607 * @param oColumn {YAHOO.widget.Column} Column instance.
4608 * @param oData {Object} (Optional) Data value for the cell.
4609 * @static
4610 */
4611 YAHOO.widget.DataTable.formatText = function(el, oRecord, oColumn, oData) {
4612 var value = (YAHOO.lang.isValue(oRecord.getData(oColumn.key))) ?
4613 oRecord.getData(oColumn.key) : "";
4614 //TODO: move to util function
4615 el.innerHTML = value.toString().replace(/&/g, "&#38;").replace(/</g, "&#60;").replace(/>/g, "&#62;");
4616 };
4617
4618 /**
4619 * Formats TEXTAREA elements.
4620 *
4621 * @method DataTable.formatTextarea
4622 * @param el {HTMLElement} The element to format with markup.
4623 * @param oRecord {YAHOO.widget.Record} Record instance.
4624 * @param oColumn {YAHOO.widget.Column} Column instance.
4625 * @param oData {Object} (Optional) Data value for the cell.
4626 * @static
4627 */
4628 YAHOO.widget.DataTable.formatTextarea = function(el, oRecord, oColumn, oData) {
4629 var value = (YAHOO.lang.isValue(oRecord.getData(oColumn.key))) ?
4630 oRecord.getData(oColumn.key) : "";
4631 var markup = "<textarea>" + value + "</textarea>";
4632 el.innerHTML = markup;
4633 };
4634
4635 /**
4636 * Formats INPUT TYPE=TEXT elements.
4637 *
4638 * @method DataTable.formatTextbox
4639 * @param el {HTMLElement} The element to format with markup.
4640 * @param oRecord {YAHOO.widget.Record} Record instance.
4641 * @param oColumn {YAHOO.widget.Column} Column instance.
4642 * @param oData {Object} (Optional) Data value for the cell.
4643 * @static
4644 */
4645 YAHOO.widget.DataTable.formatTextbox = function(el, oRecord, oColumn, oData) {
4646 var value = (YAHOO.lang.isValue(oRecord.getData(oColumn.key))) ?
4647 oRecord.getData(oColumn.key) : "";
4648 var markup = "<input type=\"text\" value=\"" + value + "\">";
4649 el.innerHTML = markup;
4650 };
4651
4652
4653
4654
4655
4656
4657
4658
4659
4660
4661
4662
4663
4664
4665
4666
4667
4668
4669
4670
4671
4672
4673
4674
4675
4676
4677
4678
4679
4680
4681
4682
4683
4684
4685
4686
4687
4688
4689
4690
4691
4692
4693
4694
4695
4696
4697
4698
4699 // PAGINATION
4700
4701 /**
4702 * Updates Paginator values in response to RecordSet changes and/or DOM events.
4703 * Pass in all, a subset, or no values.
4704 *
4705 * @method updatePaginator
4706 * @param oNewValues {Object} (Optional) Object literal of Paginator values, or
4707 * a subset of Paginator values.
4708 * @param {Object} Object literal of all Paginator values.
4709 */
4710
4711 YAHOO.widget.DataTable.prototype.updatePaginator = function(oNewValues) {
4712 // Complete the set
4713 var oValidPaginator = this.get("paginator");
4714 for(var param in oNewValues) {
4715 if(oValidPaginator.hasOwnProperty(param)) {
4716 oValidPaginator[param] = oNewValues[param];
4717 }
4718 }
4719
4720 oValidPaginator.totalRecords = this._oRecordSet.getLength();
4721 oValidPaginator.rowsThisPage = Math.min(oValidPaginator.rowsPerPage, oValidPaginator.totalRecords);
4722 oValidPaginator.totalPages = Math.ceil(oValidPaginator.totalRecords / oValidPaginator.rowsThisPage);
4723 if(isNaN(oValidPaginator.totalPages)) {
4724 oValidPaginator.totalPages = 0;
4725 }
4726
4727 this.set("paginator", oValidPaginator);
4728 return this.get("paginator");
4729 };
4730
4731 /**
4732 * Displays given page of a paginated DataTable.
4733 *
4734 * @method showPage
4735 * @param nPage {Number} Which page.
4736 */
4737 YAHOO.widget.DataTable.prototype.showPage = function(nPage) {
4738 // Validate input
4739 if(!YAHOO.lang.isNumber(nPage) || (nPage < 1) || (nPage > this.get("paginator").totalPages)) {
4740 nPage = 1;
4741 }
4742 this.updatePaginator({currentPage:nPage});
4743 this.refreshView();
4744 };
4745
4746 /**
4747 * Updates Paginator containers with markup. Override this method to customize pagination UI.
4748 *
4749 * @method formatPaginators
4750 */
4751 YAHOO.widget.DataTable.prototype.formatPaginators = function() {
4752 var pag = this.get("paginator");
4753
4754 // For Opera workaround
4755 var dropdownEnabled = false;
4756
4757 // Links are enabled
4758 if(pag.pageLinks > -1) {
4759 for(var i=0; i<pag.links.length; i++) {
4760 this.formatPaginatorLinks(pag.links[i], pag.currentPage, pag.pageLinksStart, pag.pageLinks, pag.totalPages);
4761 }
4762 }
4763
4764 // Dropdown is enabled
4765 for(i=0; i<pag.dropdowns.length; i++) {
4766 if(pag.dropdownOptions) {
4767 dropdownEnabled = true;
4768 this.formatPaginatorDropdown(pag.dropdowns[i], pag.dropdownOptions);
4769 }
4770 else {
4771 pag.dropdowns[i].style.display = "none";
4772 }
4773 }
4774
4775 // For Opera artifacting in dropdowns
4776 if(dropdownEnabled && navigator.userAgent.toLowerCase().indexOf("opera") != -1) {
4777 document.body.style += '';
4778 }
4779 };
4780
4781 /**
4782 * Updates Paginator dropdown. If dropdown doesn't exist, the markup is created.
4783 * Sets dropdown elements's "selected" value.
4784 *
4785 * @method formatPaginatorDropdown
4786 * @param elDropdown {HTMLElement} The SELECT element.
4787 * @param dropdownOptions {Object[]} OPTION values for display in the SELECT element.
4788 */
4789 YAHOO.widget.DataTable.prototype.formatPaginatorDropdown = function(elDropdown, dropdownOptions) {
4790 if(elDropdown && (elDropdown.ownerDocument == document)) {
4791 // Clear OPTION elements
4792 while (elDropdown.firstChild) {
4793 elDropdown.removeChild(elDropdown.firstChild);
4794 }
4795
4796 // Create OPTION elements
4797 for(var j=0; j<dropdownOptions.length; j++) {
4798 var dropdownOption = dropdownOptions[j];
4799 var optionEl = document.createElement("option");
4800 optionEl.value = (YAHOO.lang.isValue(dropdownOption.value)) ?
4801 dropdownOption.value : dropdownOption;
4802 optionEl.innerHTML = (YAHOO.lang.isValue(dropdownOption.text)) ?
4803 dropdownOption.text : dropdownOption;
4804 optionEl = elDropdown.appendChild(optionEl);
4805 }
4806
4807 var options = elDropdown.options;
4808 // Update dropdown's "selected" value
4809 if(options.length) {
4810 for(var i=options.length-1; i>-1; i--) {
4811 if((this.get("paginator").rowsPerPage + "") === options[i].value) {
4812 options[i].selected = true;
4813 }
4814 }
4815 }
4816
4817 // Show the dropdown
4818 elDropdown.style.display = "";
4819 return;
4820 }
4821 };
4822
4823 /**
4824 * Updates Paginator links container with markup.
4825 *
4826 * @method formatPaginatorLinks
4827 * @param elContainer {HTMLElement} The link container element.
4828 * @param nCurrentPage {Number} Current page.
4829 * @param nPageLinksStart {Number} First page link to display.
4830 * @param nPageLinksLength {Number} How many page links to display.
4831 * @param nTotalPages {Number} Total number of pages.
4832 */
4833 YAHOO.widget.DataTable.prototype.formatPaginatorLinks = function(elContainer, nCurrentPage, nPageLinksStart, nPageLinksLength, nTotalPages) {
4834 if(elContainer && (elContainer.ownerDocument == document) &&
4835 YAHOO.lang.isNumber(nCurrentPage) && YAHOO.lang.isNumber(nPageLinksStart) &&
4836 YAHOO.lang.isNumber(nTotalPages)) {
4837 // Set up markup for first/last/previous/next
4838 var bIsFirstPage = (nCurrentPage == 1) ? true : false;
4839 var bIsLastPage = (nCurrentPage == nTotalPages) ? true : false;
4840 var sFirstLinkMarkup = (bIsFirstPage) ?
4841 " <span class=\"" + YAHOO.widget.DataTable.CLASS_DISABLED +
4842 " " + YAHOO.widget.DataTable.CLASS_FIRST + "\">&lt;&lt;</span> " :
4843 " <a href=\"#\" class=\"" + YAHOO.widget.DataTable.CLASS_FIRST + "\">&lt;&lt;</a> ";
4844 var sPrevLinkMarkup = (bIsFirstPage) ?
4845 " <span class=\"" + YAHOO.widget.DataTable.CLASS_DISABLED +
4846 " " + YAHOO.widget.DataTable.CLASS_PREVIOUS + "\">&lt;</span> " :
4847 " <a href=\"#\" class=\"" + YAHOO.widget.DataTable.CLASS_PREVIOUS + "\">&lt;</a> " ;
4848 var sNextLinkMarkup = (bIsLastPage) ?
4849 " <span class=\"" + YAHOO.widget.DataTable.CLASS_DISABLED +
4850 " " + YAHOO.widget.DataTable.CLASS_NEXT + "\">&gt;</span> " :
4851 " <a href=\"#\" class=\"" + YAHOO.widget.DataTable.CLASS_NEXT + "\">&gt;</a> " ;
4852 var sLastLinkMarkup = (bIsLastPage) ?
4853 " <span class=\"" + YAHOO.widget.DataTable.CLASS_DISABLED +
4854 " " + YAHOO.widget.DataTable.CLASS_LAST + "\">&gt;&gt;</span> " :
4855 " <a href=\"#\" class=\"" + YAHOO.widget.DataTable.CLASS_LAST + "\">&gt;&gt;</a> ";
4856
4857 // Start with first and previous
4858 var sMarkup = sFirstLinkMarkup + sPrevLinkMarkup;
4859
4860 // Ok to show all links
4861 var nMaxLinks = nTotalPages;
4862 var nFirstLink = 1;
4863 var nLastLink = nTotalPages;
4864
4865 if(nPageLinksLength > 0) {
4866 // Calculate how many links to show
4867 nMaxLinks = (nPageLinksStart+nPageLinksLength < nTotalPages) ?
4868 nPageLinksStart+nPageLinksLength-1 : nTotalPages;
4869
4870 // Try to keep the current page in the middle
4871 nFirstLink = (nCurrentPage - Math.floor(nMaxLinks/2) > 0) ? nCurrentPage - Math.floor(nMaxLinks/2) : 1;
4872 nLastLink = (nCurrentPage + Math.floor(nMaxLinks/2) <= nTotalPages) ? nCurrentPage + Math.floor(nMaxLinks/2) : nTotalPages;
4873
4874 // Keep the last link in range
4875 if(nFirstLink === 1) {
4876 nLastLink = nMaxLinks;
4877 }
4878 // Keep the first link in range
4879 else if(nLastLink === nTotalPages) {
4880 nFirstLink = nTotalPages - nMaxLinks + 1;
4881 }
4882
4883 // An even number of links can get funky
4884 if(nLastLink - nFirstLink === nMaxLinks) {
4885 nLastLink--;
4886 }
4887 }
4888
4889 // Generate markup for each page
4890 for(var i=nFirstLink; i<=nLastLink; i++) {
4891 if(i != nCurrentPage) {
4892 sMarkup += " <a href=\"#\" class=\"" + YAHOO.widget.DataTable.CLASS_PAGE + "\">" + i + "</a> ";
4893 }
4894 else {
4895 sMarkup += " <span class=\"" + YAHOO.widget.DataTable.CLASS_SELECTED + "\">" + i + "</span>";
4896 }
4897 }
4898 sMarkup += sNextLinkMarkup + sLastLinkMarkup;
4899 elContainer.innerHTML = sMarkup;
4900 return;
4901 }
4902 };
4903
4904
4905
4906
4907
4908
4909
4910
4911
4912
4913
4914
4915
4916
4917
4918
4919
4920
4921
4922
4923
4924
4925
4926
4927
4928
4929
4930
4931
4932
4933
4934
4935
4936
4937
4938
4939
4940
4941
4942
4943
4944
4945
4946
4947
4948
4949
4950
4951
4952 // SELECTION/HIGHLIGHTING
4953
4954 /**
4955 * ID string of last highlighted cell element
4956 *
4957 * @property _sLastHighlightedCellId
4958 * @type String
4959 * @private
4960 */
4961 YAHOO.widget.DataTable.prototype._sLastHighlightedCellId = null;
4962
4963 /**
4964 * ID string of last highlighted row element
4965 *
4966 * @property _sLastHighlightedRowId
4967 * @type String
4968 * @private
4969 */
4970 YAHOO.widget.DataTable.prototype._sLastHighlightedRowId = null;
4971
4972 /**
4973 * Array of selections: {recordId:nRecordId, cellIndex:nCellIndex}
4974 *
4975 * @property _aSelections
4976 * @type Object[]
4977 * @private
4978 */
4979 YAHOO.widget.DataTable.prototype._aSelections = null;
4980
4981 /**
4982 * ID string of last selected element
4983 *
4984 * @property _sLastSelectedId
4985 * @type String
4986 * @private
4987 */
4988 YAHOO.widget.DataTable.prototype._sLastSelectedId = null;
4989
4990 /**
4991 * ID string of the selection anchor element.
4992 *
4993 * @property _sSelectionAnchorId
4994 * @type String
4995 * @private
4996 */
4997 YAHOO.widget.DataTable.prototype._sSelectionAnchorId = null;
4998
4999 /**
5000 * Convenience method to remove the class YAHOO.widget.DataTable.CLASS_SELECTED
5001 * from all TR elements on the page.
5002 *
5003 * @method _unselectAllTrEls
5004 * @private
5005 */
5006 YAHOO.widget.DataTable.prototype._unselectAllTrEls = function() {
5007 var selectedRows = YAHOO.util.Dom.getElementsByClassName(YAHOO.widget.DataTable.CLASS_SELECTED,"tr",this._elTbody);
5008 YAHOO.util.Dom.removeClass(selectedRows, YAHOO.widget.DataTable.CLASS_SELECTED);
5009 };
5010
5011 /**
5012 * Returns array of selected TR elements on the page.
5013 *
5014 * @method getSelectedTrEls
5015 * @return {HTMLElement[]} Array of selected TR elements.
5016 */
5017 YAHOO.widget.DataTable.prototype.getSelectedTrEls = function() {
5018 return YAHOO.util.Dom.getElementsByClassName(YAHOO.widget.DataTable.CLASS_SELECTED,"tr",this._elTbody);
5019 };
5020
5021 /**
5022 * Sets given row to the selected state.
5023 *
5024 * @method selectRow
5025 * @param row {HTMLElement | String} HTML element reference or ID.
5026 */
5027 YAHOO.widget.DataTable.prototype.selectRow = function(row) {
5028 // Validate the row
5029 var elRow = this.getTrEl(row);
5030 if(elRow) {
5031 var oRecord = this.getRecord(elRow);
5032 if(oRecord) {
5033 // Get Record ID
5034 var tracker = this._aSelections || [];
5035 var nRecordId = oRecord.getId();
5036 // Remove if already there
5037
5038 // Use Array.indexOf if available...
5039 if(tracker.indexOf && (tracker.indexOf(nRecordId) > -1)) {
5040 tracker.splice(tracker.indexOf(nRecordId),1);
5041 }
5042 // ...or do it the old-fashioned way
5043 else {
5044 for(var j=0; j<tracker.length; j++) {
5045 if(tracker[j] === nRecordId){
5046 tracker.splice(j,1);
5047 }
5048 }
5049 }
5050 // Add to the end
5051 tracker.push(nRecordId);
5052
5053 // Update trackers
5054 this._sLastSelectedId = elRow.id;
5055 if(!this._sSelectionAnchorId) {
5056 this._sSelectionAnchorId = elRow.id;
5057 }
5058 this._aSelections = tracker;
5059
5060 // Update UI
5061 YAHOO.util.Dom.addClass(elRow, YAHOO.widget.DataTable.CLASS_SELECTED);
5062
5063 this.fireEvent("rowSelectEvent", {record:oRecord, el:elRow});
5064
5065 return;
5066 }
5067 }
5068 };
5069 // Backward compatibility
5070 YAHOO.widget.DataTable.prototype.select = function(els) {
5071 if(!YAHOO.lang.isArray(els)) {
5072 els = [els];
5073 }
5074 for(var i=0; i<els.length; i++) {
5075 this.selectRow(els[i]);
5076 }
5077 };
5078
5079 /**
5080 * Sets given row to the unselected state.
5081 *
5082 * @method unselectRow
5083 * @param row {HTMLElement | String} HTML TR element reference or ID.
5084 */
5085 YAHOO.widget.DataTable.prototype.unselectRow = function(row) {
5086 // Validate the row
5087 var elRow = this.getTrEl(row);
5088 if(elRow) {
5089 var oRecord = this.getRecord(elRow);
5090 if(oRecord) {
5091 // Get Record ID
5092 var tracker = this._aSelections || [];
5093 var nRecordId = oRecord.getId();
5094
5095 // Remove if there
5096 var bFound = false;
5097
5098 // Use Array.indexOf if available...
5099 if(tracker.indexOf && (tracker.indexOf(nRecordId) > -1)) {
5100 tracker.splice(tracker.indexOf(nRecordId),1);
5101 bFound = true;
5102 }
5103 // ...or do it the old-fashioned way
5104 else {
5105 for(var j=0; j<tracker.length; j++) {
5106 if(tracker[j] === nRecordId){
5107 tracker.splice(j,1);
5108 bFound = true;
5109 }
5110 }
5111 }
5112
5113 if(bFound) {
5114 // Update tracker
5115 this._aSelections = tracker;
5116
5117 // Update the UI
5118 YAHOO.util.Dom.removeClass(elRow, YAHOO.widget.DataTable.CLASS_SELECTED);
5119
5120 this.fireEvent("rowUnselectEvent", {record:oRecord, el:elRow});
5121
5122 return;
5123 }
5124 }
5125 }
5126 };
5127
5128 /**
5129 * Clears out all row selections.
5130 *
5131 * @method unselectAllRows
5132 */
5133 YAHOO.widget.DataTable.prototype.unselectAllRows = function() {
5134 // Remove from tracker
5135 var tracker = this._aSelections || [];
5136 for(var j=0; j<tracker.length; j++) {
5137 if(YAHOO.lang.isNumber(tracker[j])){
5138 tracker.splice(j,1);
5139 }
5140 }
5141
5142 // Update tracker
5143 this._aSelections = tracker;
5144
5145 // Update UI
5146 this._unselectAllTrEls();
5147
5148 //TODO: send an array of [{el:el,record:record}]
5149 //TODO: or convert this to an unselectRows method
5150 //TODO: that takes an array of rows or unselects all if none given
5151 this.fireEvent("unselectAllRowsEvent");
5152 };
5153
5154 /**
5155 * Convenience method to remove the class YAHOO.widget.DataTable.CLASS_SELECTED
5156 * from all TD elements in the internal tracker.
5157 *
5158 * @method _unselectAllTdEls
5159 * @private
5160 */
5161 YAHOO.widget.DataTable.prototype._unselectAllTdEls = function() {
5162 var selectedCells = YAHOO.util.Dom.getElementsByClassName(YAHOO.widget.DataTable.CLASS_SELECTED,"td",this._elTbody);
5163 YAHOO.util.Dom.removeClass(selectedCells, YAHOO.widget.DataTable.CLASS_SELECTED);
5164 };
5165
5166 /**
5167 * Returns array of selected TD elements on the page.
5168 *
5169 * @method getSelectedTdEls
5170 * @return {HTMLElement[]} Array of selected TD elements.
5171 */
5172 YAHOO.widget.DataTable.prototype.getSelectedTdEls = function() {
5173 return YAHOO.util.Dom.getElementsByClassName(YAHOO.widget.DataTable.CLASS_SELECTED,"td",this._elTbody);
5174 };
5175
5176 /**
5177 * Sets given cell to the selected state.
5178 *
5179 * @method selectCell
5180 * @param cell {HTMLElement | String} DOM element reference or ID string
5181 * to DataTable page element or RecordSet index.
5182 */
5183 YAHOO.widget.DataTable.prototype.selectCell = function(cell) {
5184 var elCell = this.getTdEl(cell);
5185
5186 if(elCell) {
5187 var oRecord = this.getRecord(elCell);
5188 var nColumnId = elCell.yuiColumnId;
5189
5190 if(oRecord && YAHOO.lang.isNumber(nColumnId)) {
5191 // Get Record ID
5192 var tracker = this._aSelections || [];
5193 var nRecordId = oRecord.getId();
5194
5195 // Remove if there
5196 for(var j=0; j<tracker.length; j++) {
5197 if((tracker[j].recordId === nRecordId) && (tracker[j].columnId === nColumnId)){
5198 tracker.splice(j,1);
5199 }
5200 }
5201
5202 // Add to the end
5203 tracker.push({recordId:nRecordId, columnId:nColumnId});
5204
5205 // Update trackers
5206 this._aSelections = tracker;
5207 this._sLastSelectedId = elCell.id;
5208 if(!this._sSelectionAnchorId) {
5209 this._sSelectionAnchorId = elCell.id;
5210 }
5211
5212 // Update the UI
5213 YAHOO.util.Dom.addClass(elCell, YAHOO.widget.DataTable.CLASS_SELECTED);
5214
5215 this.fireEvent("cellSelectEvent", {record:oRecord,
5216 key: this._oColumnSet.getColumn(nColumnId).key, el:elCell});
5217 return;
5218 }
5219 }
5220 };
5221
5222 /**
5223 * Sets given cell to the unselected state.
5224 *
5225 * @method unselectCell
5226 * @param cell {HTMLElement | String} DOM element reference or ID string
5227 * to DataTable page element or RecordSet index.
5228 */
5229 YAHOO.widget.DataTable.prototype.unselectCell = function(cell) {
5230 var elCell = this.getTdEl(cell);
5231
5232 if(elCell) {
5233 var oRecord = this.getRecord(elCell);
5234 var nColumnId = elCell.yuiColumnId;
5235
5236 if(oRecord && YAHOO.lang.isNumber(nColumnId)) {
5237 // Get Record ID
5238 var tracker = this._aSelections || [];
5239 var id = oRecord.getId();
5240
5241 // Is it selected?
5242 for(var j=0; j<tracker.length; j++) {
5243 if((tracker[j].recordId === id) && (tracker[j].columnId === nColumnId)){
5244 // Remove from tracker
5245 tracker.splice(j,1);
5246
5247 // Update tracker
5248 this._aSelections = tracker;
5249
5250 // Update the UI
5251 YAHOO.util.Dom.removeClass(elCell, YAHOO.widget.DataTable.CLASS_SELECTED);
5252
5253 this.fireEvent("cellUnselectEvent", {record:oRecord,
5254 key:this._oColumnSet.getColumn(nColumnId).key, el:elCell});
5255
5256 return;
5257 }
5258 }
5259 }
5260 }
5261 };
5262
5263 /**
5264 * Clears out all cell selections.
5265 *
5266 * @method unselectAllCells
5267 */
5268 YAHOO.widget.DataTable.prototype.unselectAllCells= function() {
5269 // Remove from tracker
5270 var tracker = this._aSelections || [];
5271 for(var j=0; j<tracker.length; j++) {
5272 if(tracker[j].constructor == Object){
5273 tracker.splice(j,1);
5274 }
5275 }
5276
5277 // Update tracker
5278 this._aSelections = tracker;
5279
5280 // Update UI
5281 this._unselectAllTdEls();
5282
5283 //TODO: send data
5284 //TODO: or fire individual cellUnselectEvent
5285 this.fireEvent("unselectAllCellsEvent");
5286 };
5287
5288 /**
5289 * Returns true if given TR or TD element is select, false otherwise.
5290 *
5291 * @method isSelected
5292 * @param el {HTMLElement} HTML element reference or ID of a TR or TD.
5293 * @return {Boolean} True if element is selected.
5294 */
5295 YAHOO.widget.DataTable.prototype.isSelected = function(el) {
5296 return YAHOO.util.Dom.hasClass(el,YAHOO.widget.DataTable.CLASS_SELECTED);
5297 };
5298
5299 /**
5300 * Returns selected rows as an array of Record IDs.
5301 *
5302 * @method getSelectedRows
5303 * @return {HTMLElement[]} Array of selected rows by Record ID.
5304 */
5305 YAHOO.widget.DataTable.prototype.getSelectedRows = function() {
5306 var aSelectedRows = [];
5307 var tracker = this._aSelections || [];
5308 for(var j=0; j<tracker.length; j++) {
5309 if(YAHOO.lang.isNumber(tracker[j])){
5310 aSelectedRows.push(tracker[j]);
5311 }
5312 }
5313 return aSelectedRows;
5314 };
5315
5316 /**
5317 * Returns selected cells as an array of object literals:
5318 * {recordId:nRecordID, columnId:nColumnId}.
5319 *
5320 * @method getSelectedCells
5321 * @return {HTMLElement[]} Array of selected cells by Record and Column IDs.
5322 */
5323 YAHOO.widget.DataTable.prototype.getSelectedCells = function() {
5324 var aSelectedCells = [];
5325 var tracker = this._aSelections || [];
5326 for(var j=0; j<tracker.length; j++) {
5327 if(tracker[j] && (tracker[j].constructor == Object)){
5328 aSelectedCells.push({recordId:tracker[j].recordId, columnId:tracker[j].columnId});
5329 }
5330 }
5331 return aSelectedCells;
5332 };
5333
5334 /**
5335 * Assigns the class YAHOO.widget.DataTable.CLASS_HIGHLIGHTED to the given row.
5336 *
5337 * @method highlightRow
5338 * @param row {HTMLElement | String} DOM element reference or ID string.
5339 */
5340 YAHOO.widget.DataTable.prototype.highlightRow = function(row) {
5341 var elRow = this.getTrEl(row);
5342
5343 if(elRow) {
5344 // Make sure previous row is unhighlighted
5345 if(this._sLastHighlightedRowId) {
5346 YAHOO.util.Dom.removeClass(this._sLastHighlightedRowId,YAHOO.widget.DataTable.CLASS_HIGHLIGHTED);
5347 }
5348 var oRecord = this.getRecord(elRow);
5349 YAHOO.util.Dom.addClass(elRow,YAHOO.widget.DataTable.CLASS_HIGHLIGHTED);
5350 this._sLastHighlightedRowId = elRow.id;
5351 this.fireEvent("rowHighlightEvent", {record:oRecord, el:elRow});
5352 return;
5353 }
5354 };
5355
5356 /**
5357 * Removes the class YAHOO.widget.DataTable.CLASS_HIGHLIGHTED from the given row.
5358 *
5359 * @method unhighlightRow
5360 * @param row {HTMLElement | String} DOM element reference or ID string.
5361 */
5362 YAHOO.widget.DataTable.prototype.unhighlightRow = function(row) {
5363 var elRow = this.getTrEl(row);
5364
5365 if(elRow) {
5366 var oRecord = this.getRecord(elRow);
5367 YAHOO.util.Dom.removeClass(elRow,YAHOO.widget.DataTable.CLASS_HIGHLIGHTED);
5368 this.fireEvent("rowUnhighlightEvent", {record:oRecord, el:elRow});
5369 return;
5370 }
5371 };
5372
5373 /**
5374 * Assigns the class YAHOO.widget.DataTable.CLASS_HIGHLIGHTED to the given cell.
5375 *
5376 * @method highlightCell
5377 * @param cell {HTMLElement | String} DOM element reference or ID string.
5378 */
5379 YAHOO.widget.DataTable.prototype.highlightCell = function(cell) {
5380 var elCell = this.getTdEl(cell);
5381
5382 if(elCell) {
5383 // Make sure previous cell is unhighlighted
5384 if(this._sLastHighlightedCellId) {
5385 YAHOO.util.Dom.removeClass(this._sLastHighlightedCellId,YAHOO.widget.DataTable.CLASS_HIGHLIGHTED);
5386 }
5387
5388 var oRecord = this.getRecord(elCell);
5389 YAHOO.util.Dom.addClass(elCell,YAHOO.widget.DataTable.CLASS_HIGHLIGHTED);
5390 this._sLastHighlightedCellId = elCell.id;
5391 this.fireEvent("cellHighlightEvent", {record:oRecord,
5392 key:this._oColumnSet.getColumn(elCell.yuiColumnId).key, el:elCell});
5393 return;
5394 }
5395 };
5396
5397 /**
5398 * Removes the class YAHOO.widget.DataTable.CLASS_HIGHLIGHTED from the given cell.
5399 *
5400 * @method unhighlightCell
5401 * @param cell {HTMLElement | String} DOM element reference or ID string.
5402 */
5403 YAHOO.widget.DataTable.prototype.unhighlightCell = function(cell) {
5404 var elCell = this.getTdEl(cell);
5405
5406 if(elCell) {
5407 var oRecord = this.getRecord(elCell);
5408 YAHOO.util.Dom.removeClass(elCell,YAHOO.widget.DataTable.CLASS_HIGHLIGHTED);
5409 this.fireEvent("cellUnhighlightEvent", {record:oRecord,
5410 key:this._oColumnSet.getColumn(elCell.yuiColumnId).key, el:elCell});
5411 return;
5412 }
5413 };
5414
5415
5416
5417
5418
5419
5420
5421
5422
5423
5424
5425
5426
5427
5428
5429
5430
5431
5432
5433
5434
5435
5436
5437
5438
5439
5440
5441
5442
5443
5444
5445
5446
5447
5448
5449
5450
5451
5452
5453
5454
5455
5456
5457
5458
5459 // INLINE EDITING
5460
5461 /*TODO: for TAB handling
5462 * Shows Cell Editor for next cell.
5463 *
5464 * @method editNextCell
5465 * @param elCell {HTMLElement} Cell element from which to edit next cell.
5466 */
5467 //YAHOO.widget.DataTable.prototype.editNextCell = function(elCell) {
5468 //};
5469
5470 /**
5471 * Shows Cell Editor for given cell.
5472 *
5473 * @method showCellEditor
5474 * @param elCell {HTMLElement | String} Cell element to edit.
5475 * @param oRecord {YAHOO.widget.Record} (Optional) Record instance.
5476 * @param oColumn {YAHOO.widget.Column} (Optional) Column instance.
5477 */
5478 YAHOO.widget.DataTable.prototype.showCellEditor = function(elCell, oRecord, oColumn) {
5479 elCell = YAHOO.util.Dom.get(elCell);
5480
5481 if(elCell && (elCell.ownerDocument === document)) {
5482 if(!oRecord || !(oRecord instanceof YAHOO.widget.Record)) {
5483 oRecord = this.getRecord(elCell);
5484 }
5485 if(!oColumn || !(oColumn instanceof YAHOO.widget.Column)) {
5486 oColumn = this.getColumn(elCell);
5487 }
5488 if(oRecord && oColumn) {
5489 var oCellEditor = this._oCellEditor;
5490
5491 // Clear previous Editor
5492 if(oCellEditor.isActive) {
5493 this.cancelCellEditor();
5494 }
5495
5496 // Editor not defined
5497 if(!oColumn.editor) {
5498 return;
5499 }
5500
5501 // Update Editor values
5502 oCellEditor.cell = elCell;
5503 oCellEditor.record = oRecord;
5504 oCellEditor.column = oColumn;
5505 oCellEditor.validator = (oColumn.editorOptions &&
5506 YAHOO.lang.isFunction(oColumn.editorOptions.validator)) ?
5507 oColumn.editorOptions.validator : null;
5508 oCellEditor.value = oRecord.getData(oColumn.key);
5509
5510 // Move Editor
5511 var elContainer = oCellEditor.container;
5512 var x = YAHOO.util.Dom.getX(elCell);
5513 var y = YAHOO.util.Dom.getY(elCell);
5514
5515 // SF doesn't get xy for cells in scrolling table
5516 // when tbody display is set to block
5517 if(isNaN(x) || isNaN(y)) {
5518 x = elCell.offsetLeft + // cell pos relative to table
5519 YAHOO.util.Dom.getX(this._elTable) - // plus table pos relative to document
5520 this._elTbody.scrollLeft; // minus tbody scroll
5521 y = elCell.offsetTop + // cell pos relative to table
5522 YAHOO.util.Dom.getY(this._elTable) - // plus table pos relative to document
5523 this._elTbody.scrollTop + // minus tbody scroll
5524 this._elThead.offsetHeight; // account for fixed headers
5525 }
5526
5527 elContainer.style.left = x + "px";
5528 elContainer.style.top = y + "px";
5529
5530 // Show Editor
5531 elContainer.style.display = "";
5532
5533 // Render Editor markup
5534 var fnEditor;
5535 if(YAHOO.lang.isString(oColumn.editor)) {
5536 switch(oColumn.editor) {
5537 case "checkbox":
5538 fnEditor = YAHOO.widget.DataTable.editCheckbox;
5539 break;
5540 case "date":
5541 fnEditor = YAHOO.widget.DataTable.editDate;
5542 break;
5543 case "dropdown":
5544 fnEditor = YAHOO.widget.DataTable.editDropdown;
5545 break;
5546 case "radio":
5547 fnEditor = YAHOO.widget.DataTable.editRadio;
5548 break;
5549 case "textarea":
5550 fnEditor = YAHOO.widget.DataTable.editTextarea;
5551 break;
5552 case "textbox":
5553 fnEditor = YAHOO.widget.DataTable.editTextbox;
5554 break;
5555 default:
5556 fnEditor = null;
5557 }
5558 }
5559 else if(YAHOO.lang.isFunction(oColumn.editor)) {
5560 fnEditor = oColumn.editor;
5561 }
5562
5563 if(fnEditor) {
5564 // Create DOM input elements
5565 fnEditor(this._oCellEditor, this);
5566
5567 // Show Save/Cancel buttons
5568 if(!oColumn.editorOptions || !oColumn.editorOptions.disableBtns) {
5569 this.showCellEditorBtns(elContainer);
5570 }
5571
5572 // Hook to customize the UI
5573 this.doBeforeShowCellEditor(this._oCellEditor);
5574
5575 oCellEditor.isActive = true;
5576
5577 //TODO: verify which args to pass
5578 this.fireEvent("editorShowEvent", {editor:oCellEditor});
5579 return;
5580 }
5581 }
5582 }
5583 };
5584
5585 /**
5586 * Overridable abstract method to customize Cell Editor UI.
5587 *
5588 * @method doBeforeShowCellEditor
5589 * @param oCellEditor {Object} Cell Editor object literal.
5590 */
5591 YAHOO.widget.DataTable.prototype.doBeforeShowCellEditor = function(oCellEditor) {
5592 };
5593
5594 /**
5595 * Adds Save/Cancel buttons to Cell Editor.
5596 *
5597 * @method showCellEditorBtns
5598 * @param elContainer {HTMLElement} Cell Editor container.
5599 */
5600 YAHOO.widget.DataTable.prototype.showCellEditorBtns = function(elContainer) {
5601 // Buttons
5602 var elBtnsDiv = elContainer.appendChild(document.createElement("div"));
5603 YAHOO.util.Dom.addClass(elBtnsDiv, YAHOO.widget.DataTable.CLASS_BUTTON);
5604
5605 // Save button
5606 var elSaveBtn = elBtnsDiv.appendChild(document.createElement("button"));
5607 YAHOO.util.Dom.addClass(elSaveBtn, YAHOO.widget.DataTable.CLASS_DEFAULT);
5608 elSaveBtn.innerHTML = "OK";
5609 YAHOO.util.Event.addListener(elSaveBtn, "click", this.saveCellEditor, this, true);
5610
5611 // Cancel button
5612 var elCancelBtn = elBtnsDiv.appendChild(document.createElement("button"));
5613 elCancelBtn.innerHTML = "Cancel";
5614 YAHOO.util.Event.addListener(elCancelBtn, "click", this.cancelCellEditor, this, true);
5615 };
5616
5617 /**
5618 * Clears Cell Editor of all state and UI.
5619 *
5620 * @method resetCellEditor
5621 */
5622
5623 YAHOO.widget.DataTable.prototype.resetCellEditor = function() {
5624 var elContainer = this._oCellEditor.container;
5625 elContainer.style.display = "none";
5626 YAHOO.util.Event.purgeElement(elContainer, true);
5627 elContainer.innerHTML = "";
5628 this._oCellEditor.value = null;
5629 this._oCellEditor.isActive = false;
5630 };
5631
5632 /**
5633 * Saves Cell Editor input to Record.
5634 *
5635 * @method saveCellEditor
5636 */
5637 YAHOO.widget.DataTable.prototype.saveCellEditor = function() {
5638 //TODO: Copy the editor's values to pass to the event
5639 if(this._oCellEditor.isActive) {
5640 var newData = this._oCellEditor.value;
5641 var oldData = this._oCellEditor.record.getData(this._oCellEditor.column.key);
5642
5643 // Validate input data
5644 if(this._oCellEditor.validator) {
5645 this._oCellEditor.value = this._oCellEditor.validator.call(this, newData, oldData);
5646 if(this._oCellEditor.value === null ) {
5647 this.resetCellEditor();
5648 this.fireEvent("editorRevertEvent",
5649 {editor:this._oCellEditor, oldData:oldData, newData:newData});
5650 return;
5651 }
5652 }
5653
5654 // Update the Record
5655 this._oRecordSet.updateKey(this._oCellEditor.record, this._oCellEditor.column.key, this._oCellEditor.value);
5656
5657 // Update the UI
5658 this.formatCell(this._oCellEditor.cell);
5659
5660 // Clear out the Cell Editor
5661 this.resetCellEditor();
5662
5663 this.fireEvent("editorSaveEvent",
5664 {editor:this._oCellEditor, oldData:oldData, newData:newData});
5665 }
5666 else {
5667 }
5668 };
5669
5670 /**
5671 * Cancels Cell Editor.
5672 *
5673 * @method cancelCellEditor
5674 */
5675 YAHOO.widget.DataTable.prototype.cancelCellEditor = function() {
5676 if(this._oCellEditor.isActive) {
5677 this.resetCellEditor();
5678 //TODO: preserve values for the event?
5679 this.fireEvent("editorCancelEvent", {editor:this._oCellEditor});
5680 }
5681 else {
5682 }
5683 };
5684
5685 /**
5686 * Enables CHECKBOX Editor.
5687 *
5688 * @method editCheckbox
5689 */
5690 //YAHOO.widget.DataTable.editCheckbox = function(elContainer, oRecord, oColumn, oEditor, oSelf) {
5691 YAHOO.widget.DataTable.editCheckbox = function(oEditor, oSelf) {
5692 var elCell = oEditor.cell;
5693 var oRecord = oEditor.record;
5694 var oColumn = oEditor.column;
5695 var elContainer = oEditor.container;
5696 var aCheckedValues = oRecord.getData(oColumn.key);
5697 if(!YAHOO.lang.isArray(aCheckedValues)) {
5698 aCheckedValues = [aCheckedValues];
5699 }
5700
5701 // Checkboxes
5702 if(oColumn.editorOptions && YAHOO.lang.isArray(oColumn.editorOptions.checkboxOptions)) {
5703 var checkboxOptions = oColumn.editorOptions.checkboxOptions;
5704 var checkboxValue, checkboxId, elLabel, j, k;
5705 // First create the checkbox buttons in an IE-friendly way
5706 for(j=0; j<checkboxOptions.length; j++) {
5707 checkboxValue = YAHOO.lang.isValue(checkboxOptions[j].label) ?
5708 checkboxOptions[j].label : checkboxOptions[j];
5709 checkboxId = oSelf.id + "-editor-checkbox" + j;
5710 elContainer.innerHTML += "<input type=\"checkbox\"" +
5711 " name=\"" + oSelf.id + "-editor-checkbox\"" +
5712 " value=\"" + checkboxValue + "\"" +
5713 " id=\"" + checkboxId + "\">";
5714 // Then create the labels in an IE-friendly way
5715 elLabel = elContainer.appendChild(document.createElement("label"));
5716 elLabel.htmlFor = checkboxId;
5717 elLabel.innerHTML = checkboxValue;
5718 }
5719 var aCheckboxEls = [];
5720 var checkboxEl;
5721 // Loop through checkboxes to check them
5722 for(j=0; j<checkboxOptions.length; j++) {
5723 checkboxEl = YAHOO.util.Dom.get(oSelf.id + "-editor-checkbox" + j);
5724 aCheckboxEls.push(checkboxEl);
5725 for(k=0; k<aCheckedValues.length; k++) {
5726 if(checkboxEl.value === aCheckedValues[k]) {
5727 checkboxEl.checked = true;
5728 }
5729 }
5730 // Focus the first checkbox
5731 if(j===0) {
5732 oSelf._focusEl(checkboxEl);
5733 }
5734 }
5735 // Loop through checkboxes to assign click handlers
5736 for(j=0; j<checkboxOptions.length; j++) {
5737 checkboxEl = YAHOO.util.Dom.get(oSelf.id + "-editor-checkbox" + j);
5738 YAHOO.util.Event.addListener(checkboxEl, "click", function(){
5739 var aNewValues = [];
5740 for(var m=0; m<aCheckboxEls.length; m++) {
5741 if(aCheckboxEls[m].checked) {
5742 aNewValues.push(aCheckboxEls[m].value);
5743 }
5744 }
5745 oSelf._oCellEditor.value = aNewValues;
5746 oSelf.fireEvent("editorUpdateEvent",{editor:oSelf._oCellEditor});
5747 });
5748 }
5749 }
5750 };
5751
5752 /**
5753 * Enables Date Editor.
5754 *
5755 * @method editDate
5756 */
5757 YAHOO.widget.DataTable.editDate = function(oEditor, oSelf) {
5758 var elCell = oEditor.cell;
5759 var oRecord = oEditor.record;
5760 var oColumn = oEditor.column;
5761 var elContainer = oEditor.container;
5762 var value = oRecord.getData(oColumn.key);
5763
5764 // Calendar widget
5765 if(YAHOO.widget.Calendar) {
5766 var selectedValue = (value.getMonth()+1)+"/"+value.getDate()+"/"+value.getFullYear();
5767 var calContainer = elContainer.appendChild(document.createElement("div"));
5768 calContainer.id = "yui-dt-" + oSelf._nIndex + "-col" + oColumn.getKeyIndex() + "-dateContainer";
5769 var calendar =
5770 new YAHOO.widget.Calendar("yui-dt-" + oSelf._nIndex + "-col" + oColumn.getKeyIndex() + "-date",
5771 calContainer.id,
5772 {selected:selectedValue, pagedate:value});
5773 calendar.render();
5774 calContainer.style.cssFloat = "none";
5775
5776 //var calFloatClearer = elContainer.appendChild(document.createElement("br"));
5777 //calFloatClearer.style.clear = "both";
5778
5779 calendar.selectEvent.subscribe(function(type, args, obj) {
5780 oSelf._oCellEditor.value = new Date(args[0][0][0], args[0][0][1]-1, args[0][0][2]);
5781 });
5782 oSelf.fireEvent("editorUpdateEvent",{editor:oSelf._oCellEditor});
5783 }
5784 else {
5785 //TODO;
5786 }
5787 };
5788
5789 /**
5790 * Enables SELECT Editor.
5791 *
5792 * @method editDropdown
5793 */
5794 YAHOO.widget.DataTable.editDropdown = function(oEditor, oSelf) {
5795 var elCell = oEditor.cell;
5796 var oRecord = oEditor.record;
5797 var oColumn = oEditor.column;
5798 var elContainer = oEditor.container;
5799 var value = oRecord.getData(oColumn.key);
5800
5801 // Textbox
5802 var elDropdown = elContainer.appendChild(document.createElement("select"));
5803 var dropdownOptions = (oColumn.editorOptions && YAHOO.lang.isArray(oColumn.editorOptions.dropdownOptions)) ?
5804 oColumn.editorOptions.dropdownOptions : [];
5805 for(var j=0; j<dropdownOptions.length; j++) {
5806 var dropdownOption = dropdownOptions[j];
5807 var elOption = document.createElement("option");
5808 elOption.value = (YAHOO.lang.isValue(dropdownOption.value)) ?
5809 dropdownOption.value : dropdownOption;
5810 elOption.innerHTML = (YAHOO.lang.isValue(dropdownOption.text)) ?
5811 dropdownOption.text : dropdownOption;
5812 elOption = elDropdown.appendChild(elOption);
5813 if(value === elDropdown.options[j].value) {
5814 elDropdown.options[j].selected = true;
5815 }
5816 }
5817
5818 // Set up a listener on each check box to track the input value
5819 YAHOO.util.Event.addListener(elDropdown, "change",
5820 function(){
5821 oSelf._oCellEditor.value = elDropdown[elDropdown.selectedIndex].value;
5822 oSelf.fireEvent("editorUpdateEvent",{editor:oSelf._oCellEditor});
5823 });
5824
5825 // Focus the dropdown
5826 oSelf._focusEl(elDropdown);
5827 };
5828
5829 /**
5830 * Enables INPUT TYPE=RADIO Editor.
5831 *
5832 * @method editRadio
5833 */
5834 YAHOO.widget.DataTable.editRadio = function(oEditor, oSelf) {
5835 var elCell = oEditor.cell;
5836 var oRecord = oEditor.record;
5837 var oColumn = oEditor.column;
5838 var elContainer = oEditor.container;
5839 var value = oRecord.getData(oColumn.key);
5840
5841 // Radios
5842 if(oColumn.editorOptions && YAHOO.lang.isArray(oColumn.editorOptions.radioOptions)) {
5843 var radioOptions = oColumn.editorOptions.radioOptions;
5844 var radioValue, radioId, elLabel, j;
5845 // First create the radio buttons in an IE-friendly way
5846 for(j=0; j<radioOptions.length; j++) {
5847 radioValue = YAHOO.lang.isValue(radioOptions[j].label) ?
5848 radioOptions[j].label : radioOptions[j];
5849 radioId = oSelf.id + "-editor-radio" + j;
5850 elContainer.innerHTML += "<input type=\"radio\"" +
5851 " name=\"" + oSelf.id + "-editor-radio\"" +
5852 " value=\"" + radioValue + "\"" +
5853 " id=\"" + radioId + "\">";
5854 // Then create the labels in an IE-friendly way
5855 elLabel = elContainer.appendChild(document.createElement("label"));
5856 elLabel.htmlFor = radioId;
5857 elLabel.innerHTML = radioValue;
5858 }
5859 // Then check one, and assign click handlers
5860 for(j=0; j<radioOptions.length; j++) {
5861 var radioEl = YAHOO.util.Dom.get(oSelf.id + "-editor-radio" + j);
5862 if(value === radioEl.value) {
5863 radioEl.checked = true;
5864 oSelf._focusEl(radioEl);
5865 }
5866 YAHOO.util.Event.addListener(radioEl, "click",
5867 function(){
5868 oSelf._oCellEditor.value = this.value;
5869 oSelf.fireEvent("editorUpdateEvent",{editor:oSelf._oCellEditor});
5870 });
5871 }
5872 }
5873 };
5874
5875 /**
5876 * Enables TEXTAREA Editor.
5877 *
5878 * @method editTextarea
5879 */
5880 YAHOO.widget.DataTable.editTextarea = function(oEditor, oSelf) {
5881 var elCell = oEditor.cell;
5882 var oRecord = oEditor.record;
5883 var oColumn = oEditor.column;
5884 var elContainer = oEditor.container;
5885 var value = oRecord.getData(oColumn.key);
5886
5887 // Textarea
5888 var elTextarea = elContainer.appendChild(document.createElement("textarea"));
5889 elTextarea.style.width = elCell.offsetWidth + "px"; //(parseInt(elCell.offsetWidth,10)) + "px";
5890 elTextarea.style.height = "3em"; //(parseInt(elCell.offsetHeight,10)) + "px";
5891 elTextarea.value = YAHOO.lang.isValue(value) ? value : "";
5892
5893 // Set up a listener on each check box to track the input value
5894 YAHOO.util.Event.addListener(elTextarea, "keyup", function(){
5895 //TODO: set on a timeout
5896 oSelf._oCellEditor.value = elTextarea.value;
5897 oSelf.fireEvent("editorUpdateEvent",{editor:oSelf._oCellEditor});
5898 });
5899
5900 // Select the text
5901 elTextarea.focus();
5902 elTextarea.select();
5903 };
5904
5905 /**
5906 * Enables INPUT TYPE=TEXT Editor.
5907 *
5908 * @method editTextbox
5909 */
5910 YAHOO.widget.DataTable.editTextbox = function(oEditor, oSelf) {
5911 var elCell = oEditor.cell;
5912 var oRecord = oEditor.record;
5913 var oColumn = oEditor.column;
5914 var elContainer = oEditor.container;
5915 var value = YAHOO.lang.isValue(oRecord.getData(oColumn.key)) ? oRecord.getData(oColumn.key) : "";
5916
5917 // Textbox
5918 var elTextbox = elContainer.appendChild(document.createElement("input"));
5919 elTextbox.type = "text";
5920 elTextbox.style.width = elCell.offsetWidth + "px"; //(parseInt(elCell.offsetWidth,10)) + "px";
5921 //elTextbox.style.height = "1em"; //(parseInt(elCell.offsetHeight,10)) + "px";
5922 elTextbox.value = value;
5923
5924 // Set up a listener on each textbox to track the input value
5925 YAHOO.util.Event.addListener(elTextbox, "keyup", function(){
5926 //TODO: set on a timeout
5927 oSelf._oCellEditor.value = elTextbox.value;
5928 oSelf.fireEvent("editorUpdateEvent",{editor:oSelf._oCellEditor});
5929 });
5930
5931 // Select the text
5932 elTextbox.focus();
5933 elTextbox.select();
5934 };
5935
5936 /*
5937 * Validates Editor input value to type Number, doing type conversion as
5938 * necessary. A valid Number value is return, else the previous value is returned
5939 * if input value does not validate.
5940 *
5941 *
5942 * @method validateNumber
5943 * @static
5944 */
5945 YAHOO.widget.DataTable.validateNumber = function(oData) {
5946 //Convert to number
5947 var number = oData * 1;
5948
5949 // Validate
5950 if(YAHOO.lang.isNumber(number)) {
5951 return number;
5952 }
5953 else {
5954 return null;
5955 }
5956 };
5957
5958
5959
5960
5961
5962
5963
5964
5965
5966
5967
5968
5969
5970
5971
5972
5973
5974
5975
5976
5977
5978
5979
5980
5981
5982
5983
5984
5985
5986
5987
5988
5989
5990
5991
5992
5993
5994
5995 // ABSTRACT METHODS
5996
5997 /**
5998 * Overridable method gives implementers a hook to access data before
5999 * it gets added to RecordSet and rendered to the TBODY.
6000 *
6001 * @method doBeforeLoadData
6002 * @param sRequest {String} Original request.
6003 * @param oResponse {Object} Response object.
6004 * @return {Boolean} Return true to continue loading data into RecordSet and
6005 * updating DataTable with new Records, false to cancel.
6006 */
6007 YAHOO.widget.DataTable.prototype.doBeforeLoadData = function(sRequest, oResponse) {
6008 return true;
6009 };
6010
6011
6012
6013
6014
6015
6016
6017
6018
6019
6020
6021
6022
6023
6024
6025
6026
6027
6028
6029
6030
6031
6032
6033
6034
6035
6036
6037
6038
6039
6040
6041
6042
6043
6044
6045
6046
6047
6048
6049
6050
6051
6052
6053
6054
6055
6056
6057
6058
6059
6060
6061
6062
6063
6064
6065
6066
6067
6068
6069
6070
6071
6072
6073 /////////////////////////////////////////////////////////////////////////////
6074 //
6075 // Public Custom Event Handlers
6076 //
6077 /////////////////////////////////////////////////////////////////////////////
6078
6079 /**
6080 * Overridable custom event handler to sort Column.
6081 *
6082 * @method onEventSortColumn
6083 * @param oArgs.event {HTMLEvent} Event object.
6084 * @param oArgs.target {HTMLElement} Target element.
6085 */
6086 YAHOO.widget.DataTable.prototype.onEventSortColumn = function(oArgs) {
6087 //TODO: support nested header column sorting
6088 var evt = oArgs.event;
6089 var target = oArgs.target;
6090 YAHOO.util.Event.stopEvent(evt);
6091
6092 var el = this.getThEl(target) || this.getTdEl(target);
6093 if(el && YAHOO.lang.isNumber(el.yuiColumnId)) {
6094 this.sortColumn(this._oColumnSet.getColumn(el.yuiColumnId));
6095 }
6096 else {
6097 }
6098 };
6099
6100 /**
6101 * Overridable custom event handler to manage selection according to desktop paradigm.
6102 *
6103 * @method onEventSelectRow
6104 * @param oArgs.event {HTMLEvent} Event object.
6105 * @param oArgs.target {HTMLElement} Target element.
6106 */
6107 YAHOO.widget.DataTable.prototype.onEventSelectRow = function(oArgs) {
6108 var sMode = this.get("selectionMode");
6109 if ((sMode == "singlecell") || (sMode == "cellblock") || (sMode == "cellrange")) {
6110 return;
6111 }
6112
6113 var evt = oArgs.event;
6114 var elTarget = oArgs.target;
6115
6116 var bSHIFT = evt.shiftKey;
6117 var bCTRL = evt.ctrlKey;
6118 var i, nAnchorTrIndex;
6119
6120 // Validate target row
6121 var elTargetRow = this.getTrEl(elTarget);
6122 if(elTargetRow) {
6123 var allRows = this._elTbody.rows;
6124 var nTargetTrIndex = elTargetRow.sectionRowIndex;
6125 var elAnchorRow = YAHOO.util.Dom.get(this._sSelectionAnchorId);
6126
6127 // Both SHIFT and CTRL
6128 if((sMode != "single") && bSHIFT && bCTRL) {
6129 // Validate anchor row
6130 if(elAnchorRow && YAHOO.lang.isNumber(elAnchorRow.sectionRowIndex)) {
6131 nAnchorTrIndex = elAnchorRow.sectionRowIndex;
6132 if(this.isSelected(elAnchorRow)) {
6133 // Select all rows between anchor row and target row, including target row
6134 if(nAnchorTrIndex < nTargetTrIndex) {
6135 for(i=nAnchorTrIndex+1; i<=nTargetTrIndex; i++) {
6136 if(!this.isSelected(allRows[i])) {
6137 this.selectRow(allRows[i]);
6138 }
6139 }
6140 }
6141 // Select all rows between target row and anchor row, including target row
6142 else {
6143 for(i=nAnchorTrIndex-1; i>=nTargetTrIndex; i--) {
6144 if(!this.isSelected(allRows[i])) {
6145 this.selectRow(allRows[i]);
6146 }
6147 }
6148 }
6149 }
6150 else {
6151 // Unselect all rows between anchor row and target row
6152 if(nAnchorTrIndex < nTargetTrIndex) {
6153 for(i=nAnchorTrIndex+1; i<=nTargetTrIndex-1; i++) {
6154 if(this.isSelected(allRows[i])) {
6155 this.unselectRow(allRows[i]);
6156 }
6157 }
6158 }
6159 // Unselect all rows between target row and anchor row
6160 else {
6161 for(i=nTargetTrIndex+1; i<=nAnchorTrIndex-1; i++) {
6162 if(this.isSelected(allRows[i])) {
6163 this.unselectRow(allRows[i]);
6164 }
6165 }
6166 }
6167 // Select the target row
6168 this.selectRow(elTargetRow);
6169 }
6170 }
6171 // Invalid anchor
6172 else {
6173 // Set anchor
6174 this._sSelectionAnchorId = elTargetRow.id;
6175
6176 // Toggle selection of target
6177 if(this.isSelected(elTargetRow)) {
6178 this.unselectRow(elTargetRow);
6179 }
6180 else {
6181 this.selectRow(elTargetRow);
6182 }
6183 }
6184 }
6185 // Only SHIFT
6186 else if((sMode != "single") && bSHIFT) {
6187 this.unselectAllRows();
6188
6189 // Validate anchor
6190 if(elAnchorRow && YAHOO.lang.isNumber(elAnchorRow.sectionRowIndex)) {
6191 nAnchorTrIndex = elAnchorRow.sectionRowIndex;
6192
6193 // Select all rows between anchor row and target row,
6194 // including the anchor row and target row
6195 if(nAnchorTrIndex < nTargetTrIndex) {
6196 for(i=nAnchorTrIndex; i<=nTargetTrIndex; i++) {
6197 this.selectRow(allRows[i]);
6198 }
6199 }
6200 // Select all rows between target row and anchor row,
6201 // including the target row and anchor row
6202 else {
6203 for(i=nAnchorTrIndex; i>=nTargetTrIndex; i--) {
6204 this.selectRow(allRows[i]);
6205 }
6206 }
6207 }
6208 // Invalid anchor
6209 else {
6210 // Set anchor
6211 this._sSelectionAnchorId = elTargetRow.id;
6212
6213 // Select target row only
6214 this.selectRow(elTargetRow);
6215 }
6216 }
6217 // Only CTRL
6218 else if((sMode != "single") && bCTRL) {
6219 // Set anchor
6220 this._sSelectionAnchorId = elTargetRow.id;
6221
6222 // Toggle selection of target
6223 if(this.isSelected(elTargetRow)) {
6224 this.unselectRow(elTargetRow);
6225 }
6226 else {
6227 this.selectRow(elTargetRow);
6228 }
6229 }
6230 // Neither SHIFT nor CTRL
6231 else if(sMode == "single") {
6232 this.unselectAllRows();
6233 this.selectRow(elTargetRow);
6234 }
6235 // Neither SHIFT nor CTRL
6236 else {
6237 // Set anchor
6238 this._sSelectionAnchorId = elTargetRow.id;
6239
6240 // Select only target
6241 this.unselectAllRows();
6242 this.selectRow(elTargetRow);
6243 }
6244 YAHOO.util.Event.stopEvent(evt);
6245
6246 // Clear any selections that are a byproduct of the click or dblclick
6247 var sel;
6248 if(window.getSelection) {
6249 sel = window.getSelection();
6250 }
6251 else if(document.getSelection) {
6252 sel = document.getSelection();
6253 }
6254 else if(document.selection) {
6255 sel = document.selection;
6256 }
6257 if(sel) {
6258 if(sel.empty) {
6259 sel.empty();
6260 }
6261 else if (sel.removeAllRanges) {
6262 sel.removeAllRanges();
6263 }
6264 else if(sel.collapse) {
6265 sel.collapse();
6266 }
6267 }
6268 }
6269 else {
6270 }
6271 };
6272
6273 /**
6274 * Overridable custom event handler to select cell.
6275 *
6276 * @method onEventSelectCell
6277 * @param oArgs.event {HTMLEvent} Event object.
6278 * @param oArgs.target {HTMLElement} Target element.
6279 */
6280 YAHOO.widget.DataTable.prototype.onEventSelectCell = function(oArgs) {
6281 var sMode = this.get("selectionMode");
6282 if ((sMode == "standard") || (sMode == "single")) {
6283 return;
6284 }
6285
6286 var evt = oArgs.event;
6287 var elTarget = oArgs.target;
6288
6289 var bSHIFT = evt.shiftKey;
6290 var bCTRL = evt.ctrlKey;
6291 var i, j, nAnchorTrIndex, nAnchorTdIndex, currentRow, startIndex, endIndex;
6292
6293 var elTargetCell = this.getTdEl(elTarget);
6294 if(elTargetCell) {
6295 var elTargetRow = this.getTrEl(elTargetCell);
6296 var allRows = this._elTbody.rows;
6297 var nTargetTrIndex = elTargetRow.sectionRowIndex;
6298 var nTargetTdIndex = elTarget.yuiCellIndex;
6299 var elAnchorCell = YAHOO.util.Dom.get(this._sSelectionAnchorId);
6300
6301 // Both SHIFT and CTRL
6302 if((sMode != "singlecell") && bSHIFT && bCTRL) {
6303 // Validate anchor
6304 if(elAnchorCell && YAHOO.lang.isNumber(elAnchorCell.yuiCellIndex)) {
6305 nAnchorTrIndex = elAnchorCell.parentNode.sectionRowIndex;
6306 nAnchorTdIndex = elAnchorCell.yuiCellIndex;
6307
6308 // Anchor is selected
6309 if(this.isSelected(elAnchorCell)) {
6310 // All cells are on the same row
6311 if(nAnchorTrIndex == nTargetTrIndex) {
6312 // Select all cells between anchor cell and target cell, including target cell
6313 if(nAnchorTdIndex < nTargetTdIndex) {
6314 for(i=nAnchorTdIndex+1; i<=nTargetTdIndex; i++) {
6315 this.selectCell(allRows[nTargetTrIndex].cells[i]);
6316 }
6317 }
6318 // Select all cells between target cell and anchor cell, including target cell
6319 else if(nTargetTdIndex < nAnchorTdIndex) {
6320 for(i=nTargetTdIndex; i<nAnchorTdIndex; i++) {
6321 this.selectCell(allRows[nTargetTrIndex].cells[i]);
6322 }
6323 }
6324 }
6325 // Anchor row is above target row
6326 else if(nAnchorTrIndex < nTargetTrIndex) {
6327 if(sMode == "cellrange") {
6328 // Select all cells on anchor row from anchor cell to the end of the row
6329 for(i=nAnchorTdIndex+1; i<allRows[nAnchorTrIndex].cells.length; i++) {
6330 this.selectCell(allRows[nAnchorTrIndex].cells[i]);
6331 }
6332
6333 // Select all cells on all rows between anchor row and target row
6334 for(i=nAnchorTrIndex+1; i<nTargetTrIndex; i++) {
6335 for(j=0; j<allRows[i].cells.length; j++){
6336 this.selectCell(allRows[i].cells[j]);
6337 }
6338 }
6339
6340 // Select all cells on target row from first cell to the target cell
6341 for(i=0; i<=nTargetTdIndex; i++) {
6342 this.selectCell(allRows[nTargetTrIndex].cells[i]);
6343 }
6344 }
6345 else if(sMode == "cellblock") {
6346 startIndex = Math.min(nAnchorTdIndex, nTargetTdIndex);
6347 endIndex = Math.max(nAnchorTdIndex, nTargetTdIndex);
6348
6349 // Select all cells from startIndex to endIndex on rows between anchor row and target row
6350 for(i=nAnchorTrIndex; i<=nTargetTrIndex; i++) {
6351 for(j=startIndex; j<=endIndex; j++) {
6352 this.selectCell(allRows[i].cells[j]);
6353 }
6354 }
6355 }
6356 }
6357 // Anchor row is below target row
6358 else {
6359 if(sMode == "cellrange") {
6360 // Select all cells on target row from target cell to the end of the row
6361 for(i=nTargetTdIndex; i<allRows[nTargetTrIndex].cells.length; i++) {
6362 this.selectCell(allRows[nTargetTrIndex].cells[i]);
6363 }
6364
6365 // Select all cells on all rows between target row and anchor row
6366 for(i=nTargetTrIndex+1; i<nAnchorTrIndex; i++) {
6367 for(j=0; j<allRows[i].cells.length; j++){
6368 this.selectCell(allRows[i].cells[j]);
6369 }
6370 }
6371
6372 // Select all cells on anchor row from first cell to the anchor cell
6373 for(i=0; i<nAnchorTdIndex; i++) {
6374 this.selectCell(allRows[nAnchorTrIndex].cells[i]);
6375 }
6376 }
6377 else if(sMode == "cellblock") {
6378 startIndex = Math.min(nAnchorTdIndex, nTargetTdIndex);
6379 endIndex = Math.max(nAnchorTdIndex, nTargetTdIndex);
6380
6381 // Select all cells from startIndex to endIndex on rows between target row and anchor row
6382 for(i=nAnchorTrIndex; i>=nTargetTrIndex; i--) {
6383 for(j=endIndex; j>=startIndex; j--) {
6384 this.selectCell(allRows[i].cells[j]);
6385 }
6386 }
6387 }
6388 }
6389 }
6390 // Anchor cell is unselected
6391 else {
6392 // All cells are on the same row
6393 if(nAnchorTrIndex == nTargetTrIndex) {
6394 // Unselect all cells between anchor cell and target cell
6395 if(nAnchorTdIndex < nTargetTdIndex) {
6396 for(i=nAnchorTdIndex+1; i<nTargetTdIndex; i++) {
6397 this.unselectCell(allRows[nTargetTrIndex].cells[i]);
6398 }
6399 }
6400 // Select all cells between target cell and anchor cell
6401 else if(nTargetTdIndex < nAnchorTdIndex) {
6402 for(i=nTargetTdIndex+1; i<nAnchorTdIndex; i++) {
6403 this.unselectCell(allRows[nTargetTrIndex].cells[i]);
6404 }
6405 }
6406 }
6407 // Anchor row is above target row
6408 if(nAnchorTrIndex < nTargetTrIndex) {
6409 // Unselect all cells from anchor cell to target cell
6410 for(i=nAnchorTrIndex; i<=nTargetTrIndex; i++) {
6411 currentRow = allRows[i];
6412 for(j=0; j<currentRow.cells.length; j++) {
6413 // This is the anchor row, only unselect cells after the anchor cell
6414 if(currentRow.sectionRowIndex == nAnchorTrIndex) {
6415 if(j>nAnchorTdIndex) {
6416 this.unselectCell(currentRow.cells[j]);
6417 }
6418 }
6419 // This is the target row, only unelect cells before the target cell
6420 else if(currentRow.sectionRowIndex == nTargetTrIndex) {
6421 if(j<nTargetTdIndex) {
6422 this.unselectCell(currentRow.cells[j]);
6423 }
6424 }
6425 // Unselect all cells on this row
6426 else {
6427 this.unselectCell(currentRow.cells[j]);
6428 }
6429 }
6430 }
6431 }
6432 // Anchor row is below target row
6433 else {
6434 // Unselect all cells from target cell to anchor cell
6435 for(i=nTargetTrIndex; i<=nAnchorTrIndex; i++) {
6436 currentRow = allRows[i];
6437 for(j=0; j<currentRow.cells.length; j++) {
6438 // This is the target row, only unselect cells after the target cell
6439 if(currentRow.sectionRowIndex == nTargetTrIndex) {
6440 if(j>nTargetTdIndex) {
6441 this.unselectCell(currentRow.cells[j]);
6442 }
6443 }
6444 // This is the anchor row, only unselect cells before the anchor cell
6445 else if(currentRow.sectionRowIndex == nAnchorTrIndex) {
6446 if(j<nAnchorTdIndex) {
6447 this.unselectCell(currentRow.cells[j]);
6448 }
6449 }
6450 // Unselect all cells on this row
6451 else {
6452 this.unselectCell(currentRow.cells[j]);
6453 }
6454 }
6455 }
6456 }
6457
6458 // Select the target cell
6459 this.selectCell(elTargetCell);
6460 }
6461 }
6462 // Invalid anchor
6463 else {
6464 // Set anchor
6465 this._sSelectionAnchorId = elTargetCell.id;
6466
6467 // Toggle selection of target
6468 if(this.isSelected(elTargetCell)) {
6469 this.unselectCell(elTargetCell);
6470 }
6471 else {
6472 this.selectCell(elTargetCell);
6473 }
6474 }
6475 }
6476 // Only SHIFT
6477 else if((sMode != "singlecell") && bSHIFT) {
6478 this.unselectAllCells();
6479
6480 // Validate anchor
6481 if(elAnchorCell && YAHOO.lang.isNumber(elAnchorCell.yuiCellIndex)) {
6482 nAnchorTrIndex = elAnchorCell.parentNode.sectionRowIndex;
6483 nAnchorTdIndex = elAnchorCell.yuiCellIndex;
6484
6485 // All cells are on the same row
6486 if(nAnchorTrIndex == nTargetTrIndex) {
6487 // Select all cells between anchor cell and target cell,
6488 // including the anchor cell and target cell
6489 if(nAnchorTdIndex < nTargetTdIndex) {
6490 for(i=nAnchorTdIndex; i<=nTargetTdIndex; i++) {
6491 this.selectCell(allRows[nTargetTrIndex].cells[i]);
6492 }
6493 }
6494 // Select all cells between target cell and anchor cell
6495 // including the target cell and anchor cell
6496 else if(nTargetTdIndex < nAnchorTdIndex) {
6497 for(i=nTargetTdIndex; i<=nAnchorTdIndex; i++) {
6498 this.selectCell(allRows[nTargetTrIndex].cells[i]);
6499 }
6500 }
6501 }
6502 // Anchor row is above target row
6503 else if(nAnchorTrIndex < nTargetTrIndex) {
6504 if(sMode == "cellrange") {
6505 // Select all cells from anchor cell to target cell
6506 // including the anchor cell and target cell
6507 for(i=nAnchorTrIndex; i<=nTargetTrIndex; i++) {
6508 currentRow = allRows[i];
6509 for(j=0; j<currentRow.cells.length; j++) {
6510 // This is the anchor row, only select the anchor cell and after
6511 if(currentRow.sectionRowIndex == nAnchorTrIndex) {
6512 if(j>=nAnchorTdIndex) {
6513 this.selectCell(currentRow.cells[j]);
6514 }
6515 }
6516 // This is the target row, only select the target cell and before
6517 else if(currentRow.sectionRowIndex == nTargetTrIndex) {
6518 if(j<=nTargetTdIndex) {
6519 this.selectCell(currentRow.cells[j]);
6520 }
6521 }
6522 // Select all cells on this row
6523 else {
6524 this.selectCell(currentRow.cells[j]);
6525 }
6526 }
6527 }
6528 }
6529 else if(sMode == "cellblock") {
6530 // Select the cellblock from anchor cell to target cell
6531 // including the anchor cell and the target cell
6532 startIndex = Math.min(nAnchorTdIndex, nTargetTdIndex);
6533 endIndex = Math.max(nAnchorTdIndex, nTargetTdIndex);
6534
6535 for(i=nAnchorTrIndex; i<=nTargetTrIndex; i++) {
6536 for(j=startIndex; j<=endIndex; j++) {
6537 this.selectCell(allRows[i].cells[j]);
6538 }
6539 }
6540
6541 this._sLastSelectedId = allRows[nTargetTrIndex].cells[nTargetTdIndex].id;
6542 }
6543 }
6544 // Anchor row is below target row
6545 else {
6546 if(sMode == "cellrange") {
6547 // Select all cells from target cell to anchor cell,
6548 // including the target cell and anchor cell
6549 for(i=nTargetTrIndex; i<=nAnchorTrIndex; i++) {
6550 currentRow = allRows[i];
6551 for(j=0; j<currentRow.cells.length; j++) {
6552 // This is the target row, only select the target cell and after
6553 if(currentRow.sectionRowIndex == nTargetTrIndex) {
6554 if(j>=nTargetTdIndex) {
6555 this.selectCell(currentRow.cells[j]);
6556 }
6557 }
6558 // This is the anchor row, only select the anchor cell and before
6559 else if(currentRow.sectionRowIndex == nAnchorTrIndex) {
6560 if(j<=nAnchorTdIndex) {
6561 this.selectCell(currentRow.cells[j]);
6562 }
6563 }
6564 // Select all cells on this row
6565 else {
6566 this.selectCell(currentRow.cells[j]);
6567 }
6568 }
6569 }
6570 }
6571 else if(sMode == "cellblock") {
6572 // Select the cellblock from target cell to anchor cell
6573 // including the target cell and the anchor cell
6574 startIndex = Math.min(nAnchorTdIndex, nTargetTdIndex);
6575 endIndex = Math.max(nAnchorTdIndex, nTargetTdIndex);
6576
6577 for(i=nTargetTrIndex; i<=nAnchorTrIndex; i++) {
6578 for(j=startIndex; j<=endIndex; j++) {
6579 this.selectCell(allRows[i].cells[j]);
6580 }
6581 }
6582
6583 this._sLastSelectedId = allRows[nTargetTrIndex].cells[nTargetTdIndex].id;
6584 }
6585 }
6586 }
6587 // Invalid anchor
6588 else {
6589 // Set anchor
6590 this._sSelectionAnchorId = elTargetCell.id;
6591
6592 // Select target only
6593 this.selectCell(elTargetCell);
6594 }
6595 }
6596 // Only CTRL
6597 else if((sMode != "singlecell") && bCTRL) {
6598 // Set anchor
6599 this._sSelectionAnchorId = elTargetCell.id;
6600
6601 // Toggle selection of target
6602 if(this.isSelected(elTargetCell)) {
6603 this.unselectCell(elTargetCell);
6604 }
6605 else {
6606 this.selectCell(elTargetCell);
6607 }
6608 }
6609 // Neither SHIFT nor CTRL, or multi-selection has been disabled
6610 else {
6611 // Set anchor
6612 this._sSelectionAnchorId = elTargetCell.id;
6613
6614 // Select only target
6615 this.unselectAllCells();
6616 this.selectCell(elTargetCell);
6617 }
6618
6619 YAHOO.util.Event.stopEvent(evt);
6620
6621 // Clear any selections that are a byproduct of the click or dblclick
6622 var sel;
6623 if(window.getSelection) {
6624 sel = window.getSelection();
6625 }
6626 else if(document.getSelection) {
6627 sel = document.getSelection();
6628 }
6629 else if(document.selection) {
6630 sel = document.selection;
6631 }
6632 if(sel) {
6633 if(sel.empty) {
6634 sel.empty();
6635 }
6636 else if (sel.removeAllRanges) {
6637 sel.removeAllRanges();
6638 }
6639 else if(sel.collapse) {
6640 sel.collapse();
6641 }
6642 }
6643 }
6644 else {
6645 }
6646 };
6647
6648
6649
6650
6651
6652
6653
6654
6655
6656
6657
6658 /**
6659 * Overridable custom event handler to highlight row.
6660 *
6661 * @method onEventHighlightRow
6662 * @param oArgs.event {HTMLEvent} Event object.
6663 * @param oArgs.target {HTMLElement} Target element.
6664 */
6665 YAHOO.widget.DataTable.prototype.onEventHighlightRow = function(oArgs) {
6666 var evt = oArgs.event;
6667 var elTarget = oArgs.target;
6668 this.highlightRow(elTarget);
6669 };
6670
6671 /**
6672 * Overridable custom event handler to unhighlight row.
6673 *
6674 * @method onEventUnhighlightRow
6675 * @param oArgs.event {HTMLEvent} Event object.
6676 * @param oArgs.target {HTMLElement} Target element.
6677 */
6678 YAHOO.widget.DataTable.prototype.onEventUnhighlightRow = function(oArgs) {
6679 var evt = oArgs.event;
6680 var elTarget = oArgs.target;
6681 this.unhighlightRow(elTarget);
6682 };
6683
6684 /**
6685 * Overridable custom event handler to highlight cell.
6686 *
6687 * @method onEventHighlightCell
6688 * @param oArgs.event {HTMLEvent} Event object.
6689 * @param oArgs.target {HTMLElement} Target element.
6690 */
6691 YAHOO.widget.DataTable.prototype.onEventHighlightCell = function(oArgs) {
6692 var evt = oArgs.event;
6693 var elTarget = oArgs.target;
6694 this.highlightCell(elTarget);
6695 };
6696
6697 /**
6698 * Overridable custom event handler to unhighlight cell.
6699 *
6700 * @method onEventUnhighlightCell
6701 * @param oArgs.event {HTMLEvent} Event object.
6702 * @param oArgs.target {HTMLElement} Target element.
6703 */
6704 YAHOO.widget.DataTable.prototype.onEventUnhighlightCell = function(oArgs) {
6705 var evt = oArgs.event;
6706 var elTarget = oArgs.target;
6707 this.unhighlightCell(elTarget);
6708 };
6709
6710 /**
6711 * Overridable custom event handler to format cell.
6712 *
6713 * @method onEventFormatCell
6714 * @param oArgs.event {HTMLEvent} Event object.
6715 * @param oArgs.target {HTMLElement} Target element.
6716 */
6717 YAHOO.widget.DataTable.prototype.onEventFormatCell = function(oArgs) {
6718 var evt = oArgs.event;
6719 var target = oArgs.target;
6720 var elTag = target.tagName.toLowerCase();
6721
6722 var elCell = this.getTdEl(target);
6723 if(elCell && YAHOO.lang.isNumber(elCell.yuiColumnId)) {
6724 var oColumn = this._oColumnSet.getColumn(elCell.yuiColumnId);
6725 this.formatCell(elCell, this.getRecord(elCell), oColumn);
6726 }
6727 else {
6728 }
6729 };
6730
6731 /**
6732 * Overridable custom event handler to edit cell.
6733 *
6734 * @method onEventShowCellEditor
6735 * @param oArgs.event {HTMLEvent} Event object.
6736 * @param oArgs.target {HTMLElement} Target element.
6737 */
6738 YAHOO.widget.DataTable.prototype.onEventShowCellEditor = function(oArgs) {
6739 var evt = oArgs.event;
6740 var target = oArgs.target;
6741 var elTag = target.tagName.toLowerCase();
6742
6743 var elCell = this.getTdEl(target);
6744 if(elCell) {
6745 this.showCellEditor(elCell);
6746 }
6747 else {
6748 }
6749 };
6750 // Backward compatibility
6751 YAHOO.widget.DataTable.prototype.onEventEditCell = function(oArgs) {
6752 this.onEventShowCellEditor(oArgs);
6753 };
6754
6755 /**
6756 * Overridable custom event handler to save Cell Editor input.
6757 *
6758 * @method onEventSaveCellEditor
6759 * @param oArgs.editor {Object} Cell Editor object literal.
6760 */
6761 YAHOO.widget.DataTable.prototype.onEventSaveCellEditor = function(oArgs) {
6762 this.saveCellEditor();
6763 };
6764
6765 /**
6766 * Callback function for creating a progressively enhanced DataTable first
6767 * receives data from DataSource and populates the RecordSet, then initializes
6768 * DOM elements.
6769 *
6770 * @method _onDataReturnEnhanceTable
6771 * @param sRequest {String} Original request.
6772 * @param oResponse {Object} Response object.
6773 * @param bError {Boolean} (optional) True if there was a data error.
6774 * @private
6775 */
6776 YAHOO.widget.DataTable.prototype._onDataReturnEnhanceTable = function(sRequest, oResponse) {
6777 // Pass data through abstract method for any transformations
6778 var ok = this.doBeforeLoadData(sRequest, oResponse);
6779
6780 // Data ok to populate
6781 if(ok && oResponse && !oResponse.error && YAHOO.lang.isArray(oResponse.results)) {
6782 // Update RecordSet
6783 this._oRecordSet.addRecords(oResponse.results);
6784
6785 // Initialize DOM elements
6786 this._initTableEl();
6787 if(!this._elTable || !this._elThead || !this._elTbody) {
6788 return;
6789 }
6790
6791 // Call Element's constructor after DOM elements are created
6792 // but *before* UI is updated with data
6793 YAHOO.widget.DataTable.superclass.constructor.call(this, this._elContainer, this._oConfigs);
6794
6795 //HACK: Set the Paginator values
6796 if(this._oConfigs.paginator) {
6797 this.updatePaginator(this._oConfigs.paginator);
6798 }
6799
6800 // Update the UI
6801 this.refreshView();
6802 }
6803 // Error
6804 else if(ok && oResponse.error) {
6805 this.showTableMessage(YAHOO.widget.DataTable.MSG_ERROR, YAHOO.widget.DataTable.CLASS_ERROR);
6806 }
6807 // Empty
6808 else if(ok){
6809 this.showTableMessage(YAHOO.widget.DataTable.MSG_EMPTY, YAHOO.widget.DataTable.CLASS_EMPTY);
6810 }
6811 };
6812
6813 /**
6814 * Callback function receives data from DataSource and populates an entire
6815 * DataTable with Records and TR elements, clearing previous Records, if any.
6816 *
6817 * @method onDataReturnInitializeTable
6818 * @param sRequest {String} Original request.
6819 * @param oResponse {Object} Response object.
6820 * @param bError {Boolean} (optional) True if there was a data error.
6821 */
6822 YAHOO.widget.DataTable.prototype.onDataReturnInitializeTable = function(sRequest, oResponse) {
6823 this.fireEvent("dataReturnEvent", {request:sRequest,response:oResponse});
6824
6825 // Pass data through abstract method for any transformations
6826 var ok = this.doBeforeLoadData(sRequest, oResponse);
6827
6828 // Data ok to populate
6829 if(ok && oResponse && !oResponse.error && YAHOO.lang.isArray(oResponse.results)) {
6830 this.initializeTable(oResponse.results);
6831 }
6832 // Error
6833 else if(ok && oResponse.error) {
6834 this.showTableMessage(YAHOO.widget.DataTable.MSG_ERROR, YAHOO.widget.DataTable.CLASS_ERROR);
6835 }
6836 // Empty
6837 else if(ok){
6838 this.showTableMessage(YAHOO.widget.DataTable.MSG_EMPTY, YAHOO.widget.DataTable.CLASS_EMPTY);
6839 }
6840 };
6841 // Backward compatibility
6842 YAHOO.widget.DataTable.prototype.onDataReturnReplaceRows = function(sRequest, oResponse) {
6843 this.onDataReturnInitializeTable(sRequest, oResponse);
6844 };
6845
6846 /**
6847 * Callback function receives data from DataSource and appends to an existing
6848 * DataTable new Records and, if applicable, creates or updates
6849 * corresponding TR elements.
6850 *
6851 * @method onDataReturnAppendRows
6852 * @param sRequest {String} Original request.
6853 * @param oResponse {Object} Response object.
6854 * @param bError {Boolean} (optional) True if there was a data error.
6855 */
6856 YAHOO.widget.DataTable.prototype.onDataReturnAppendRows = function(sRequest, oResponse) {
6857 this.fireEvent("dataReturnEvent", {request:sRequest,response:oResponse});
6858
6859 // Pass data through abstract method for any transformations
6860 var ok = this.doBeforeLoadData(sRequest, oResponse);
6861
6862 // Data ok to append
6863 if(ok && oResponse && !oResponse.error && YAHOO.lang.isArray(oResponse.results)) {
6864 this.addRows(oResponse.results);
6865 }
6866 // Error
6867 else if(ok && oResponse.error) {
6868 this.showTableMessage(YAHOO.widget.DataTable.MSG_ERROR, YAHOO.widget.DataTable.CLASS_ERROR);
6869 }
6870 };
6871
6872 /**
6873 * Callback function receives data from DataSource and inserts into top of an
6874 * existing DataTable new Records and, if applicable, creates or updates
6875 * corresponding TR elements.
6876 *
6877 * @method onDataReturnInsertRows
6878 * @param sRequest {String} Original request.
6879 * @param oResponse {Object} Response object.
6880 * @param bError {Boolean} (optional) True if there was a data error.
6881 */
6882 YAHOO.widget.DataTable.prototype.onDataReturnInsertRows = function(sRequest, oResponse) {
6883 this.fireEvent("dataReturnEvent", {request:sRequest,response:oResponse});
6884
6885 // Pass data through abstract method for any transformations
6886 var ok = this.doBeforeLoadData(sRequest, oResponse);
6887
6888 // Data ok to append
6889 if(ok && oResponse && !oResponse.error && YAHOO.lang.isArray(oResponse.results)) {
6890 this.addRows(oResponse.results, 0);
6891 }
6892 // Error
6893 else if(ok && oResponse.error) {
6894 this.showTableMessage(YAHOO.widget.DataTable.MSG_ERROR, YAHOO.widget.DataTable.CLASS_ERROR);
6895 }
6896 };
6897
6898
6899
6900
6901
6902
6903
6904
6905
6906
6907
6908
6909
6910
6911
6912
6913
6914
6915
6916
6917
6918
6919
6920
6921
6922
6923
6924
6925
6926
6927
6928
6929
6930
6931
6932 /////////////////////////////////////////////////////////////////////////////
6933 //
6934 // Custom Events
6935 //
6936 /////////////////////////////////////////////////////////////////////////////
6937
6938 /**
6939 * Fired when the DataTable instance's initialization is complete.
6940 *
6941 * @event initEvent
6942 */
6943
6944 /**
6945 * Fired when the DataTable's view is refreshed.
6946 *
6947 * @event refreshEvent
6948 */
6949
6950 /**
6951 * Fired when data is returned from DataSource.
6952 *
6953 * @event dataReturnEvent
6954 * @param oArgs.request {String} Original request.
6955 * @param oArgs.response {Object} Response object.
6956 */
6957
6958 /**
6959 * Fired when the DataTable has a focus.
6960 *
6961 * @event tableFocusEvent
6962 */
6963
6964 /**
6965 * Fired when the DataTable has a blur.
6966 *
6967 * @event tableBlurEvent
6968 */
6969
6970 /**
6971 * Fired when the DataTable has a mouseover.
6972 *
6973 * @event tableMouseoverEvent
6974 * @param oArgs.event {HTMLEvent} The event object.
6975 * @param oArgs.target {HTMLElement} The DataTable's TABLE element.
6976 *
6977 */
6978
6979 /**
6980 * Fired when the DataTable has a mouseout.
6981 *
6982 * @event tableMouseoutEvent
6983 * @param oArgs.event {HTMLEvent} The event object.
6984 * @param oArgs.target {HTMLElement} The DataTable's TABLE element.
6985 *
6986 */
6987
6988 /**
6989 * Fired when the DataTable has a mousedown.
6990 *
6991 * @event tableMousedownEvent
6992 * @param oArgs.event {HTMLEvent} The event object.
6993 * @param oArgs.target {HTMLElement} The DataTable's TABLE element.
6994 *
6995 */
6996
6997 /**
6998 * Fired when the DataTable has a click.
6999 *
7000 * @event tableClickEvent
7001 * @param oArgs.event {HTMLEvent} The event object.
7002 * @param oArgs.target {HTMLElement} The DataTable's TABLE element.
7003 *
7004 */
7005
7006 /**
7007 * Fired when the DataTable has a dblclick.
7008 *
7009 * @event tableDblclickEvent
7010 * @param oArgs.event {HTMLEvent} The event object.
7011 * @param oArgs.target {HTMLElement} The DataTable's TABLE element.
7012 *
7013 */
7014
7015 /**
7016 * Fired when a fixed scrolling DataTable has a scroll.
7017 *
7018 * @event tableScrollEvent
7019 * @param oArgs.event {HTMLEvent} The event object.
7020 * @param oArgs.target {HTMLElement} The DataTable's CONTAINER element (in IE)
7021 * or the DataTable's TBODY element (everyone else).
7022 *
7023 */
7024
7025 /**
7026 * Fired when a message is shown in the DataTable's message element.
7027 *
7028 * @event tableMsgShowEvent
7029 * @param oArgs.html {String} The HTML displayed.
7030 * @param oArgs.className {String} The className assigned.
7031 *
7032 */
7033
7034 /**
7035 * Fired when the DataTable's message element is hidden.
7036 *
7037 * @event tableMsgHideEvent
7038 */
7039
7040 /**
7041 * Fired when a header row has a mouseover.
7042 *
7043 * @event headerRowMouseoverEvent
7044 * @param oArgs.event {HTMLEvent} The event object.
7045 * @param oArgs.target {HTMLElement} The TR element.
7046 */
7047
7048 /**
7049 * Fired when a header row has a mouseout.
7050 *
7051 * @event headerRowMouseoutEvent
7052 * @param oArgs.event {HTMLEvent} The event object.
7053 * @param oArgs.target {HTMLElement} The TR element.
7054 */
7055
7056 /**
7057 * Fired when a header row has a mousedown.
7058 *
7059 * @event headerRowMousedownEvent
7060 * @param oArgs.event {HTMLEvent} The event object.
7061 * @param oArgs.target {HTMLElement} The TR element.
7062 */
7063
7064 /**
7065 * Fired when a header row has a click.
7066 *
7067 * @event headerRowClickEvent
7068 * @param oArgs.event {HTMLEvent} The event object.
7069 * @param oArgs.target {HTMLElement} The TR element.
7070 */
7071
7072 /**
7073 * Fired when a header row has a dblclick.
7074 *
7075 * @event headerRowDblclickEvent
7076 * @param oArgs.event {HTMLEvent} The event object.
7077 * @param oArgs.target {HTMLElement} The TR element.
7078 */
7079
7080 /**
7081 * Fired when a header cell has a mouseover.
7082 *
7083 * @event headerCellMouseoverEvent
7084 * @param oArgs.event {HTMLEvent} The event object.
7085 * @param oArgs.target {HTMLElement} The TH element.
7086 *
7087 */
7088
7089 /**
7090 * Fired when a header cell has a mouseout.
7091 *
7092 * @event headerCellMouseoutEvent
7093 * @param oArgs.event {HTMLEvent} The event object.
7094 * @param oArgs.target {HTMLElement} The TH element.
7095 *
7096 */
7097
7098 /**
7099 * Fired when a header cell has a mousedown.
7100 *
7101 * @event headerCellMousedownEvent
7102 * @param oArgs.event {HTMLEvent} The event object.
7103 * @param oArgs.target {HTMLElement} The TH element.
7104 */
7105
7106 /**
7107 * Fired when a header cell has a click.
7108 *
7109 * @event headerCellClickEvent
7110 * @param oArgs.event {HTMLEvent} The event object.
7111 * @param oArgs.target {HTMLElement} The TH element.
7112 */
7113
7114 /**
7115 * Fired when a header cell has a dblclick.
7116 *
7117 * @event headerCellDblclickEvent
7118 * @param oArgs.event {HTMLEvent} The event object.
7119 * @param oArgs.target {HTMLElement} The TH element.
7120 */
7121
7122 /**
7123 * Fired when a header label has a mouseover.
7124 *
7125 * @event headerLabelMouseoverEvent
7126 * @param oArgs.event {HTMLEvent} The event object.
7127 * @param oArgs.target {HTMLElement} The SPAN element.
7128 *
7129 */
7130
7131 /**
7132 * Fired when a header label has a mouseout.
7133 *
7134 * @event headerLabelMouseoutEvent
7135 * @param oArgs.event {HTMLEvent} The event object.
7136 * @param oArgs.target {HTMLElement} The SPAN element.
7137 *
7138 */
7139
7140 /**
7141 * Fired when a header label has a mousedown.
7142 *
7143 * @event headerLabelMousedownEvent
7144 * @param oArgs.event {HTMLEvent} The event object.
7145 * @param oArgs.target {HTMLElement} The SPAN element.
7146 */
7147
7148 /**
7149 * Fired when a header label has a click.
7150 *
7151 * @event headerLabelClickEvent
7152 * @param oArgs.event {HTMLEvent} The event object.
7153 * @param oArgs.target {HTMLElement} The SPAN element.
7154 */
7155
7156 /**
7157 * Fired when a header label has a dblclick.
7158 *
7159 * @event headerLabelDblclickEvent
7160 * @param oArgs.event {HTMLEvent} The event object.
7161 * @param oArgs.target {HTMLElement} The SPAN element.
7162 */
7163
7164 /**
7165 * Fired when a column is sorted.
7166 *
7167 * @event columnSortEvent
7168 * @param oArgs.column {YAHOO.widget.Column} The Column instance.
7169 * @param oArgs.dir {String} Sort direction "asc" or "desc".
7170 */
7171
7172 /**
7173 * Fired when a column is resized.
7174 *
7175 * @event columnResizeEvent
7176 * @param oArgs.column {YAHOO.widget.Column} The Column instance.
7177 * @param oArgs.target {HTMLElement} The TH element.
7178 */
7179
7180 /**
7181 * Fired when a row has a mouseover.
7182 *
7183 * @event rowMouseoverEvent
7184 * @param oArgs.event {HTMLEvent} The event object.
7185 * @param oArgs.target {HTMLElement} The TR element.
7186 */
7187
7188 /**
7189 * Fired when a row has a mouseout.
7190 *
7191 * @event rowMouseoutEvent
7192 * @param oArgs.event {HTMLEvent} The event object.
7193 * @param oArgs.target {HTMLElement} The TR element.
7194 */
7195
7196 /**
7197 * Fired when a row has a mousedown.
7198 *
7199 * @event rowMousedownEvent
7200 * @param oArgs.event {HTMLEvent} The event object.
7201 * @param oArgs.target {HTMLElement} The TR element.
7202 */
7203
7204 /**
7205 * Fired when a row has a click.
7206 *
7207 * @event rowClickEvent
7208 * @param oArgs.event {HTMLEvent} The event object.
7209 * @param oArgs.target {HTMLElement} The TR element.
7210 */
7211
7212 /**
7213 * Fired when a row has a dblclick.
7214 *
7215 * @event rowDblclickEvent
7216 * @param oArgs.event {HTMLEvent} The event object.
7217 * @param oArgs.target {HTMLElement} The TR element.
7218 */
7219
7220 /**
7221 * Fired when a row is added.
7222 *
7223 * @event rowAddEvent
7224 * @param oArgs.record {YAHOO.widget.Record} The added Record.
7225 */
7226
7227 /**
7228 * Fired when a row is updated.
7229 *
7230 * @event rowUpdateEvent
7231 * @param oArgs.record {YAHOO.widget.Record} The updated Record.
7232 * @param oArgs.oldData {Object} Object literal of the old data.
7233 */
7234
7235 /**
7236 * Fired when a row is deleted.
7237 *
7238 * @event rowDeleteEvent
7239 * @param oArgs.oldData {Object} Object literal of the deleted data.
7240 * @param oArgs.recordIndex {Number} Index of the deleted Record.
7241 * @param oArgs.trElIndex {Number} Index of the deleted TR element, if in view.
7242 */
7243
7244 /**
7245 * Fired when a row is selected.
7246 *
7247 * @event rowSelectEvent
7248 * @param oArgs.el {HTMLElement} The selected TR element, if applicable.
7249 * @param oArgs.record {YAHOO.widget.Record} The selected Record.
7250 */
7251
7252 /**
7253 * Fired when a row is unselected.
7254 *
7255 * @event rowUnselectEvent
7256 * @param oArgs.el {HTMLElement} The unselected TR element, if applicable.
7257 * @param oArgs.record {YAHOO.widget.Record} The unselected Record.
7258 */
7259
7260 /*TODO: delete and use rowUnselectEvent?
7261 * Fired when all row selections are cleared.
7262 *
7263 * @event unselectAllRowsEvent
7264 */
7265
7266 /*
7267 * Fired when a row is highlighted.
7268 *
7269 * @event rowHighlightEvent
7270 * @param oArgs.el {HTMLElement} The highlighted TR element.
7271 * @param oArgs.record {YAHOO.widget.Record} The highlighted Record.
7272 */
7273
7274 /*
7275 * Fired when a row is unhighlighted.
7276 *
7277 * @event rowUnhighlightEvent
7278 * @param oArgs.el {HTMLElement} The highlighted TR element.
7279 * @param oArgs.record {YAHOO.widget.Record} The highlighted Record.
7280 */
7281
7282 /**
7283 * Fired when a cell has a mouseover.
7284 *
7285 * @event cellMouseoverEvent
7286 * @param oArgs.event {HTMLEvent} The event object.
7287 * @param oArgs.target {HTMLElement} The TD element.
7288 */
7289
7290 /**
7291 * Fired when a cell has a mouseout.
7292 *
7293 * @event cellMouseoutEvent
7294 * @param oArgs.event {HTMLEvent} The event object.
7295 * @param oArgs.target {HTMLElement} The TD element.
7296 */
7297
7298 /**
7299 * Fired when a cell has a mousedown.
7300 *
7301 * @event cellMousedownEvent
7302 * @param oArgs.event {HTMLEvent} The event object.
7303 * @param oArgs.target {HTMLElement} The TD element.
7304 */
7305
7306 /**
7307 * Fired when a cell has a click.
7308 *
7309 * @event cellClickEvent
7310 * @param oArgs.event {HTMLEvent} The event object.
7311 * @param oArgs.target {HTMLElement} The TD element.
7312 */
7313
7314 /**
7315 * Fired when a cell has a dblclick.
7316 *
7317 * @event cellDblclickEvent
7318 * @param oArgs.event {HTMLEvent} The event object.
7319 * @param oArgs.target {HTMLElement} The TD element.
7320 */
7321
7322 /**
7323 * Fired when a cell is formatted.
7324 *
7325 * @event cellFormatEvent
7326 * @param oArgs.el {HTMLElement} The formatted TD element.
7327 * @param oArgs.record {YAHOO.widget.Record} The formatted Record.
7328 * @param oArgs.key {String} The key of the formatted cell.
7329 */
7330
7331 /**
7332 * Fired when a cell is selected.
7333 *
7334 * @event cellSelectEvent
7335 * @param oArgs.el {HTMLElement} The selected TD element.
7336 * @param oArgs.record {YAHOO.widget.Record} The selected Record.
7337 * @param oArgs.key {String} The key of the selected cell.
7338 */
7339
7340 /**
7341 * Fired when a cell is unselected.
7342 *
7343 * @event cellUnselectEvent
7344 * @param oArgs.el {HTMLElement} The unselected TD element.
7345 * @param oArgs.record {YAHOO.widget.Record} The unselected Record.
7346 * @param oArgs.key {String} The key of the unselected cell.
7347 */
7348
7349 /**
7350 * Fired when a cell is highlighted.
7351 *
7352 * @event cellHighlightEvent
7353 * @param oArgs.el {HTMLElement} The highlighted TD element.
7354 * @param oArgs.record {YAHOO.widget.Record} The highlighted Record.
7355 * @param oArgs.key {String} The key of the highlighted cell.
7356 */
7357
7358 /**
7359 * Fired when a cell is unhighlighted.
7360 *
7361 * @event cellUnhighlightEvent
7362 * @param oArgs.el {HTMLElement} The unhighlighted TD element.
7363 * @param oArgs.record {YAHOO.widget.Record} The unhighlighted Record.
7364 * @param oArgs.key {String} The key of the unhighlighted cell.
7365 */
7366
7367 /*TODO: hide from doc and use cellUnselectEvent
7368 * Fired when all cell selections are cleared.
7369 *
7370 * @event unselectAllCellsEvent
7371 */
7372
7373 /*TODO: implement
7374 * Fired when DataTable paginator is updated.
7375 *
7376 * @event paginatorUpdateEvent
7377 * @param paginator {Object} Object literal of Paginator values.
7378 */
7379
7380 /**
7381 * Fired when an Editor is activated.
7382 *
7383 * @event editorShowEvent
7384 * @param oArgs.editor {Object} The Editor object literal.
7385 */
7386
7387 /**
7388 * Fired when an active Editor has a keydown.
7389 *
7390 * @event editorKeydownEvent
7391 * @param oArgs.editor {Object} The Editor object literal.
7392 * @param oArgs.event {HTMLEvent} The event object.
7393 */
7394
7395 /**
7396 * Fired when Editor input is reverted.
7397 *
7398 * @event editorRevertEvent
7399 * @param oArgs.editor {Object} The Editor object literal.
7400 * @param oArgs.newData {Object} New data value.
7401 * @param oArgs.oldData {Object} Old data value.
7402 */
7403
7404 /**
7405 * Fired when Editor input is saved.
7406 *
7407 * @event editorSaveEvent
7408 * @param oArgs.editor {Object} The Editor object literal.
7409 * @param oArgs.newData {Object} New data value.
7410 * @param oArgs.oldData {Object} Old data value.
7411 */
7412
7413 /**
7414 * Fired when Editor input is canceled.
7415 *
7416 * @event editorCancelEvent
7417 * @param oArgs.editor {Object} The Editor object literal.
7418 */
7419
7420 /**
7421 * Fired when an active Editor has a blur.
7422 *
7423 * @event editorBlurEvent
7424 * @param oArgs.editor {Object} The Editor object literal.
7425 */
7426
7427
7428
7429
7430
7431
7432
7433 /**
7434 * Fired when a link is clicked.
7435 *
7436 * @event linkClickEvent
7437 * @param oArgs.event {HTMLEvent} The event object.
7438 * @param oArgs.target {HTMLElement} The A element.
7439 */
7440
7441 /**
7442 * Fired when a BUTTON element is clicked.
7443 *
7444 * @event buttonClickEvent
7445 * @param oArgs.event {HTMLEvent} The event object.
7446 * @param oArgs.target {HTMLElement} The BUTTON element.
7447 */
7448
7449 /**
7450 * Fired when a CHECKBOX element is clicked.
7451 *
7452 * @event checkboxClickEvent
7453 * @param oArgs.event {HTMLEvent} The event object.
7454 * @param oArgs.target {HTMLElement} The CHECKBOX element.
7455 */
7456
7457 /*TODO
7458 * Fired when a SELECT element is changed.
7459 *
7460 * @event dropdownChangeEvent
7461 * @param oArgs.event {HTMLEvent} The event object.
7462 * @param oArgs.target {HTMLElement} The SELECT element.
7463 */
7464
7465 /**
7466 * Fired when a RADIO element is clicked.
7467 *
7468 * @event radioClickEvent
7469 * @param oArgs.event {HTMLEvent} The event object.
7470 * @param oArgs.target {HTMLElement} The RADIO element.
7471 */
7472
7473
7474 /****************************************************************************/
7475 /****************************************************************************/
7476 /****************************************************************************/
7477
7478 /**
7479 * The ColumnSet class defines and manages a DataTable's Columns,
7480 * including nested hierarchies and access to individual Column instances.
7481 *
7482 * @namespace YAHOO.widget
7483 * @class ColumnSet
7484 * @uses YAHOO.util.EventProvider
7485 * @constructor
7486 * @param aHeaders {Object[]} Array of object literals that define header cells.
7487 */
7488 YAHOO.widget.ColumnSet = function(aHeaders) {
7489 this._sName = "instance" + YAHOO.widget.ColumnSet._nCount;
7490
7491 // DOM tree representation of all Columns
7492 var tree = [];
7493 // Flat representation of all Columns
7494 var flat = [];
7495 // Flat representation of only Columns that are meant to display data
7496 var keys = [];
7497 // Array of HEADERS attribute values for all keys in the "keys" array
7498 var headers = [];
7499
7500 // Tracks current node list depth being tracked
7501 var nodeDepth = -1;
7502
7503 // Internal recursive function to defined Column instances
7504 var parseColumns = function(nodeList, parent) {
7505 // One level down
7506 nodeDepth++;
7507
7508 // Create corresponding tree node if not already there for this depth
7509 if(!tree[nodeDepth]) {
7510 tree[nodeDepth] = [];
7511 }
7512
7513
7514 // Parse each node at this depth for attributes and any children
7515 for(var j=0; j<nodeList.length; j++) {
7516 var currentNode = nodeList[j];
7517
7518 // Instantiate a new Column for each node
7519 var oColumn = new YAHOO.widget.Column(currentNode);
7520
7521 // Add the new Column to the flat list
7522 flat.push(oColumn);
7523
7524 // Assign its parent as an attribute, if applicable
7525 if(parent) {
7526 oColumn.parent = parent;
7527 }
7528
7529 // The Column has descendants
7530 if(YAHOO.lang.isArray(currentNode.children)) {
7531 oColumn.children = currentNode.children;
7532
7533 // Determine COLSPAN value for this Column
7534 var terminalChildNodes = 0;
7535 var countTerminalChildNodes = function(ancestor) {
7536 var descendants = ancestor.children;
7537 // Drill down each branch and count terminal nodes
7538 for(var k=0; k<descendants.length; k++) {
7539 // Keep drilling down
7540 if(YAHOO.lang.isArray(descendants[k].children)) {
7541 countTerminalChildNodes(descendants[k]);
7542 }
7543 // Reached branch terminus
7544 else {
7545 terminalChildNodes++;
7546 }
7547 }
7548 };
7549 countTerminalChildNodes(currentNode);
7550 oColumn._colspan = terminalChildNodes;
7551
7552 // Cascade certain properties to children if not defined on their own
7553 var currentChildren = currentNode.children;
7554 for(var k=0; k<currentChildren.length; k++) {
7555 var child = currentChildren[k];
7556 if(oColumn.className && (child.className === undefined)) {
7557 child.className = oColumn.className;
7558 }
7559 if(oColumn.editor && (child.editor === undefined)) {
7560 child.editor = oColumn.editor;
7561 }
7562 if(oColumn.editorOptions && (child.editorOptions === undefined)) {
7563 child.editorOptions = oColumn.editorOptions;
7564 }
7565 if(oColumn.formatter && (child.formatter === undefined)) {
7566 child.formatter = oColumn.formatter;
7567 }
7568 if(oColumn.resizeable && (child.resizeable === undefined)) {
7569 child.resizeable = oColumn.resizeable;
7570 }
7571 if(oColumn.sortable && (child.sortable === undefined)) {
7572 child.sortable = oColumn.sortable;
7573 }
7574 if(oColumn.width && (child.width === undefined)) {
7575 child.width = oColumn.width;
7576 }
7577 // Backward compatibility
7578 if(oColumn.type && (child.type === undefined)) {
7579 child.type = oColumn.type;
7580 }
7581 if(oColumn.type && !oColumn.formatter) {
7582 oColumn.formatter = oColumn.type;
7583 }
7584 if(oColumn.text && !YAHOO.lang.isValue(oColumn.label)) {
7585 oColumn.label = oColumn.text;
7586 }
7587 if(oColumn.parser) {
7588 }
7589 if(oColumn.sortOptions && ((oColumn.sortOptions.ascFunction) ||
7590 (oColumn.sortOptions.descFunction))) {
7591 }
7592 }
7593
7594 // The children themselves must also be parsed for Column instances
7595 if(!tree[nodeDepth+1]) {
7596 tree[nodeDepth+1] = [];
7597 }
7598 parseColumns(currentChildren, oColumn);
7599 }
7600 // This Column does not have any children
7601 else {
7602 oColumn._nKeyIndex = keys.length;
7603 oColumn._colspan = 1;
7604 keys.push(oColumn);
7605 }
7606
7607 // Add the Column to the top-down tree
7608 tree[nodeDepth].push(oColumn);
7609 }
7610 nodeDepth--;
7611 };
7612
7613 // Parse out Column instances from the array of object literals
7614 if(YAHOO.lang.isArray(aHeaders)) {
7615 parseColumns(aHeaders);
7616 }
7617
7618 // Determine ROWSPAN value for each Column in the tree
7619 var parseTreeForRowspan = function(tree) {
7620 var maxRowDepth = 1;
7621 var currentRow;
7622 var currentColumn;
7623
7624 // Calculate the max depth of descendants for this row
7625 var countMaxRowDepth = function(row, tmpRowDepth) {
7626 tmpRowDepth = tmpRowDepth || 1;
7627
7628 for(var n=0; n<row.length; n++) {
7629 var col = row[n];
7630 // Column has children, so keep counting
7631 if(YAHOO.lang.isArray(col.children)) {
7632 tmpRowDepth++;
7633 countMaxRowDepth(col.children, tmpRowDepth);
7634 tmpRowDepth--;
7635 }
7636 // No children, is it the max depth?
7637 else {
7638 if(tmpRowDepth > maxRowDepth) {
7639 maxRowDepth = tmpRowDepth;
7640 }
7641 }
7642
7643 }
7644 };
7645
7646 // Count max row depth for each row
7647 for(var m=0; m<tree.length; m++) {
7648 currentRow = tree[m];
7649 countMaxRowDepth(currentRow);
7650
7651 // Assign the right ROWSPAN values to each Column in the row
7652 for(var p=0; p<currentRow.length; p++) {
7653 currentColumn = currentRow[p];
7654 if(!YAHOO.lang.isArray(currentColumn.children)) {
7655 currentColumn._rowspan = maxRowDepth;
7656 }
7657 else {
7658 currentColumn._rowspan = 1;
7659 }
7660 }
7661
7662 // Reset counter for next row
7663 maxRowDepth = 1;
7664 }
7665 };
7666 parseTreeForRowspan(tree);
7667
7668
7669
7670
7671
7672 // Store header relationships in an array for HEADERS attribute
7673 var recurseAncestorsForHeaders = function(i, oColumn) {
7674 headers[i].push(oColumn._nId);
7675 if(oColumn.parent) {
7676 recurseAncestorsForHeaders(i, oColumn.parent);
7677 }
7678 };
7679 for(var i=0; i<keys.length; i++) {
7680 headers[i] = [];
7681 recurseAncestorsForHeaders(i, keys[i]);
7682 headers[i] = headers[i].reverse();
7683 headers[i] = headers[i].join(" ");
7684 }
7685
7686 // Save to the ColumnSet instance
7687 this.tree = tree;
7688 this.flat = flat;
7689 this.keys = keys;
7690 this.headers = headers;
7691
7692 YAHOO.widget.ColumnSet._nCount++;
7693 };
7694
7695 /////////////////////////////////////////////////////////////////////////////
7696 //
7697 // Public member variables
7698 //
7699 /////////////////////////////////////////////////////////////////////////////
7700
7701 /**
7702 * Internal class variable to index multiple data table instances.
7703 *
7704 * @property ColumnSet._nCount
7705 * @type number
7706 * @private
7707 * @static
7708 */
7709 YAHOO.widget.ColumnSet._nCount = 0;
7710
7711 /**
7712 * Unique instance name.
7713 *
7714 * @property _sName
7715 * @type String
7716 * @private
7717 */
7718 YAHOO.widget.ColumnSet.prototype._sName = null;
7719
7720 /////////////////////////////////////////////////////////////////////////////
7721 //
7722 // Public member variables
7723 //
7724 /////////////////////////////////////////////////////////////////////////////
7725
7726 /**
7727 * Top-down tree representation of Column hierarchy.
7728 *
7729 * @property tree
7730 * @type YAHOO.widget.Column[]
7731 */
7732 YAHOO.widget.ColumnSet.prototype.tree = null;
7733
7734 /**
7735 * Flattened representation of all Columns.
7736 *
7737 * @property flat
7738 * @type YAHOO.widget.Column[]
7739 * @default []
7740 */
7741 YAHOO.widget.ColumnSet.prototype.flat = null;
7742
7743 /**
7744 * Array of Columns that map one-to-one to a table column.
7745 *
7746 * @property keys
7747 * @type YAHOO.widget.Column[]
7748 * @default []
7749 */
7750 YAHOO.widget.ColumnSet.prototype.keys = null;
7751
7752 /**
7753 * ID index of nested parent hierarchies for HEADERS accessibility attribute.
7754 *
7755 * @property headers
7756 * @type String[]
7757 * @default []
7758 */
7759 YAHOO.widget.ColumnSet.prototype.headers = null;
7760
7761 /////////////////////////////////////////////////////////////////////////////
7762 //
7763 // Public methods
7764 //
7765 /////////////////////////////////////////////////////////////////////////////
7766
7767 /**
7768 * Public accessor to the unique name of the ColumnSet instance.
7769 *
7770 * @method toString
7771 * @return {String} Unique name of the ColumnSet instance.
7772 */
7773
7774 YAHOO.widget.ColumnSet.prototype.toString = function() {
7775 return "ColumnSet " + this._sName;
7776 };
7777
7778 /**
7779 * Returns Column instance with given ID number or key.
7780 *
7781 * @method getColumn
7782 * @param column {Number | String} ID number or unique key.
7783 * @return {YAHOO.widget.Column} Column instance.
7784 */
7785
7786 YAHOO.widget.ColumnSet.prototype.getColumn = function(column) {
7787 var allColumns = this.flat;
7788 if(YAHOO.lang.isNumber(column)) {
7789 for(var i=0; i<allColumns.length; i++) {
7790 if(allColumns[i]._nId === column) {
7791 return allColumns[i];
7792 }
7793 }
7794 }
7795 else if(YAHOO.lang.isString(column)) {
7796 for(i=0; i<allColumns.length; i++) {
7797 if(allColumns[i].key === column) {
7798 return allColumns[i];
7799 }
7800 }
7801 }
7802 return null;
7803 };
7804
7805 /****************************************************************************/
7806 /****************************************************************************/
7807 /****************************************************************************/
7808
7809 /**
7810 * The Column class defines and manages attributes of DataTable Columns
7811 *
7812 * @namespace YAHOO.widget
7813 * @class Column
7814 * @constructor
7815 * @param oConfigs {Object} Object literal of configuration values.
7816 */
7817 YAHOO.widget.Column = function(oConfigs) {
7818 // Internal variables
7819 this._nId = YAHOO.widget.Column._nCount;
7820 this._sName = "Column instance" + this._nId;
7821
7822 // Object literal defines Column attributes
7823 if(oConfigs && (oConfigs.constructor == Object)) {
7824 for(var sConfig in oConfigs) {
7825 if(sConfig) {
7826 this[sConfig] = oConfigs[sConfig];
7827 }
7828 }
7829 }
7830
7831 if(!YAHOO.lang.isValue(this.key)) {
7832 this.key = "yui-dt-column"+this._nId;
7833 }
7834 YAHOO.widget.Column._nCount++;
7835 };
7836
7837 /////////////////////////////////////////////////////////////////////////////
7838 //
7839 // Private member variables
7840 //
7841 /////////////////////////////////////////////////////////////////////////////
7842
7843 /**
7844 * Internal instance counter.
7845 *
7846 * @property Column._nCount
7847 * @type Number
7848 * @private
7849 * @static
7850 * @default 0
7851 */
7852 YAHOO.widget.Column._nCount = 0;
7853
7854 /**
7855 * Unique instance name.
7856 *
7857 * @property _sName
7858 * @type String
7859 * @private
7860 */
7861 YAHOO.widget.Column.prototype._sName = null;
7862
7863
7864 /**
7865 * Unique number assigned at instantiation, indicates original order within
7866 * ColumnSet.
7867 *
7868 * @property _nId
7869 * @type Number
7870 * @private
7871 */
7872 YAHOO.widget.Column.prototype._nId = null;
7873
7874 /**
7875 * Reference to Column's index within its ColumnSet's keys array, or null if not applicable.
7876 *
7877 * @property _nKeyIndex
7878 * @type Number
7879 * @private
7880 */
7881 YAHOO.widget.Column.prototype._nKeyIndex = null;
7882
7883 /**
7884 * Number of table cells the Column spans.
7885 *
7886 * @property _colspan
7887 * @type Number
7888 * @private
7889 */
7890 YAHOO.widget.Column.prototype._colspan = 1;
7891
7892 /**
7893 * Number of table rows the Column spans.
7894 *
7895 * @property _rowspan
7896 * @type Number
7897 * @private
7898 */
7899 YAHOO.widget.Column.prototype._rowspan = 1;
7900
7901 /**
7902 * Column's parent Column instance, or null.
7903 *
7904 * @property _parent
7905 * @type YAHOO.widget.Column
7906 * @private
7907 */
7908 YAHOO.widget.Column.prototype._parent = null;
7909
7910 /**
7911 * Current offsetWidth of the Column (in pixels).
7912 *
7913 * @property _width
7914 * @type Number
7915 * @private
7916 */
7917 YAHOO.widget.Column.prototype._width = null;
7918
7919 /**
7920 * Minimum width the Column can support (in pixels). Value is populated only if table
7921 * is fixedWidth, null otherwise.
7922 *
7923 * @property _minWidth
7924 * @type Number
7925 * @private
7926 */
7927 YAHOO.widget.Column.prototype._minWidth = null;
7928
7929 /////////////////////////////////////////////////////////////////////////////
7930 //
7931 // Public member variables
7932 //
7933 /////////////////////////////////////////////////////////////////////////////
7934
7935 /**
7936 * Associated database field, or null.
7937 *
7938 * @property key
7939 * @type String
7940 */
7941 YAHOO.widget.Column.prototype.key = null;
7942
7943 /**
7944 * Text or HTML for display as Column's label in the TH element.
7945 *
7946 * @property label
7947 * @type String
7948 */
7949 YAHOO.widget.Column.prototype.label = null;
7950
7951 /**
7952 * Column head cell ABBR for accessibility.
7953 *
7954 * @property abbr
7955 * @type String
7956 */
7957 YAHOO.widget.Column.prototype.abbr = null;
7958
7959 /**
7960 * Array of object literals that define children (nested headers) of a Column.
7961 *
7962 * @property children
7963 * @type Object[]
7964 */
7965 YAHOO.widget.Column.prototype.children = null;
7966
7967 /**
7968 * Column width.
7969 *
7970 * @property width
7971 * @type String
7972 */
7973 YAHOO.widget.Column.prototype.width = null;
7974
7975 /**
7976 * Custom CSS class or array of classes to be applied to every cell in the Column.
7977 *
7978 * @property className
7979 * @type String || String[]
7980 */
7981 YAHOO.widget.Column.prototype.className = null;
7982
7983 /**
7984 * Defines a format function.
7985 *
7986 * @property formatter
7987 * @type String || HTMLFunction
7988 */
7989 YAHOO.widget.Column.prototype.formatter = null;
7990
7991 /**
7992 * Defines an editor function, otherwise Column is not editable.
7993 *
7994 * @property editor
7995 * @type String || HTMLFunction
7996 */
7997 YAHOO.widget.Column.prototype.editor = null;
7998
7999 /**
8000 * Defines editor options for Column in an object literal of param:value pairs.
8001 *
8002 * @property editorOptions
8003 * @type Object
8004 */
8005 YAHOO.widget.Column.prototype.editorOptions = null;
8006
8007 /**
8008 * True if Column is resizeable, false otherwise.
8009 *
8010 * @property resizeable
8011 * @type Boolean
8012 * @default false
8013 */
8014 YAHOO.widget.Column.prototype.resizeable = false;
8015
8016 /**
8017 * True if Column is sortable, false otherwise.
8018 *
8019 * @property sortable
8020 * @type Boolean
8021 * @default false
8022 */
8023 YAHOO.widget.Column.prototype.sortable = false;
8024
8025 /**
8026 * Default sort order for Column: "asc" or "desc".
8027 *
8028 * @property sortOptions.defaultOrder
8029 * @type String
8030 * @default null
8031 */
8032 /**
8033 * Custom sort handler.
8034 *
8035 * @property sortOptions.sortFunction
8036 * @type Function
8037 * @default null
8038 */
8039 YAHOO.widget.Column.prototype.sortOptions = null;
8040
8041
8042
8043
8044
8045
8046
8047
8048
8049
8050
8051
8052
8053
8054
8055 /////////////////////////////////////////////////////////////////////////////
8056 //
8057 // Public methods
8058 //
8059 /////////////////////////////////////////////////////////////////////////////
8060
8061 /**
8062 * Public accessor to the unique name of the Column instance.
8063 *
8064 * @method toString
8065 * @return {String} Column's unique name.
8066 */
8067 YAHOO.widget.Column.prototype.toString = function() {
8068 return this._sName;
8069 };
8070
8071 /**
8072 * Returns unique number assigned at instantiation, indicates original order
8073 * within ColumnSet.
8074 *
8075 * @method getId
8076 * @return {Number} Column's unique ID number.
8077 */
8078 YAHOO.widget.Column.prototype.getId = function() {
8079 return this._nId;
8080 };
8081
8082 /**
8083 * Public accessor returns Column's key index within its ColumnSet's keys array, or
8084 * null if not applicable.
8085 *
8086 * @method getKeyIndex
8087 * @return {Number} Column's key index within its ColumnSet keys array, if applicable.
8088 */
8089 YAHOO.widget.Column.prototype.getKeyIndex = function() {
8090 return this._nKeyIndex;
8091 };
8092
8093 /**
8094 * Public accessor returns Column's parent instance if any, or null otherwise.
8095 *
8096 * @method getParent
8097 * @return {YAHOO.widget.Column} Column's parent instance.
8098 */
8099 YAHOO.widget.Column.prototype.getParent = function() {
8100 return this._parent;
8101 };
8102
8103 /**
8104 * Public accessor returns Column's calculated COLSPAN value.
8105 *
8106 * @method getColspan
8107 * @return {Number} Column's COLSPAN value.
8108 */
8109 YAHOO.widget.Column.prototype.getColspan = function() {
8110 return this._colspan;
8111 };
8112 // Backward compatibility
8113 YAHOO.widget.Column.prototype.getColSpan = function() {
8114 return this.getColspan();
8115 };
8116
8117 /**
8118 * Public accessor returns Column's calculated ROWSPAN value.
8119 *
8120 * @method getRowspan
8121 * @return {Number} Column's ROWSPAN value.
8122 */
8123 YAHOO.widget.Column.prototype.getRowspan = function() {
8124 return this._rowspan;
8125 };
8126
8127 // Backward compatibility
8128 YAHOO.widget.Column.prototype.getIndex = function() {
8129 return this.getKeyIndex();
8130 };
8131 YAHOO.widget.Column.prototype.format = function() {
8132 };
8133 YAHOO.widget.Column.formatCheckbox = function(elCell, oRecord, oColumn, oData) {
8134 YAHOO.widget.DataTable.formatCheckbox(elCell, oRecord, oColumn, oData);
8135 };
8136 YAHOO.widget.Column.formatCurrency = function(elCell, oRecord, oColumn, oData) {
8137 YAHOO.widget.DataTable.formatCurrency(elCell, oRecord, oColumn, oData);
8138 };
8139 YAHOO.widget.Column.formatDate = function(elCell, oRecord, oColumn, oData) {
8140 YAHOO.widget.DataTable.formatDate(elCell, oRecord, oColumn, oData);
8141 };
8142 YAHOO.widget.Column.formatEmail = function(elCell, oRecord, oColumn, oData) {
8143 YAHOO.widget.DataTable.formatEmail(elCell, oRecord, oColumn, oData);
8144 };
8145 YAHOO.widget.Column.formatLink = function(elCell, oRecord, oColumn, oData) {
8146 YAHOO.widget.DataTable.formatLink(elCell, oRecord, oColumn, oData);
8147 };
8148 YAHOO.widget.Column.formatNumber = function(elCell, oRecord, oColumn, oData) {
8149 YAHOO.widget.DataTable.formatNumber(elCell, oRecord, oColumn, oData);
8150 };
8151 YAHOO.widget.Column.formatSelect = function(elCell, oRecord, oColumn, oData) {
8152 YAHOO.widget.DataTable.formatDropdown(elCell, oRecord, oColumn, oData);
8153 };
8154
8155 /****************************************************************************/
8156 /****************************************************************************/
8157 /****************************************************************************/
8158
8159 /**
8160 * Sort static utility to support Column sorting.
8161 *
8162 * @namespace YAHOO.util
8163 * @class Sort
8164 * @static
8165 */
8166 YAHOO.util.Sort = {
8167 /////////////////////////////////////////////////////////////////////////////
8168 //
8169 // Public methods
8170 //
8171 /////////////////////////////////////////////////////////////////////////////
8172
8173 /**
8174 * Comparator function for simple case-insensitive string sorting.
8175 *
8176 * @method compare
8177 * @param a {Object} First sort argument.
8178 * @param b {Object} Second sort argument.
8179 * @param desc {Boolean} True if sort direction is descending, false if
8180 * sort direction is ascending.
8181 */
8182 compare: function(a, b, desc) {
8183 if((a === null) || (typeof a == "undefined")) {
8184 if((b === null) || (typeof b == "undefined")) {
8185 return 0;
8186 }
8187 else {
8188 return 1;
8189 }
8190 }
8191 else if((b === null) || (typeof b == "undefined")) {
8192 return -1;
8193 }
8194
8195 if(a.constructor == String) {
8196 a = a.toLowerCase();
8197 }
8198 if(b.constructor == String) {
8199 b = b.toLowerCase();
8200 }
8201 if(a < b) {
8202 return (desc) ? 1 : -1;
8203 }
8204 else if (a > b) {
8205 return (desc) ? -1 : 1;
8206 }
8207 else {
8208 return 0;
8209 }
8210 }
8211 };
8212
8213 /****************************************************************************/
8214 /****************************************************************************/
8215 /****************************************************************************/
8216
8217 /**
8218 * ColumnResizer subclasses DragDrop to support resizeable Columns.
8219 *
8220 * @namespace YAHOO.util
8221 * @class ColumnResizer
8222 * @extends YAHOO.util.DragDrop
8223 * @constructor
8224 * @param oDataTable {YAHOO.widget.DataTable} DataTable instance.
8225 * @param oColumn {YAHOO.widget.Column} Column instance.
8226 * @param elThead {HTMLElement} TH element reference.
8227 * @param sHandleElId {String} DOM ID of the handle element that causes the resize.
8228 * @param sGroup {String} Group name of related DragDrop items.
8229 * @param oConfig {Object} (Optional) Object literal of config values.
8230 */
8231 YAHOO.util.ColumnResizer = function(oDataTable, oColumn, elThead, sHandleId, sGroup, oConfig) {
8232 if(oDataTable && oColumn && elThead && sHandleId) {
8233 this.datatable = oDataTable;
8234 this.column = oColumn;
8235 this.cell = elThead;
8236 this.init(sHandleId, sGroup, oConfig);
8237 //this.initFrame();
8238 this.setYConstraint(0,0);
8239 }
8240 else {
8241 }
8242 };
8243
8244 if(YAHOO.util.DD) {
8245 YAHOO.extend(YAHOO.util.ColumnResizer, YAHOO.util.DD);
8246 }
8247
8248 /////////////////////////////////////////////////////////////////////////////
8249 //
8250 // Public DOM event handlers
8251 //
8252 /////////////////////////////////////////////////////////////////////////////
8253
8254 /**
8255 * Handles mousedown events on the Column resizer.
8256 *
8257 * @method onMouseDown
8258 * @param e {string} The mousedown event
8259 */
8260 YAHOO.util.ColumnResizer.prototype.onMouseDown = function(e) {
8261 this.startWidth = this.cell.offsetWidth;
8262 this.startPos = YAHOO.util.Dom.getX(this.getDragEl());
8263
8264 if(this.datatable.fixedWidth) {
8265 var cellLabel = YAHOO.util.Dom.getElementsByClassName(YAHOO.widget.DataTable.CLASS_LABEL,"span",this.cell)[0];
8266 this.minWidth = cellLabel.offsetWidth + 6;
8267 var sib = this.cell.nextSibling;
8268 var sibCellLabel = YAHOO.util.Dom.getElementsByClassName(YAHOO.widget.DataTable.CLASS_LABEL,"span",sib)[0];
8269 this.sibMinWidth = sibCellLabel.offsetWidth + 6;
8270 //!!
8271 var left = ((this.startWidth - this.minWidth) < 0) ? 0 : (this.startWidth - this.minWidth);
8272 var right = ((sib.offsetWidth - this.sibMinWidth) < 0) ? 0 : (sib.offsetWidth - this.sibMinWidth);
8273 this.setXConstraint(left, right);
8274 }
8275
8276 };
8277
8278 /**
8279 * Handles mouseup events on the Column resizer.
8280 *
8281 * @method onMouseUp
8282 * @param e {string} The mouseup event
8283 */
8284 YAHOO.util.ColumnResizer.prototype.onMouseUp = function(e) {
8285 //TODO: replace the resizer where it belongs:
8286 var resizeStyle = YAHOO.util.Dom.get(this.handleElId).style;
8287 resizeStyle.left = "auto";
8288 resizeStyle.right = 0;
8289 resizeStyle.marginRight = "-6px";
8290 resizeStyle.width = "6px";
8291 //.yui-dt-headresizer {position:absolute;margin-right:-6px;right:0;bottom:0;width:6px;height:100%;cursor:w-resize;cursor:col-resize;}
8292
8293
8294 //var cells = this.datatable._elTable.tHead.rows[this.datatable._elTable.tHead.rows.length-1].cells;
8295 //for(var i=0; i<cells.length; i++) {
8296 //cells[i].style.width = "5px";
8297 //}
8298
8299 //TODO: set new ColumnSet width values
8300 this.datatable.fireEvent("columnResizeEvent", {column:this.column,target:this.cell});
8301 };
8302
8303 /**
8304 * Handles drag events on the Column resizer.
8305 *
8306 * @method onDrag
8307 * @param e {string} The drag event
8308 */
8309 YAHOO.util.ColumnResizer.prototype.onDrag = function(e) {
8310 var newPos = YAHOO.util.Dom.getX(this.getDragEl());
8311 var offsetX = newPos - this.startPos;
8312 var newWidth = this.startWidth + offsetX;
8313
8314 if(newWidth < this.minWidth) {
8315 newWidth = this.minWidth;
8316 }
8317
8318 // Resize the Column
8319 var oDataTable = this.datatable;
8320 var elCell = this.cell;
8321
8322
8323 // Resize the other Columns
8324 if(oDataTable.fixedWidth) {
8325 // Moving right or left?
8326 var sib = elCell.nextSibling;
8327 //var sibIndex = elCell.index + 1;
8328 var sibnewwidth = sib.offsetWidth - offsetX;
8329 if(sibnewwidth < this.sibMinWidth) {
8330 sibnewwidth = this.sibMinWidth;
8331 }
8332
8333 //TODO: how else to cycle through all the Columns without having to use an index property?
8334 for(var i=0; i<oDataTable._oColumnSet.length; i++) {
8335 //if((i != elCell.index) && (i!=sibIndex)) {
8336 // YAHOO.util.Dom.get(oDataTable._oColumnSet.keys[i].id).style.width = oDataTable._oColumnSet.keys[i].width + "px";
8337 //}
8338 }
8339 sib.style.width = sibnewwidth;
8340 elCell.style.width = newWidth + "px";
8341 //oDataTable._oColumnSet.flat[sibIndex].width = sibnewwidth;
8342 //oDataTable._oColumnSet.flat[elCell.index].width = newWidth;
8343
8344 }
8345 else {
8346 elCell.style.width = newWidth + "px";
8347 }
8348 };
8349
8350
8351
8352
8353 /****************************************************************************/
8354 /****************************************************************************/
8355 /****************************************************************************/
8356
8357 /**
8358 * A RecordSet defines and manages a set of Records.
8359 *
8360 * @namespace YAHOO.widget
8361 * @class RecordSet
8362 * @param data {Object || Object[]} An object literal or an array of data.
8363 * @constructor
8364 */
8365 YAHOO.widget.RecordSet = function(data) {
8366 // Internal variables
8367 this._sName = "RecordSet instance" + YAHOO.widget.RecordSet._nCount;
8368 YAHOO.widget.RecordSet._nCount++;
8369 this._records = [];
8370 this._length = 0;
8371
8372 if(data) {
8373 if(YAHOO.lang.isArray(data)) {
8374 this.addRecords(data);
8375 }
8376 else if(data.constructor == Object) {
8377 this.addRecord(data);
8378 }
8379 }
8380
8381 /**
8382 * Fired when a new Record is added to the RecordSet.
8383 *
8384 * @event recordAddEvent
8385 * @param oArgs.record {YAHOO.widget.Record} The Record instance.
8386 * @param oArgs.data {Object} Data added.
8387 */
8388 this.createEvent("recordAddEvent");
8389
8390 /**
8391 * Fired when multiple Records are added to the RecordSet at once.
8392 *
8393 * @event recordsAddEvent
8394 * @param oArgs.records {YAHOO.widget.Record[]} An array of Record instances.
8395 * @param oArgs.data {Object[]} Data added.
8396 */
8397 this.createEvent("recordsAddEvent");
8398
8399 /**
8400 * Fired when a Record is updated with new data.
8401 *
8402 * @event recordUpdateEvent
8403 * @param oArgs.record {YAHOO.widget.Record} The Record instance.
8404 * @param oArgs.newData {Object} New data.
8405 * @param oArgs.oldData {Object} Old data.
8406 */
8407 this.createEvent("recordUpdateEvent");
8408
8409 /**
8410 * Fired when a Record is deleted from the RecordSet.
8411 *
8412 * @event recordDeleteEvent
8413 * @param oArgs.data {Object} A copy of the data held by the Record,
8414 * or an array of data object literals if multiple Records were deleted at once.
8415 * @param oArgs.index {Object} Index of the deleted Record.
8416 */
8417 this.createEvent("recordDeleteEvent");
8418
8419 /**
8420 * Fired when multiple Records are deleted from the RecordSet at once.
8421 *
8422 * @event recordsDeleteEvent
8423 * @param oArgs.data {Object[]} An array of data object literals copied
8424 * from the Records.
8425 * @param oArgs.index {Object} Index of the first deleted Record.
8426 */
8427 this.createEvent("recordsDeleteEvent");
8428
8429 /**
8430 * Fired when all Records are deleted from the RecordSet at once.
8431 *
8432 * @event resetEvent
8433 */
8434 this.createEvent("resetEvent");
8435
8436 /**
8437 * Fired when a Record Key is updated with new data.
8438 *
8439 * @event keyUpdateEvent
8440 * @param oArgs.record {YAHOO.widget.Record} The Record instance.
8441 * @param oArgs.key {String} The updated key.
8442 * @param oArgs.newData {Object} New data.
8443 * @param oArgs.oldData {Object} Old data.
8444 *
8445 */
8446 this.createEvent("keyUpdateEvent");
8447
8448 };
8449
8450 if(YAHOO.util.EventProvider) {
8451 YAHOO.augment(YAHOO.widget.RecordSet, YAHOO.util.EventProvider);
8452 }
8453 else {
8454 }
8455
8456 /////////////////////////////////////////////////////////////////////////////
8457 //
8458 // Private member variables
8459 //
8460 /////////////////////////////////////////////////////////////////////////////
8461 /**
8462 * Internal class variable to name multiple Recordset instances.
8463 *
8464 * @property RecordSet._nCount
8465 * @type Number
8466 * @private
8467 * @static
8468 */
8469 YAHOO.widget.RecordSet._nCount = 0;
8470
8471 /**
8472 * Unique instance name.
8473 *
8474 * @property _sName
8475 * @type String
8476 * @private
8477 */
8478 YAHOO.widget.RecordSet.prototype._sName = null;
8479
8480 /**
8481 * Internal variable to give unique indexes to Record instances.
8482 *
8483 * @property _nCount
8484 * @type Number
8485 * @private
8486 */
8487 YAHOO.widget.RecordSet.prototype._nRecordCount = 0;
8488
8489 /**
8490 * Internal counter of how many Records are in the RecordSet.
8491 *
8492 * @property _length
8493 * @type Number
8494 * @private
8495 */
8496 YAHOO.widget.RecordSet.prototype._length = null;
8497
8498 /////////////////////////////////////////////////////////////////////////////
8499 //
8500 // Private methods
8501 //
8502 /////////////////////////////////////////////////////////////////////////////
8503
8504 /**
8505 * Adds one Record to the RecordSet at the given index. If index is null,
8506 * then adds the Record to the end of the RecordSet.
8507 *
8508 * @method _addRecord
8509 * @param oData {Object} An object literal of data.
8510 * @param index {Number} (optional) Position index.
8511 * @return {YAHOO.widget.Record} A Record instance.
8512 * @private
8513 */
8514 YAHOO.widget.RecordSet.prototype._addRecord = function(oData, index) {
8515 var oRecord = new YAHOO.widget.Record(oData);
8516 oRecord._nId = this._nRecordCount;
8517 this._nRecordCount++;
8518
8519 if(YAHOO.lang.isNumber(index) && (index > -1)) {
8520 this._records.splice(index,0,oRecord);
8521 }
8522 else {
8523 index = this.getLength();
8524 this._records.push(oRecord);
8525 }
8526 this._length++;
8527 return oRecord;
8528 };
8529
8530 /**
8531 * Deletes Records from the RecordSet at the given index. If range is null,
8532 * then only one Record is deleted.
8533 *
8534 * @method _deleteRecord
8535 * @param index {Number} Position index.
8536 * @param range {Number} (optional) How many Records to delete
8537 * @private
8538 */
8539 YAHOO.widget.RecordSet.prototype._deleteRecord = function(index, range) {
8540 if(!YAHOO.lang.isNumber(range) || (range < 0)) {
8541 range = 1;
8542 }
8543 this._records.splice(index, range);
8544 this._length = this._length - range;
8545 };
8546
8547 /////////////////////////////////////////////////////////////////////////////
8548 //
8549 // Public methods
8550 //
8551 /////////////////////////////////////////////////////////////////////////////
8552
8553 /**
8554 * Public accessor to the unique name of the RecordSet instance.
8555 *
8556 * @method toString
8557 * @return {String} Unique name of the RecordSet instance.
8558 */
8559 YAHOO.widget.RecordSet.prototype.toString = function() {
8560 return this._sName;
8561 };
8562
8563 /**
8564 * Returns the number of Records held in the RecordSet.
8565 *
8566 * @method getLength
8567 * @return {Number} Number of records in the RecordSet.
8568 */
8569 YAHOO.widget.RecordSet.prototype.getLength = function() {
8570 return this._length;
8571 };
8572
8573 /**
8574 * Returns Record at given position index.
8575 *
8576 * @method getRecord
8577 * @param index {Number} Record's Recordset position index.
8578 * @return {YAHOO.widget.Record} Record object.
8579 */
8580 YAHOO.widget.RecordSet.prototype.getRecord = function(index) {
8581 if(YAHOO.lang.isNumber(index)) {
8582 return this._records[index];
8583 }
8584 /*else if(YAHOO.lang.isString(identifier)) {
8585 for(var i=0; i<this._records.length; i++) {
8586 if(this._records[i].yuiRecordId == identifier) {
8587 return this._records[i];
8588 }
8589 }
8590 }*/
8591 return null;
8592
8593 };
8594
8595 /*
8596 * Returns an array of Records from the RecordSet.
8597 *
8598 * @method getRecords
8599 * @param index {Number} (optional) Recordset position index of which Record to
8600 * start at.
8601 * @param range {Number} (optional) Number of Records to get.
8602 * @return {YAHOO.widget.Record[]} Array of Records starting at given index and
8603 * length equal to given range. If index is not given, all Records are returned.
8604 */
8605 YAHOO.widget.RecordSet.prototype.getRecords = function(index, range) {
8606 if(!YAHOO.lang.isNumber(index)) {
8607 return this._records;
8608 }
8609 if(!YAHOO.lang.isNumber(range)) {
8610 return this._records.slice(index);
8611 }
8612 return this._records.slice(index, index+range);
8613 };
8614
8615 /**
8616 * Returns position index for the given Record.
8617 *
8618 * @method getRecordIndex
8619 * @param oRecord {YAHOO.widget.Record} Record instance.
8620 * @return {Number} Record's RecordSet position index.
8621 */
8622
8623 YAHOO.widget.RecordSet.prototype.getRecordIndex = function(oRecord) {
8624 for(var i=this._records.length-1; i>-1; i--) {
8625 if(oRecord.getId() === this._records[i].getId()) {
8626 return i;
8627 }
8628 }
8629 return null;
8630
8631 };
8632
8633 /**
8634 * Adds one Record to the RecordSet at the given index. If index is null,
8635 * then adds the Record to the end of the RecordSet.
8636 *
8637 * @method addRecord
8638 * @param oData {Object} An object literal of data.
8639 * @param index {Number} (optional) Position index.
8640 * @return {YAHOO.widget.Record} A Record instance.
8641 */
8642 YAHOO.widget.RecordSet.prototype.addRecord = function(oData, index) {
8643 if(oData && (oData.constructor == Object)) {
8644 var oRecord = this._addRecord(oData, index);
8645 this.fireEvent("recordAddEvent",{record:oRecord,data:oData});
8646 return oRecord;
8647 }
8648 else {
8649 return null;
8650 }
8651 };
8652
8653 /**
8654 * Adds multiple Records at once to the RecordSet at the given index with the
8655 * given data. If index is null, then the new Records are added to the end of
8656 * the RecordSet.
8657 *
8658 * @method addRecords
8659 * @param aData {Object[]} An array of object literal data.
8660 * @param index {Number} (optional) Position index.
8661 * @return {YAHOO.widget.Record[]} An array of Record instances.
8662 */
8663 YAHOO.widget.RecordSet.prototype.addRecords = function(aData, index) {
8664 if(YAHOO.lang.isArray(aData)) {
8665 var newRecords = [];
8666 // Can't go backwards bc we need to preserve order
8667 for(var i=0; i<aData.length; i++) {
8668 if(aData[i] && (aData[i].constructor == Object)) {
8669 var record = this._addRecord(aData[i], index);
8670 newRecords.push(record);
8671 }
8672 }
8673 this.fireEvent("recordsAddEvent",{records:newRecords,data:aData});
8674 return newRecords;
8675 }
8676 else if(aData && (aData.constructor == Object)) {
8677 var oRecord = this._addRecord(aData);
8678 this.fireEvent("recordsAddEvent",{records:[oRecord],data:aData});
8679 return oRecord;
8680 }
8681 else {
8682 }
8683 };
8684
8685 /**
8686 * Updates given Record with given data.
8687 *
8688 * @method updateRecord
8689 * @param record {YAHOO.widget.Record | Number} A Record instance, or Record's
8690 * RecordSet position index.
8691 * @param oData {Object) Object literal of new data.
8692 * @return {YAHOO.widget.Record} Updated Record, or null.
8693 */
8694 YAHOO.widget.RecordSet.prototype.updateRecord = function(record, oData) {
8695 var oRecord = null;
8696 if(YAHOO.lang.isNumber(record)) {
8697 oRecord = this._records[record];
8698 }
8699 else if(record instanceof YAHOO.widget.Record) {
8700 oRecord = record;
8701 }
8702 if(oRecord && oData && (oData.constructor == Object)) {
8703 // Copy data from the Record for the event that gets fired later
8704 var oldData = {};
8705 for(var key in oRecord._oData) {
8706 oldData[key] = oRecord._oData[key];
8707 }
8708 oRecord._oData = oData;
8709 this.fireEvent("recordUpdateEvent",{record:oRecord,newData:oData,oldData:oldData});
8710 return oRecord;
8711 }
8712 else {
8713 return null;
8714 }
8715 };
8716
8717 /**
8718 * Updates given Record at given key with given data.
8719 *
8720 * @method updateKey
8721 * @param record {YAHOO.widget.Record | Number} A Record instance, or Record's
8722 * RecordSet position index.
8723 * @param sKey {String} Key name.
8724 * @param oData {Object) New data.
8725 */
8726 YAHOO.widget.RecordSet.prototype.updateKey = function(record, sKey, oData) {
8727 var oRecord;
8728
8729 if(YAHOO.lang.isNumber(record)) {
8730 oRecord = this._records[record];
8731 }
8732 if(record instanceof YAHOO.widget.Record) {
8733 oRecord = record;
8734
8735 var oldData = null;
8736 var keyValue = oRecord._oData[sKey];
8737 // Copy data from the Record for the event that gets fired later
8738 if(keyValue && keyValue.constructor == Object) {
8739 oldData = {};
8740 for(var key in keyValue) {
8741 oldData[key] = keyValue[key];
8742 }
8743 }
8744 // Copy by value
8745 else {
8746 oldData = keyValue;
8747 }
8748
8749 oRecord._oData[sKey] = oData;
8750 this.fireEvent("keyUpdateEvent",{record:oRecord,key:sKey,newData:oData,oldData:oldData});
8751 }
8752 else {
8753 }
8754 };
8755
8756 /**
8757 * Replaces all Records in RecordSet with new data.
8758 *
8759 * @method replaceRecords
8760 * @param data {Object || Object[]} An object literal of data or an array of
8761 * object literal data.
8762 * @return {YAHOO.widget.Record || YAHOO.widget.Record[]} A Record instance or
8763 * an array of Records.
8764 */
8765 YAHOO.widget.RecordSet.prototype.replaceRecords = function(data) {
8766 this.reset();
8767 return this.addRecords(data);
8768 };
8769
8770 /**
8771 * Sorts all Records by given function.
8772 *
8773 * @method sortRecords
8774 * @param fnSort {Function} Reference to a sort function.
8775 * @param desc {Boolean} True if sort direction is descending, false if sort
8776 * direction is ascending.
8777 * @return {YAHOO.widget.Record[]} Sorted array of Records.
8778 */
8779 YAHOO.widget.RecordSet.prototype.sortRecords = function(fnSort, desc) {
8780 return this._records.sort(function(a, b) {return fnSort(a, b, desc);});
8781 };
8782
8783
8784 /**
8785 * Removes the Record at the given position index from the RecordSet. If a range
8786 * is also provided, removes that many Records, starting from the index. Length
8787 * of RecordSet is correspondingly shortened.
8788 *
8789 * @method deleteRecord
8790 * @param index {Number} Record's RecordSet position index.
8791 * @param range {Number} (optional) How many Records to delete.
8792 * @return {Object} A copy of the data held by the deleted Record.
8793 */
8794 YAHOO.widget.RecordSet.prototype.deleteRecord = function(index) {
8795 if(YAHOO.lang.isNumber(index) && (index > -1) && (index < this.getLength())) {
8796 // Copy data from the Record for the event that gets fired later
8797 var oRecordData = this.getRecord(index).getData();
8798 var oData = {};
8799 for(var key in oRecordData) {
8800 oData[key] = oRecordData[key];
8801 }
8802
8803 this._deleteRecord(index);
8804 this.fireEvent("recordDeleteEvent",{data:oData,index:index});
8805 return oData;
8806 }
8807 else {
8808 return null;
8809 }
8810 };
8811
8812 /**
8813 * Removes the Record at the given position index from the RecordSet. If a range
8814 * is also provided, removes that many Records, starting from the index. Length
8815 * of RecordSet is correspondingly shortened.
8816 *
8817 * @method deleteRecords
8818 * @param index {Number} Record's RecordSet position index.
8819 * @param range {Number} (optional) How many Records to delete.
8820 */
8821 YAHOO.widget.RecordSet.prototype.deleteRecords = function(index, range) {
8822 if(!YAHOO.lang.isNumber(range)) {
8823 range = 1;
8824 }
8825 if(YAHOO.lang.isNumber(index) && (index > -1) && (index < this.getLength())) {
8826 var recordsToDelete = this.getRecords(index, range);
8827 // Copy data from each Record for the event that gets fired later
8828 var deletedData = [];
8829 for(var i=0; i<recordsToDelete.length; i++) {
8830 var oData = {};
8831 for(var key in recordsToDelete[i]) {
8832 oData[key] = recordsToDelete[i][key];
8833 }
8834 deletedData.push(oData);
8835 }
8836 this._deleteRecord(index, range);
8837
8838 this.fireEvent("recordsDeleteEvent",{data:deletedData,index:index});
8839
8840 }
8841 else {
8842 }
8843 };
8844
8845 /**
8846 * Deletes all Records from the RecordSet.
8847 *
8848 * @method reset
8849 */
8850 YAHOO.widget.RecordSet.prototype.reset = function() {
8851 this._records = [];
8852 this._length = 0;
8853 this.fireEvent("resetEvent");
8854 };
8855
8856
8857 /****************************************************************************/
8858 /****************************************************************************/
8859 /****************************************************************************/
8860
8861 /**
8862 * The Record class defines a DataTable record.
8863 *
8864 * @namespace YAHOO.widget
8865 * @class Record
8866 * @constructor
8867 * @param oConfigs {Object} (optional) Object literal of key/value pairs.
8868 */
8869 YAHOO.widget.Record = function(oLiteral) {
8870 this._oData = {};
8871 if(oLiteral && (oLiteral.constructor == Object)) {
8872 for(var sKey in oLiteral) {
8873 this._oData[sKey] = oLiteral[sKey];
8874 }
8875 }
8876 };
8877
8878 /////////////////////////////////////////////////////////////////////////////
8879 //
8880 // Private member variables
8881 //
8882 /////////////////////////////////////////////////////////////////////////////
8883 /**
8884 * Unique number assigned at instantiation, indicates original order within
8885 * RecordSet.
8886 *
8887 * @property _nId
8888 * @type Number
8889 * @private
8890 */
8891 YAHOO.widget.Record.prototype._nId = null;
8892
8893 /**
8894 * Holds data for the Record in an object literal.
8895 *
8896 * @property _oData
8897 * @type Object
8898 * @private
8899 */
8900 YAHOO.widget.Record.prototype._oData = null;
8901
8902 /////////////////////////////////////////////////////////////////////////////
8903 //
8904 // Public member variables
8905 //
8906 /////////////////////////////////////////////////////////////////////////////
8907
8908 /////////////////////////////////////////////////////////////////////////////
8909 //
8910 // Public methods
8911 //
8912 /////////////////////////////////////////////////////////////////////////////
8913
8914 /**
8915 * Returns unique number assigned at instantiation, indicates original order
8916 * within RecordSet.
8917 *
8918 * @method getId
8919 * @return Number
8920 */
8921 YAHOO.widget.Record.prototype.getId = function() {
8922 return this._nId;
8923 };
8924
8925 /**
8926 * Returns data for the Record for a key if given, or the entire object
8927 * literal otherwise.
8928 *
8929 * @method getData
8930 * @param sKey {String} (Optional) The key to retrieve a single data value.
8931 * @return Object
8932 */
8933 YAHOO.widget.Record.prototype.getData = function(sKey) {
8934 if(YAHOO.lang.isString(sKey)) {
8935 return this._oData[sKey];
8936 }
8937 else {
8938 return this._oData;
8939 }
8940 };
8941
8942
8943 YAHOO.register("datatable", YAHOO.widget.DataTable, {version: "2.3.0", build: "442"});
Moodle Repo, with LinuxChix modifications