← Back to branch summary

~loggerhead-team/loggerhead/trunk-rich

« back to all changes in this revision

Viewing changes to loggerhead/static/javascript/yui/build/dom/dom-base.js

[rs=thumper] merge loggerhead trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
loggerhead/static/javascript/yui/build/dom/dom-base.js
2
2
Copyright (c) 2008, Yahoo! Inc. All rights reserved.
3
3
Code licensed under the BSD License:
4
4
http://developer.yahoo.net/yui/license.txt
5
 
version: 3.0.0pr1
 
5
version: 3.0.0pr2
6
6
*/
7
7
YUI.add('dom-base', function(Y) {
8
8
 
66
66
        if (text === UNDEFINED && INNER_TEXT in element) {
67
67
            text = element[INNER_TEXT];
68
68
        } 
69
 
        return text || ''; 
 
69
        return text || '';
70
70
    },
71
71
 
72
72
    /**
79
79
     * @return {HTMLElement | null} The first matching child html element.
80
80
     */
81
81
    firstChild: function(element, fn) {
82
 
        return Y.DOM._childBy(element, null, fn); 
 
82
        return Y.DOM._childBy(element, null, fn);
83
83
    },
84
84
 
85
85
    firstChildByTag: function(element, tag, fn) {
86
 
        return Y.DOM._childBy(element, tag, fn); 
 
86
        return Y.DOM._childBy(element, tag, fn);
87
87
    },
88
88
 
89
89
    /**
90
90
     * Finds the lastChild of the given HTMLElement.
91
91
     * @method lastChild
92
92
     * @param {HTMLElement} element The html element.
 
93
     * @param {String} tag The tag to search for.
93
94
     * @param {Function} fn optional An optional boolean test to apply.
94
95
     * The optional function is passed the current HTMLElement being tested as its only argument.
95
96
     * If no function is given, the first found is returned.
96
97
     * @return {HTMLElement | null} The first matching child html element.
97
98
     */
98
99
    lastChild: function(element, fn) {
99
 
        return Y.DOM._childBy(element, null, fn, true); 
 
100
        return Y.DOM._childBy(element, null, fn, true);
100
101
    },
101
102
 
102
103
    lastChildByTag: function(element, tag, fn) {
103
 
        return Y.DOM._childBy(element, tag, fn, true); 
 
104
        return Y.DOM._childBy(element, tag, fn, true);
104
105
    },
105
106
 
106
107
    /**
126
127
                    }
127
128
                }
128
129
 
129
 
                return elements; 
 
130
                return elements;
130
131
            };
131
132
        } else {
132
133
            return function(element, tag, fn) {
142
143
                        };
143
144
                    }
144
145
 
145
 
                    elements = Y.DOM.filterElementsBy(elements, wrapFn); 
 
146
                    elements = Y.DOM.filterElementsBy(elements, wrapFn);
146
147
                }
147
148
                return elements;
148
149
            };
159
160
     * @return {Array} The collection of child elements.
160
161
     */
161
162
    children: function(element, fn) {
162
 
        return Y.DOM.childrenByTag(element, null, fn); 
 
163
        return Y.DOM.childrenByTag(element, null, fn);
163
164
    },
164
165
 
165
166
    /**
172
173
     * @param {Boolean} all optional Whether all node types should be scanned, or just element nodes.
173
174
     * @return {HTMLElement | null} The matching DOM node or null if none found. 
174
175
     */
175
 
    previous: function(element, fn, all) {
 
176
    previous: function(element, fn) {
176
177
        return Y.DOM.elementByAxis(element, PREVIOUS_SIBLING, fn);
177
178
    },
178
179
 
211
212
     * @param {String} axis The axis to search (parentNode, nextSibling, previousSibling).
212
213
     * @param {Function} fn optional An optional boolean test to apply.
213
214
     * @param {Boolean} all optional Whether all node types should be returned, or just element nodes.
214
 
     * The optional function is passed the current DOM node being tested as its only argument.
 
215
     * The optional function is passed the current HTMLElement being tested as its only argument.
215
216
     * If no function is given, the first element is returned.
216
217
     * @return {HTMLElement | null} The matching element or null if none found.
217
218
     */
255
256
     * @param {HTMLElement} root optional An optional root element to start from.
256
257
     * @param {Function} fn optional An optional boolean test to apply.
257
258
     * The optional function is passed the current HTMLElement being tested as its only argument.
258
 
     * If no function is given, the first match is returned.
 
259
     * If no function is given, the first match is returned. 
259
260
     * @return {HTMLElement} The matching element.
260
261
     */
261
262
    firstByTag: function(tag, root, fn) {
284
285
     */
285
286
    filterElementsBy: function(elements, fn, firstOnly) {
286
287
        var ret = (firstOnly) ? null : [];
287
 
        for (var i = 0, el; el = elements[i++];) {
288
 
            if ( el[TAG_NAME] && (!fn || fn(el)) ) {
 
288
        for (var i = 0, len = elements[LENGTH]; i < len; ++i) {
 
289
            if (elements[i][TAG_NAME] && (!fn || fn(elements[i]))) {
289
290
                if (firstOnly) {
290
 
                    ret = el;
 
291
                    ret = elements[i];
291
292
                    break;
292
293
                } else {
293
 
                    ret[ret[LENGTH]] = el;
 
294
                    ret[ret[LENGTH]] = elements[i];
294
295
                }
295
296
            }
296
297
        }
308
309
    contains: function(element, needle) {
309
310
        var ret = false;
310
311
 
311
 
        if (!needle || !needle[NODE_TYPE] || !element || !element[NODE_TYPE]) {
 
312
        if ( !needle || !element || !needle[NODE_TYPE] || !element[NODE_TYPE]) {
312
313
            ret = false;
313
314
        } else if (element[CONTAINS])  {
314
315
            if (Y.UA.opera || needle[NODE_TYPE] === 1) { // IE & SAF contains fail if needle not an ELEMENT_NODE
326
327
    },
327
328
 
328
329
    /**
329
 
     * Returns an HTMLElement for the given string of HTML.
330
 
     * @method create
331
 
     * @param {String} html The string of HTML to convert to a DOM element. 
332
 
     * @param {Document} document An optional document to create the node with.
333
 
     * @return {HTMLElement} The newly created element. 
 
330
     * Determines whether or not the HTMLElement is part of the document.
 
331
     * @method inDoc
 
332
     * @param {HTMLElement} element The containing html element.
 
333
     * @param {HTMLElement} doc optional The document to check.
 
334
     * @return {Boolean} Whether or not the element is attached to the document. 
334
335
     */
 
336
    inDoc: function(element, doc) {
 
337
        doc = doc || Y.config.doc;
 
338
        return Y.DOM.contains(doc.documentElement, element);
 
339
    },
 
340
 
335
341
    create: function(html, doc) {
336
342
        doc = doc || Y.config.doc;
337
343
        var m = re_tag.exec(html);
523
529
        });
524
530
    }
525
531
})();
 
532
 
526
533
/** 
527
534
 * The DOM utility provides a cross-browser abtraction layer
528
535
 * normalizing DOM tasks, and adds extra helper functionality
606
613
 
607
614
 
608
615
 
609
 
}, '3.0.0pr1' );
 
616
 
 
617
}, '3.0.0pr2' ,{skinnable:false, requires:['event']});