The Tor Browser / file comparison
comparison: dom/tests/mochitest/ajax/mochikit/MochiKit/DOM.js
dom/tests/mochitest/ajax/mochikit/MochiKit/DOM.js
- branch
- TOR_BUG_9701
- changeset 8
- 97036ab72558
equal
deleted
inserted
replaced
| -1:000000000000 | 0:89d4559abea3 |
|---|---|
| 1 /*** | |
| 2 | |
| 3 MochiKit.DOM 1.4 | |
| 4 | |
| 5 See <http://mochikit.com/> for documentation, downloads, license, etc. | |
| 6 | |
| 7 (c) 2005 Bob Ippolito. All rights Reserved. | |
| 8 | |
| 9 ***/ | |
| 10 | |
| 11 if (typeof(dojo) != 'undefined') { | |
| 12 dojo.provide("MochiKit.DOM"); | |
| 13 dojo.require("MochiKit.Base"); | |
| 14 } | |
| 15 if (typeof(JSAN) != 'undefined') { | |
| 16 JSAN.use("MochiKit.Base", []); | |
| 17 } | |
| 18 | |
| 19 try { | |
| 20 if (typeof(MochiKit.Base) == 'undefined') { | |
| 21 throw ""; | |
| 22 } | |
| 23 } catch (e) { | |
| 24 throw "MochiKit.DOM depends on MochiKit.Base!"; | |
| 25 } | |
| 26 | |
| 27 if (typeof(MochiKit.DOM) == 'undefined') { | |
| 28 MochiKit.DOM = {}; | |
| 29 } | |
| 30 | |
| 31 MochiKit.DOM.NAME = "MochiKit.DOM"; | |
| 32 MochiKit.DOM.VERSION = "1.4"; | |
| 33 MochiKit.DOM.__repr__ = function () { | |
| 34 return "[" + this.NAME + " " + this.VERSION + "]"; | |
| 35 }; | |
| 36 MochiKit.DOM.toString = function () { | |
| 37 return this.__repr__(); | |
| 38 }; | |
| 39 | |
| 40 MochiKit.DOM.EXPORT = [ | |
| 41 "removeEmptyTextNodes", | |
| 42 "formContents", | |
| 43 "currentWindow", | |
| 44 "currentDocument", | |
| 45 "withWindow", | |
| 46 "withDocument", | |
| 47 "registerDOMConverter", | |
| 48 "coerceToDOM", | |
| 49 "createDOM", | |
| 50 "createDOMFunc", | |
| 51 "isChildNode", | |
| 52 "getNodeAttribute", | |
| 53 "removeNodeAttribute", | |
| 54 "setNodeAttribute", | |
| 55 "updateNodeAttributes", | |
| 56 "appendChildNodes", | |
| 57 "insertSiblingNodesAfter", | |
| 58 "insertSiblingNodesBefore", | |
| 59 "replaceChildNodes", | |
| 60 "removeElement", | |
| 61 "swapDOM", | |
| 62 "BUTTON", | |
| 63 "TT", | |
| 64 "PRE", | |
| 65 "H1", | |
| 66 "H2", | |
| 67 "H3", | |
| 68 "BR", | |
| 69 "CANVAS", | |
| 70 "HR", | |
| 71 "LABEL", | |
| 72 "TEXTAREA", | |
| 73 "FORM", | |
| 74 "STRONG", | |
| 75 "SELECT", | |
| 76 "OPTION", | |
| 77 "OPTGROUP", | |
| 78 "LEGEND", | |
| 79 "FIELDSET", | |
| 80 "P", | |
| 81 "UL", | |
| 82 "OL", | |
| 83 "LI", | |
| 84 "TD", | |
| 85 "TR", | |
| 86 "THEAD", | |
| 87 "TBODY", | |
| 88 "TFOOT", | |
| 89 "TABLE", | |
| 90 "TH", | |
| 91 "INPUT", | |
| 92 "SPAN", | |
| 93 "A", | |
| 94 "DIV", | |
| 95 "IMG", | |
| 96 "getElement", | |
| 97 "$", | |
| 98 "getElementsByTagAndClassName", | |
| 99 "addToCallStack", | |
| 100 "addLoadEvent", | |
| 101 "focusOnLoad", | |
| 102 "setElementClass", | |
| 103 "toggleElementClass", | |
| 104 "addElementClass", | |
| 105 "removeElementClass", | |
| 106 "swapElementClass", | |
| 107 "hasElementClass", | |
| 108 "escapeHTML", | |
| 109 "toHTML", | |
| 110 "emitHTML", | |
| 111 "scrapeText", | |
| 112 "isParent", | |
| 113 "getFirstParentByTagAndClassName", | |
| 114 "makeClipping", | |
| 115 "undoClipping", | |
| 116 "makePositioned", | |
| 117 "undoPositioned", | |
| 118 "getFirstElementByTagAndClassName" | |
| 119 ]; | |
| 120 | |
| 121 MochiKit.DOM.EXPORT_OK = [ | |
| 122 "domConverters" | |
| 123 ]; | |
| 124 | |
| 125 MochiKit.DOM.DEPRECATED = [ | |
| 126 ['computedStyle', 'MochiKit.Style.getStyle', '1.4'], | |
| 127 /** @id MochiKit.DOM.elementDimensions */ | |
| 128 ['elementDimensions', 'MochiKit.Style.getElementDimensions', '1.4'], | |
| 129 /** @id MochiKit.DOM.elementPosition */ | |
| 130 ['elementPosition', 'MochiKit.Style.getElementPosition', '1.4'], | |
| 131 ['hideElement', 'MochiKit.Style.hideElement', '1.4'], | |
| 132 /** @id MochiKit.DOM.setElementDimensions */ | |
| 133 ['setElementDimensions', 'MochiKit.Style.setElementDimensions', '1.4'], | |
| 134 /** @id MochiKit.DOM.setElementPosition */ | |
| 135 ['setElementPosition', 'MochiKit.Style.setElementPosition', '1.4'], | |
| 136 ['setDisplayForElement', 'MochiKit.Style.setDisplayForElement', '1.4'], | |
| 137 /** @id MochiKit.DOM.setOpacity */ | |
| 138 ['setOpacity', 'MochiKit.Style.setOpacity', '1.4'], | |
| 139 ['showElement', 'MochiKit.Style.showElement', '1.4'], | |
| 140 /** @id MochiKit.DOM.Coordinates */ | |
| 141 ['Coordinates', 'MochiKit.Style.Coordinates', '1.4'], // FIXME: broken | |
| 142 /** @id MochiKit.DOM.Dimensions */ | |
| 143 ['Dimensions', 'MochiKit.Style.Dimensions', '1.4'] // FIXME: broken | |
| 144 ]; | |
| 145 | |
| 146 /** @id MochiKit.DOM.getViewportDimensions */ | |
| 147 MochiKit.DOM.getViewportDimensions = new Function('' + | |
| 148 'if (!MochiKit["Style"]) {' + | |
| 149 ' throw new Error("This function has been deprecated and depends on MochiKit.Style.");' + | |
| 150 '}' + | |
| 151 'return MochiKit.Style.getViewportDimensions.apply(this, arguments);'); | |
| 152 | |
| 153 MochiKit.Base.update(MochiKit.DOM, { | |
| 154 | |
| 155 /** @id MochiKit.DOM.currentWindow */ | |
| 156 currentWindow: function () { | |
| 157 return MochiKit.DOM._window; | |
| 158 }, | |
| 159 | |
| 160 /** @id MochiKit.DOM.currentDocument */ | |
| 161 currentDocument: function () { | |
| 162 return MochiKit.DOM._document; | |
| 163 }, | |
| 164 | |
| 165 /** @id MochiKit.DOM.withWindow */ | |
| 166 withWindow: function (win, func) { | |
| 167 var self = MochiKit.DOM; | |
| 168 var oldDoc = self._document; | |
| 169 var oldWin = self._window; | |
| 170 var rval; | |
| 171 try { | |
| 172 self._window = win; | |
| 173 self._document = win.document; | |
| 174 rval = func(); | |
| 175 } catch (e) { | |
| 176 self._window = oldWin; | |
| 177 self._document = oldDoc; | |
| 178 throw e; | |
| 179 } | |
| 180 self._window = oldWin; | |
| 181 self._document = oldDoc; | |
| 182 return rval; | |
| 183 }, | |
| 184 | |
| 185 /** @id MochiKit.DOM.formContents */ | |
| 186 formContents: function (elem/* = document.body */) { | |
| 187 var names = []; | |
| 188 var values = []; | |
| 189 var m = MochiKit.Base; | |
| 190 var self = MochiKit.DOM; | |
| 191 if (typeof(elem) == "undefined" || elem === null) { | |
| 192 elem = self._document.body; | |
| 193 } else { | |
| 194 elem = self.getElement(elem); | |
| 195 } | |
| 196 m.nodeWalk(elem, function (elem) { | |
| 197 var name = elem.name; | |
| 198 if (m.isNotEmpty(name)) { | |
| 199 var tagName = elem.tagName.toUpperCase(); | |
| 200 if (tagName === "INPUT" | |
| 201 && (elem.type == "radio" || elem.type == "checkbox") | |
| 202 && !elem.checked | |
| 203 ) { | |
| 204 return null; | |
| 205 } | |
| 206 if (tagName === "SELECT") { | |
| 207 if (elem.type == "select-one") { | |
| 208 if (elem.selectedIndex >= 0) { | |
| 209 var opt = elem.options[elem.selectedIndex]; | |
| 210 var v = opt.value; | |
| 211 if (!v) { | |
| 212 var h = opt.outerHTML; | |
| 213 // internet explorer sure does suck. | |
| 214 if (h && !h.match(/^[^>]+\svalue\s*=/i)) { | |
| 215 v = opt.text; | |
| 216 } | |
| 217 } | |
| 218 names.push(name); | |
| 219 values.push(v); | |
| 220 return null; | |
| 221 } | |
| 222 // no form elements? | |
| 223 names.push(name); | |
| 224 values.push(""); | |
| 225 return null; | |
| 226 } else { | |
| 227 var opts = elem.options; | |
| 228 if (!opts.length) { | |
| 229 names.push(name); | |
| 230 values.push(""); | |
| 231 return null; | |
| 232 } | |
| 233 for (var i = 0; i < opts.length; i++) { | |
| 234 var opt = opts[i]; | |
| 235 if (!opt.selected) { | |
| 236 continue; | |
| 237 } | |
| 238 var v = opt.value; | |
| 239 if (!v) { | |
| 240 var h = opt.outerHTML; | |
| 241 // internet explorer sure does suck. | |
| 242 if (h && !h.match(/^[^>]+\svalue\s*=/i)) { | |
| 243 v = opt.text; | |
| 244 } | |
| 245 } | |
| 246 names.push(name); | |
| 247 values.push(v); | |
| 248 } | |
| 249 return null; | |
| 250 } | |
| 251 } | |
| 252 if (tagName === "FORM" || tagName === "P" || tagName === "SPAN" | |
| 253 || tagName === "DIV" | |
| 254 ) { | |
| 255 return elem.childNodes; | |
| 256 } | |
| 257 names.push(name); | |
| 258 values.push(elem.value || ''); | |
| 259 return null; | |
| 260 } | |
| 261 return elem.childNodes; | |
| 262 }); | |
| 263 return [names, values]; | |
| 264 }, | |
| 265 | |
| 266 /** @id MochiKit.DOM.withDocument */ | |
| 267 withDocument: function (doc, func) { | |
| 268 var self = MochiKit.DOM; | |
| 269 var oldDoc = self._document; | |
| 270 var rval; | |
| 271 try { | |
| 272 self._document = doc; | |
| 273 rval = func(); | |
| 274 } catch (e) { | |
| 275 self._document = oldDoc; | |
| 276 throw e; | |
| 277 } | |
| 278 self._document = oldDoc; | |
| 279 return rval; | |
| 280 }, | |
| 281 | |
| 282 /** @id MochiKit.DOM.registerDOMConverter */ | |
| 283 registerDOMConverter: function (name, check, wrap, /* optional */override) { | |
| 284 MochiKit.DOM.domConverters.register(name, check, wrap, override); | |
| 285 }, | |
| 286 | |
| 287 /** @id MochiKit.DOM.coerceToDOM */ | |
| 288 coerceToDOM: function (node, ctx) { | |
| 289 var m = MochiKit.Base; | |
| 290 var im = MochiKit.Iter; | |
| 291 var self = MochiKit.DOM; | |
| 292 if (im) { | |
| 293 var iter = im.iter; | |
| 294 var repeat = im.repeat; | |
| 295 var map = m.map; | |
| 296 } | |
| 297 var domConverters = self.domConverters; | |
| 298 var coerceToDOM = arguments.callee; | |
| 299 var NotFound = m.NotFound; | |
| 300 while (true) { | |
| 301 if (typeof(node) == 'undefined' || node === null) { | |
| 302 return null; | |
| 303 } | |
| 304 // this is a safari childNodes object, avoiding crashes w/ attr | |
| 305 // lookup | |
| 306 if (typeof(node) == "function" && | |
| 307 typeof(node.length) == "number" && | |
| 308 !(node instanceof Function)) { | |
| 309 node = im.list(node); | |
| 310 } | |
| 311 if (typeof(node.nodeType) != 'undefined' && node.nodeType > 0) { | |
| 312 return node; | |
| 313 } | |
| 314 if (typeof(node) == 'number' || typeof(node) == 'boolean') { | |
| 315 node = node.toString(); | |
| 316 // FALL THROUGH | |
| 317 } | |
| 318 if (typeof(node) == 'string') { | |
| 319 return self._document.createTextNode(node); | |
| 320 } | |
| 321 if (typeof(node.__dom__) == 'function') { | |
| 322 node = node.__dom__(ctx); | |
| 323 continue; | |
| 324 } | |
| 325 if (typeof(node.dom) == 'function') { | |
| 326 node = node.dom(ctx); | |
| 327 continue; | |
| 328 } | |
| 329 if (typeof(node) == 'function') { | |
| 330 node = node.apply(ctx, [ctx]); | |
| 331 continue; | |
| 332 } | |
| 333 | |
| 334 if (im) { | |
| 335 // iterable | |
| 336 var iterNodes = null; | |
| 337 try { | |
| 338 iterNodes = iter(node); | |
| 339 } catch (e) { | |
| 340 // pass | |
| 341 } | |
| 342 if (iterNodes) { | |
| 343 return map(coerceToDOM, iterNodes, repeat(ctx)); | |
| 344 } | |
| 345 } | |
| 346 | |
| 347 // adapter | |
| 348 try { | |
| 349 node = domConverters.match(node, ctx); | |
| 350 continue; | |
| 351 } catch (e) { | |
| 352 if (e != NotFound) { | |
| 353 throw e; | |
| 354 } | |
| 355 } | |
| 356 | |
| 357 // fallback | |
| 358 return self._document.createTextNode(node.toString()); | |
| 359 } | |
| 360 // mozilla warnings aren't too bright | |
| 361 return undefined; | |
| 362 }, | |
| 363 | |
| 364 /** @id MochiKit.DOM.isChildNode */ | |
| 365 isChildNode: function (node, maybeparent) { | |
| 366 var self = MochiKit.DOM; | |
| 367 if (typeof(node) == "string") { | |
| 368 node = self.getElement(node); | |
| 369 } | |
| 370 if (typeof(maybeparent) == "string") { | |
| 371 maybeparent = self.getElement(maybeparent); | |
| 372 } | |
| 373 if (node === maybeparent) { | |
| 374 return true; | |
| 375 } | |
| 376 while (node && node.tagName.toUpperCase() != "BODY") { | |
| 377 node = node.parentNode; | |
| 378 if (node === maybeparent) { | |
| 379 return true; | |
| 380 } | |
| 381 } | |
| 382 return false; | |
| 383 }, | |
| 384 | |
| 385 /** @id MochiKit.DOM.setNodeAttribute */ | |
| 386 setNodeAttribute: function (node, attr, value) { | |
| 387 var o = {}; | |
| 388 o[attr] = value; | |
| 389 try { | |
| 390 return MochiKit.DOM.updateNodeAttributes(node, o); | |
| 391 } catch (e) { | |
| 392 // pass | |
| 393 } | |
| 394 return null; | |
| 395 }, | |
| 396 | |
| 397 /** @id MochiKit.DOM.getNodeAttribute */ | |
| 398 getNodeAttribute: function (node, attr) { | |
| 399 var self = MochiKit.DOM; | |
| 400 var rename = self.attributeArray.renames[attr]; | |
| 401 node = self.getElement(node); | |
| 402 try { | |
| 403 if (rename) { | |
| 404 return node[rename]; | |
| 405 } | |
| 406 return node.getAttribute(attr); | |
| 407 } catch (e) { | |
| 408 // pass | |
| 409 } | |
| 410 return null; | |
| 411 }, | |
| 412 | |
| 413 /** @id MochiKit.DOM.removeNodeAttribute */ | |
| 414 removeNodeAttribute: function (node, attr) { | |
| 415 var self = MochiKit.DOM; | |
| 416 var rename = self.attributeArray.renames[attr]; | |
| 417 node = self.getElement(node); | |
| 418 try { | |
| 419 if (rename) { | |
| 420 return node[rename]; | |
| 421 } | |
| 422 return node.removeAttribute(attr); | |
| 423 } catch (e) { | |
| 424 // pass | |
| 425 } | |
| 426 return null; | |
| 427 }, | |
| 428 | |
| 429 /** @id MochiKit.DOM.updateNodeAttributes */ | |
| 430 updateNodeAttributes: function (node, attrs) { | |
| 431 var elem = node; | |
| 432 var self = MochiKit.DOM; | |
| 433 if (typeof(node) == 'string') { | |
| 434 elem = self.getElement(node); | |
| 435 } | |
| 436 if (attrs) { | |
| 437 var updatetree = MochiKit.Base.updatetree; | |
| 438 if (self.attributeArray.compliant) { | |
| 439 // not IE, good. | |
| 440 for (var k in attrs) { | |
| 441 var v = attrs[k]; | |
| 442 if (typeof(v) == 'object' && typeof(elem[k]) == 'object') { | |
| 443 if (k == "style" && MochiKit.Style) { | |
| 444 MochiKit.Style.setStyle(elem, v); | |
| 445 } else { | |
| 446 updatetree(elem[k], v); | |
| 447 } | |
| 448 } else if (k.substring(0, 2) == "on") { | |
| 449 if (typeof(v) == "string") { | |
| 450 v = new Function(v); | |
| 451 } | |
| 452 elem[k] = v; | |
| 453 } else { | |
| 454 elem.setAttribute(k, v); | |
| 455 } | |
| 456 } | |
| 457 } else { | |
| 458 // IE is insane in the membrane | |
| 459 var renames = self.attributeArray.renames; | |
| 460 for (var k in attrs) { | |
| 461 v = attrs[k]; | |
| 462 var renamed = renames[k]; | |
| 463 if (k == "style" && typeof(v) == "string") { | |
| 464 elem.style.cssText = v; | |
| 465 } else if (typeof(renamed) == "string") { | |
| 466 elem[renamed] = v; | |
| 467 } else if (typeof(elem[k]) == 'object' | |
| 468 && typeof(v) == 'object') { | |
| 469 if (k == "style" && MochiKit.Style) { | |
| 470 MochiKit.Style.setStyle(elem, v); | |
| 471 } else { | |
| 472 updatetree(elem[k], v); | |
| 473 } | |
| 474 } else if (k.substring(0, 2) == "on") { | |
| 475 if (typeof(v) == "string") { | |
| 476 v = new Function(v); | |
| 477 } | |
| 478 elem[k] = v; | |
| 479 } else { | |
| 480 elem.setAttribute(k, v); | |
| 481 } | |
| 482 } | |
| 483 } | |
| 484 } | |
| 485 return elem; | |
| 486 }, | |
| 487 | |
| 488 /** @id MochiKit.DOM.appendChildNodes */ | |
| 489 appendChildNodes: function (node/*, nodes...*/) { | |
| 490 var elem = node; | |
| 491 var self = MochiKit.DOM; | |
| 492 if (typeof(node) == 'string') { | |
| 493 elem = self.getElement(node); | |
| 494 } | |
| 495 var nodeStack = [ | |
| 496 self.coerceToDOM( | |
| 497 MochiKit.Base.extend(null, arguments, 1), | |
| 498 elem | |
| 499 ) | |
| 500 ]; | |
| 501 var concat = MochiKit.Base.concat; | |
| 502 while (nodeStack.length) { | |
| 503 var n = nodeStack.shift(); | |
| 504 if (typeof(n) == 'undefined' || n === null) { | |
| 505 // pass | |
| 506 } else if (typeof(n.nodeType) == 'number') { | |
| 507 elem.appendChild(n); | |
| 508 } else { | |
| 509 nodeStack = concat(n, nodeStack); | |
| 510 } | |
| 511 } | |
| 512 return elem; | |
| 513 }, | |
| 514 | |
| 515 | |
| 516 /** @id MochiKit.DOM.insertSiblingNodesBefore */ | |
| 517 insertSiblingNodesBefore: function (node/*, nodes...*/) { | |
| 518 var elem = node; | |
| 519 var self = MochiKit.DOM; | |
| 520 if (typeof(node) == 'string') { | |
| 521 elem = self.getElement(node); | |
| 522 } | |
| 523 var nodeStack = [ | |
| 524 self.coerceToDOM( | |
| 525 MochiKit.Base.extend(null, arguments, 1), | |
| 526 elem | |
| 527 ) | |
| 528 ]; | |
| 529 var parentnode = elem.parentNode; | |
| 530 var concat = MochiKit.Base.concat; | |
| 531 while (nodeStack.length) { | |
| 532 var n = nodeStack.shift(); | |
| 533 if (typeof(n) == 'undefined' || n === null) { | |
| 534 // pass | |
| 535 } else if (typeof(n.nodeType) == 'number') { | |
| 536 parentnode.insertBefore(n, elem); | |
| 537 } else { | |
| 538 nodeStack = concat(n, nodeStack); | |
| 539 } | |
| 540 } | |
| 541 return parentnode; | |
| 542 }, | |
| 543 | |
| 544 /** @id MochiKit.DOM.insertSiblingNodesAfter */ | |
| 545 insertSiblingNodesAfter: function (node/*, nodes...*/) { | |
| 546 var elem = node; | |
| 547 var self = MochiKit.DOM; | |
| 548 | |
| 549 if (typeof(node) == 'string') { | |
| 550 elem = self.getElement(node); | |
| 551 } | |
| 552 var nodeStack = [ | |
| 553 self.coerceToDOM( | |
| 554 MochiKit.Base.extend(null, arguments, 1), | |
| 555 elem | |
| 556 ) | |
| 557 ]; | |
| 558 | |
| 559 if (elem.nextSibling) { | |
| 560 return self.insertSiblingNodesBefore(elem.nextSibling, nodeStack); | |
| 561 } | |
| 562 else { | |
| 563 return self.appendChildNodes(elem.parentNode, nodeStack); | |
| 564 } | |
| 565 }, | |
| 566 | |
| 567 /** @id MochiKit.DOM.replaceChildNodes */ | |
| 568 replaceChildNodes: function (node/*, nodes...*/) { | |
| 569 var elem = node; | |
| 570 var self = MochiKit.DOM; | |
| 571 if (typeof(node) == 'string') { | |
| 572 elem = self.getElement(node); | |
| 573 arguments[0] = elem; | |
| 574 } | |
| 575 var child; | |
| 576 while ((child = elem.firstChild)) { | |
| 577 elem.removeChild(child); | |
| 578 } | |
| 579 if (arguments.length < 2) { | |
| 580 return elem; | |
| 581 } else { | |
| 582 return self.appendChildNodes.apply(this, arguments); | |
| 583 } | |
| 584 }, | |
| 585 | |
| 586 /** @id MochiKit.DOM.createDOM */ | |
| 587 createDOM: function (name, attrs/*, nodes... */) { | |
| 588 var elem; | |
| 589 var self = MochiKit.DOM; | |
| 590 var m = MochiKit.Base; | |
| 591 if (typeof(attrs) == "string" || typeof(attrs) == "number") { | |
| 592 var args = m.extend([name, null], arguments, 1); | |
| 593 return arguments.callee.apply(this, args); | |
| 594 } | |
| 595 if (typeof(name) == 'string') { | |
| 596 // Internet Explorer is dumb | |
| 597 var xhtml = self._xhtml; | |
| 598 if (attrs && !self.attributeArray.compliant) { | |
| 599 // http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/name_2.asp | |
| 600 var contents = ""; | |
| 601 if ('name' in attrs) { | |
| 602 contents += ' name="' + self.escapeHTML(attrs.name) + '"'; | |
| 603 } | |
| 604 if (name == 'input' && 'type' in attrs) { | |
| 605 contents += ' type="' + self.escapeHTML(attrs.type) + '"'; | |
| 606 } | |
| 607 if (contents) { | |
| 608 name = "<" + name + contents + ">"; | |
| 609 xhtml = false; | |
| 610 } | |
| 611 } | |
| 612 var d = self._document; | |
| 613 if (xhtml && d === document) { | |
| 614 elem = d.createElementNS("http://www.w3.org/1999/xhtml", name); | |
| 615 } else { | |
| 616 elem = d.createElement(name); | |
| 617 } | |
| 618 } else { | |
| 619 elem = name; | |
| 620 } | |
| 621 if (attrs) { | |
| 622 self.updateNodeAttributes(elem, attrs); | |
| 623 } | |
| 624 if (arguments.length <= 2) { | |
| 625 return elem; | |
| 626 } else { | |
| 627 var args = m.extend([elem], arguments, 2); | |
| 628 return self.appendChildNodes.apply(this, args); | |
| 629 } | |
| 630 }, | |
| 631 | |
| 632 /** @id MochiKit.DOM.createDOMFunc */ | |
| 633 createDOMFunc: function (/* tag, attrs, *nodes */) { | |
| 634 var m = MochiKit.Base; | |
| 635 return m.partial.apply( | |
| 636 this, | |
| 637 m.extend([MochiKit.DOM.createDOM], arguments) | |
| 638 ); | |
| 639 }, | |
| 640 | |
| 641 /** @id MochiKit.DOM.removeElement */ | |
| 642 removeElement: function (elem) { | |
| 643 var e = MochiKit.DOM.getElement(elem); | |
| 644 e.parentNode.removeChild(e); | |
| 645 return e; | |
| 646 }, | |
| 647 | |
| 648 /** @id MochiKit.DOM.swapDOM */ | |
| 649 swapDOM: function (dest, src) { | |
| 650 var self = MochiKit.DOM; | |
| 651 dest = self.getElement(dest); | |
| 652 var parent = dest.parentNode; | |
| 653 if (src) { | |
| 654 src = self.getElement(src); | |
| 655 parent.replaceChild(src, dest); | |
| 656 } else { | |
| 657 parent.removeChild(dest); | |
| 658 } | |
| 659 return src; | |
| 660 }, | |
| 661 | |
| 662 /** @id MochiKit.DOM.getElement */ | |
| 663 getElement: function (id) { | |
| 664 var self = MochiKit.DOM; | |
| 665 if (arguments.length == 1) { | |
| 666 return ((typeof(id) == "string") ? | |
| 667 self._document.getElementById(id) : id); | |
| 668 } else { | |
| 669 return MochiKit.Base.map(self.getElement, arguments); | |
| 670 } | |
| 671 }, | |
| 672 | |
| 673 /** @id MochiKit.DOM.getElementsByTagAndClassName */ | |
| 674 getElementsByTagAndClassName: function (tagName, className, | |
| 675 /* optional */parent) { | |
| 676 var self = MochiKit.DOM; | |
| 677 if (typeof(tagName) == 'undefined' || tagName === null) { | |
| 678 tagName = '*'; | |
| 679 } | |
| 680 if (typeof(parent) == 'undefined' || parent === null) { | |
| 681 parent = self._document; | |
| 682 } | |
| 683 parent = self.getElement(parent); | |
| 684 var children = (parent.getElementsByTagName(tagName) | |
| 685 || self._document.all); | |
| 686 if (typeof(className) == 'undefined' || className === null) { | |
| 687 return MochiKit.Base.extend(null, children); | |
| 688 } | |
| 689 | |
| 690 var elements = []; | |
| 691 for (var i = 0; i < children.length; i++) { | |
| 692 var child = children[i]; | |
| 693 var cls = child.className; | |
| 694 if (!cls) { | |
| 695 continue; | |
| 696 } | |
| 697 var classNames = cls.split(' '); | |
| 698 for (var j = 0; j < classNames.length; j++) { | |
| 699 if (classNames[j] == className) { | |
| 700 elements.push(child); | |
| 701 break; | |
| 702 } | |
| 703 } | |
| 704 } | |
| 705 | |
| 706 return elements; | |
| 707 }, | |
| 708 | |
| 709 _newCallStack: function (path, once) { | |
| 710 var rval = function () { | |
| 711 var callStack = arguments.callee.callStack; | |
| 712 for (var i = 0; i < callStack.length; i++) { | |
| 713 if (callStack[i].apply(this, arguments) === false) { | |
| 714 break; | |
| 715 } | |
| 716 } | |
| 717 if (once) { | |
| 718 try { | |
| 719 this[path] = null; | |
| 720 } catch (e) { | |
| 721 // pass | |
| 722 } | |
| 723 } | |
| 724 }; | |
| 725 rval.callStack = []; | |
| 726 return rval; | |
| 727 }, | |
| 728 | |
| 729 /** @id MochiKit.DOM.addToCallStack */ | |
| 730 addToCallStack: function (target, path, func, once) { | |
| 731 var self = MochiKit.DOM; | |
| 732 var existing = target[path]; | |
| 733 var regfunc = existing; | |
| 734 if (!(typeof(existing) == 'function' | |
| 735 && typeof(existing.callStack) == "object" | |
| 736 && existing.callStack !== null)) { | |
| 737 regfunc = self._newCallStack(path, once); | |
| 738 if (typeof(existing) == 'function') { | |
| 739 regfunc.callStack.push(existing); | |
| 740 } | |
| 741 target[path] = regfunc; | |
| 742 } | |
| 743 regfunc.callStack.push(func); | |
| 744 }, | |
| 745 | |
| 746 /** @id MochiKit.DOM.addLoadEvent */ | |
| 747 addLoadEvent: function (func) { | |
| 748 var self = MochiKit.DOM; | |
| 749 self.addToCallStack(self._window, "onload", func, true); | |
| 750 | |
| 751 }, | |
| 752 | |
| 753 /** @id MochiKit.DOM.focusOnLoad */ | |
| 754 focusOnLoad: function (element) { | |
| 755 var self = MochiKit.DOM; | |
| 756 self.addLoadEvent(function () { | |
| 757 element = self.getElement(element); | |
| 758 if (element) { | |
| 759 element.focus(); | |
| 760 } | |
| 761 }); | |
| 762 }, | |
| 763 | |
| 764 /** @id MochiKit.DOM.setElementClass */ | |
| 765 setElementClass: function (element, className) { | |
| 766 var self = MochiKit.DOM; | |
| 767 var obj = self.getElement(element); | |
| 768 if (self.attributeArray.compliant) { | |
| 769 obj.setAttribute("class", className); | |
| 770 } else { | |
| 771 obj.setAttribute("className", className); | |
| 772 } | |
| 773 }, | |
| 774 | |
| 775 /** @id MochiKit.DOM.toggleElementClass */ | |
| 776 toggleElementClass: function (className/*, element... */) { | |
| 777 var self = MochiKit.DOM; | |
| 778 for (var i = 1; i < arguments.length; i++) { | |
| 779 var obj = self.getElement(arguments[i]); | |
| 780 if (!self.addElementClass(obj, className)) { | |
| 781 self.removeElementClass(obj, className); | |
| 782 } | |
| 783 } | |
| 784 }, | |
| 785 | |
| 786 /** @id MochiKit.DOM.addElementClass */ | |
| 787 addElementClass: function (element, className) { | |
| 788 var self = MochiKit.DOM; | |
| 789 var obj = self.getElement(element); | |
| 790 var cls = obj.className; | |
| 791 // trivial case, no className yet | |
| 792 if (cls == undefined || cls.length === 0) { | |
| 793 self.setElementClass(obj, className); | |
| 794 return true; | |
| 795 } | |
| 796 // the other trivial case, already set as the only class | |
| 797 if (cls == className) { | |
| 798 return false; | |
| 799 } | |
| 800 var classes = cls.split(" "); | |
| 801 for (var i = 0; i < classes.length; i++) { | |
| 802 // already present | |
| 803 if (classes[i] == className) { | |
| 804 return false; | |
| 805 } | |
| 806 } | |
| 807 // append class | |
| 808 self.setElementClass(obj, cls + " " + className); | |
| 809 return true; | |
| 810 }, | |
| 811 | |
| 812 /** @id MochiKit.DOM.removeElementClass */ | |
| 813 removeElementClass: function (element, className) { | |
| 814 var self = MochiKit.DOM; | |
| 815 var obj = self.getElement(element); | |
| 816 var cls = obj.className; | |
| 817 // trivial case, no className yet | |
| 818 if (cls == undefined || cls.length === 0) { | |
| 819 return false; | |
| 820 } | |
| 821 // other trivial case, set only to className | |
| 822 if (cls == className) { | |
| 823 self.setElementClass(obj, ""); | |
| 824 return true; | |
| 825 } | |
| 826 var classes = cls.split(" "); | |
| 827 for (var i = 0; i < classes.length; i++) { | |
| 828 // already present | |
| 829 if (classes[i] == className) { | |
| 830 // only check sane case where the class is used once | |
| 831 classes.splice(i, 1); | |
| 832 self.setElementClass(obj, classes.join(" ")); | |
| 833 return true; | |
| 834 } | |
| 835 } | |
| 836 // not found | |
| 837 return false; | |
| 838 }, | |
| 839 | |
| 840 /** @id MochiKit.DOM.swapElementClass */ | |
| 841 swapElementClass: function (element, fromClass, toClass) { | |
| 842 var obj = MochiKit.DOM.getElement(element); | |
| 843 var res = MochiKit.DOM.removeElementClass(obj, fromClass); | |
| 844 if (res) { | |
| 845 MochiKit.DOM.addElementClass(obj, toClass); | |
| 846 } | |
| 847 return res; | |
| 848 }, | |
| 849 | |
| 850 /** @id MochiKit.DOM.hasElementClass */ | |
| 851 hasElementClass: function (element, className/*...*/) { | |
| 852 var obj = MochiKit.DOM.getElement(element); | |
| 853 var cls = obj.className; | |
| 854 if (!cls) { | |
| 855 return false; | |
| 856 } | |
| 857 var classes = cls.split(" "); | |
| 858 for (var i = 1; i < arguments.length; i++) { | |
| 859 var good = false; | |
| 860 for (var j = 0; j < classes.length; j++) { | |
| 861 if (classes[j] == arguments[i]) { | |
| 862 good = true; | |
| 863 break; | |
| 864 } | |
| 865 } | |
| 866 if (!good) { | |
| 867 return false; | |
| 868 } | |
| 869 } | |
| 870 return true; | |
| 871 }, | |
| 872 | |
| 873 /** @id MochiKit.DOM.escapeHTML */ | |
| 874 escapeHTML: function (s) { | |
| 875 return s.replace(/&/g, "&" | |
| 876 ).replace(/"/g, """ | |
| 877 ).replace(/</g, "<" | |
| 878 ).replace(/>/g, ">"); | |
| 879 }, | |
| 880 | |
| 881 /** @id MochiKit.DOM.toHTML */ | |
| 882 toHTML: function (dom) { | |
| 883 return MochiKit.DOM.emitHTML(dom).join(""); | |
| 884 }, | |
| 885 | |
| 886 /** @id MochiKit.DOM.emitHTML */ | |
| 887 emitHTML: function (dom, /* optional */lst) { | |
| 888 if (typeof(lst) == 'undefined' || lst === null) { | |
| 889 lst = []; | |
| 890 } | |
| 891 // queue is the call stack, we're doing this non-recursively | |
| 892 var queue = [dom]; | |
| 893 var self = MochiKit.DOM; | |
| 894 var escapeHTML = self.escapeHTML; | |
| 895 var attributeArray = self.attributeArray; | |
| 896 while (queue.length) { | |
| 897 dom = queue.pop(); | |
| 898 if (typeof(dom) == 'string') { | |
| 899 lst.push(dom); | |
| 900 } else if (dom.nodeType == 1) { | |
| 901 // we're not using higher order stuff here | |
| 902 // because safari has heisenbugs.. argh. | |
| 903 // | |
| 904 // I think it might have something to do with | |
| 905 // garbage collection and function calls. | |
| 906 lst.push('<' + dom.tagName.toLowerCase()); | |
| 907 var attributes = []; | |
| 908 var domAttr = attributeArray(dom); | |
| 909 for (var i = 0; i < domAttr.length; i++) { | |
| 910 var a = domAttr[i]; | |
| 911 attributes.push([ | |
| 912 " ", | |
| 913 a.name, | |
| 914 '="', | |
| 915 escapeHTML(a.value), | |
| 916 '"' | |
| 917 ]); | |
| 918 } | |
| 919 attributes.sort(); | |
| 920 for (i = 0; i < attributes.length; i++) { | |
| 921 var attrs = attributes[i]; | |
| 922 for (var j = 0; j < attrs.length; j++) { | |
| 923 lst.push(attrs[j]); | |
| 924 } | |
| 925 } | |
| 926 if (dom.hasChildNodes()) { | |
| 927 lst.push(">"); | |
| 928 // queue is the FILO call stack, so we put the close tag | |
| 929 // on first | |
| 930 queue.push("</" + dom.tagName.toLowerCase() + ">"); | |
| 931 var cnodes = dom.childNodes; | |
| 932 for (i = cnodes.length - 1; i >= 0; i--) { | |
| 933 queue.push(cnodes[i]); | |
| 934 } | |
| 935 } else { | |
| 936 lst.push('/>'); | |
| 937 } | |
| 938 } else if (dom.nodeType == 3) { | |
| 939 lst.push(escapeHTML(dom.nodeValue)); | |
| 940 } | |
| 941 } | |
| 942 return lst; | |
| 943 }, | |
| 944 | |
| 945 /** @id MochiKit.DOM.scrapeText */ | |
| 946 scrapeText: function (node, /* optional */asArray) { | |
| 947 var rval = []; | |
| 948 (function (node) { | |
| 949 var cn = node.childNodes; | |
| 950 if (cn) { | |
| 951 for (var i = 0; i < cn.length; i++) { | |
| 952 arguments.callee.call(this, cn[i]); | |
| 953 } | |
| 954 } | |
| 955 var nodeValue = node.nodeValue; | |
| 956 if (typeof(nodeValue) == 'string') { | |
| 957 rval.push(nodeValue); | |
| 958 } | |
| 959 })(MochiKit.DOM.getElement(node)); | |
| 960 if (asArray) { | |
| 961 return rval; | |
| 962 } else { | |
| 963 return rval.join(""); | |
| 964 } | |
| 965 }, | |
| 966 | |
| 967 /** @id MochiKit.DOM.removeEmptyTextNodes */ | |
| 968 removeEmptyTextNodes: function (element) { | |
| 969 element = MochiKit.DOM.getElement(element); | |
| 970 for (var i = 0; i < element.childNodes.length; i++) { | |
| 971 var node = element.childNodes[i]; | |
| 972 if (node.nodeType == 3 && !/\S/.test(node.nodeValue)) { | |
| 973 node.parentNode.removeChild(node); | |
| 974 } | |
| 975 } | |
| 976 }, | |
| 977 | |
| 978 /** @id MochiKit.DOM.makeClipping */ | |
| 979 makeClipping: function (element) { | |
| 980 element = MochiKit.DOM.getElement(element); | |
| 981 var oldOverflow = element.style.overflow; | |
| 982 if ((MochiKit.Style.getStyle(element, 'overflow') || 'visible') != 'hidden') { | |
| 983 element.style.overflow = 'hidden'; | |
| 984 } | |
| 985 return oldOverflow; | |
| 986 }, | |
| 987 | |
| 988 /** @id MochiKit.DOM.undoClipping */ | |
| 989 undoClipping: function (element, overflow) { | |
| 990 element = MochiKit.DOM.getElement(element); | |
| 991 if (!overflow) { | |
| 992 return; | |
| 993 } | |
| 994 element.style.overflow = overflow; | |
| 995 }, | |
| 996 | |
| 997 /** @id MochiKit.DOM.makePositioned */ | |
| 998 makePositioned: function (element) { | |
| 999 element = MochiKit.DOM.getElement(element); | |
| 1000 var pos = MochiKit.Style.getStyle(element, 'position'); | |
| 1001 if (pos == 'static' || !pos) { | |
| 1002 element.style.position = 'relative'; | |
| 1003 // Opera returns the offset relative to the positioning context, | |
| 1004 // when an element is position relative but top and left have | |
| 1005 // not been defined | |
| 1006 if (/Opera/.test(navigator.userAgent)) { | |
| 1007 element.style.top = 0; | |
| 1008 element.style.left = 0; | |
| 1009 } | |
| 1010 } | |
| 1011 }, | |
| 1012 | |
| 1013 /** @id MochiKit.DOM.undoPositioned */ | |
| 1014 undoPositioned: function (element) { | |
| 1015 element = MochiKit.DOM.getElement(element); | |
| 1016 if (element.style.position == 'relative') { | |
| 1017 element.style.position = element.style.top = element.style.left = element.style.bottom = element.style.right = ''; | |
| 1018 } | |
| 1019 }, | |
| 1020 | |
| 1021 /** @id MochiKit.DOM.getFirstElementByTagAndClassName */ | |
| 1022 getFirstElementByTagAndClassName: function (tagName, className, | |
| 1023 /* optional */parent) { | |
| 1024 var self = MochiKit.DOM; | |
| 1025 if (typeof(tagName) == 'undefined' || tagName === null) { | |
| 1026 tagName = '*'; | |
| 1027 } | |
| 1028 if (typeof(parent) == 'undefined' || parent === null) { | |
| 1029 parent = self._document; | |
| 1030 } | |
| 1031 parent = self.getElement(parent); | |
| 1032 var children = (parent.getElementsByTagName(tagName) | |
| 1033 || self._document.all); | |
| 1034 if (typeof(className) == 'undefined' || className === null) { | |
| 1035 return children[0]; | |
| 1036 } | |
| 1037 | |
| 1038 for (var i = 0; i < children.length; i++) { | |
| 1039 var child = children[i]; | |
| 1040 var classNames = child.className.split(' '); | |
| 1041 for (var j = 0; j < classNames.length; j++) { | |
| 1042 if (classNames[j] == className) { | |
| 1043 return child; | |
| 1044 } | |
| 1045 } | |
| 1046 } | |
| 1047 }, | |
| 1048 | |
| 1049 /** @id MochiKit.DOM.getFirstParentByTagAndClassName */ | |
| 1050 getFirstParentByTagAndClassName: function (elem, tagName, className) { | |
| 1051 var self = MochiKit.DOM; | |
| 1052 elem = self.getElement(elem); | |
| 1053 if (typeof(tagName) == 'undefined' || tagName === null) { | |
| 1054 tagName = '*'; | |
| 1055 } else { | |
| 1056 tagName = tagName.toUpperCase(); | |
| 1057 } | |
| 1058 if (typeof(className) == 'undefined' || className === null) { | |
| 1059 className = null; | |
| 1060 } | |
| 1061 | |
| 1062 var classList = ''; | |
| 1063 var curTagName = ''; | |
| 1064 while (elem && elem.tagName) { | |
| 1065 elem = elem.parentNode; | |
| 1066 if (tagName == '*' && className === null) { | |
| 1067 return elem; | |
| 1068 } | |
| 1069 classList = elem.className.split(' '); | |
| 1070 curTagName = elem.tagName.toUpperCase(); | |
| 1071 if (className === null && tagName == curTagName) { | |
| 1072 return elem; | |
| 1073 } else if (className !== null) { | |
| 1074 for (var i = 0; i < classList.length; i++) { | |
| 1075 if (tagName == '*' && classList[i] == className) { | |
| 1076 return elem; | |
| 1077 } else if (tagName == curTagName && classList[i] == className) { | |
| 1078 return elem; | |
| 1079 } | |
| 1080 } | |
| 1081 } | |
| 1082 } | |
| 1083 return elem; | |
| 1084 }, | |
| 1085 | |
| 1086 /** @id MochiKit.DOM.isParent */ | |
| 1087 isParent: function (child, element) { | |
| 1088 if (!child.parentNode || child == element) { | |
| 1089 return false; | |
| 1090 } | |
| 1091 | |
| 1092 if (child.parentNode == element) { | |
| 1093 return true; | |
| 1094 } | |
| 1095 | |
| 1096 return MochiKit.DOM.isParent(child.parentNode, element); | |
| 1097 }, | |
| 1098 | |
| 1099 __new__: function (win) { | |
| 1100 | |
| 1101 var m = MochiKit.Base; | |
| 1102 if (typeof(document) != "undefined") { | |
| 1103 this._document = document; | |
| 1104 var kXULNSURI = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"; | |
| 1105 this._xhtml = (document.documentElement && | |
| 1106 document.createElementNS && | |
| 1107 document.documentElement.namespaceURI === kXULNSURI); | |
| 1108 } else if (MochiKit.MockDOM) { | |
| 1109 this._document = MochiKit.MockDOM.document; | |
| 1110 } | |
| 1111 this._window = win; | |
| 1112 | |
| 1113 this.domConverters = new m.AdapterRegistry(); | |
| 1114 | |
| 1115 var __tmpElement = this._document.createElement("span"); | |
| 1116 var attributeArray; | |
| 1117 if (__tmpElement && __tmpElement.attributes && | |
| 1118 __tmpElement.attributes.length > 0) { | |
| 1119 // for braindead browsers (IE) that insert extra junk | |
| 1120 var filter = m.filter; | |
| 1121 attributeArray = function (node) { | |
| 1122 return filter(attributeArray.ignoreAttrFilter, node.attributes); | |
| 1123 }; | |
| 1124 attributeArray.ignoreAttr = {}; | |
| 1125 var attrs = __tmpElement.attributes; | |
| 1126 var ignoreAttr = attributeArray.ignoreAttr; | |
| 1127 for (var i = 0; i < attrs.length; i++) { | |
| 1128 var a = attrs[i]; | |
| 1129 ignoreAttr[a.name] = a.value; | |
| 1130 } | |
| 1131 attributeArray.ignoreAttrFilter = function (a) { | |
| 1132 return (attributeArray.ignoreAttr[a.name] != a.value); | |
| 1133 }; | |
| 1134 attributeArray.compliant = false; | |
| 1135 attributeArray.renames = { | |
| 1136 "class": "className", | |
| 1137 "checked": "defaultChecked", | |
| 1138 "usemap": "useMap", | |
| 1139 "for": "htmlFor", | |
| 1140 "readonly": "readOnly", | |
| 1141 "colspan": "colSpan", | |
| 1142 "bgcolor": "bgColor", | |
| 1143 "cellspacing": "cellSpacing", | |
| 1144 "cellpadding": "cellPadding" | |
| 1145 }; | |
| 1146 } else { | |
| 1147 attributeArray = function (node) { | |
| 1148 /*** | |
| 1149 | |
| 1150 Return an array of attributes for a given node, | |
| 1151 filtering out attributes that don't belong for | |
| 1152 that are inserted by "Certain Browsers". | |
| 1153 | |
| 1154 ***/ | |
| 1155 return node.attributes; | |
| 1156 }; | |
| 1157 attributeArray.compliant = true; | |
| 1158 attributeArray.renames = {}; | |
| 1159 } | |
| 1160 this.attributeArray = attributeArray; | |
| 1161 | |
| 1162 // FIXME: this really belongs in Base, and could probably be cleaner | |
| 1163 var _deprecated = function(fromModule, arr) { | |
| 1164 var modules = arr[1].split('.'); | |
| 1165 var str = ''; | |
| 1166 var obj = {}; | |
| 1167 | |
| 1168 str += 'if (!MochiKit.' + modules[1] + ') { throw new Error("'; | |
| 1169 str += 'This function has been deprecated and depends on MochiKit.'; | |
| 1170 str += modules[1] + '.");}'; | |
| 1171 str += 'return MochiKit.' + modules[1] + '.' + arr[0]; | |
| 1172 str += '.apply(this, arguments);'; | |
| 1173 | |
| 1174 obj[modules[2]] = new Function(str); | |
| 1175 MochiKit.Base.update(MochiKit[fromModule], obj); | |
| 1176 } | |
| 1177 for (var i; i < MochiKit.DOM.DEPRECATED.length; i++) { | |
| 1178 _deprecated('DOM', MochiKit.DOM.DEPRECATED[i]); | |
| 1179 } | |
| 1180 | |
| 1181 // shorthand for createDOM syntax | |
| 1182 var createDOMFunc = this.createDOMFunc; | |
| 1183 /** @id MochiKit.DOM.UL */ | |
| 1184 this.UL = createDOMFunc("ul"); | |
| 1185 /** @id MochiKit.DOM.OL */ | |
| 1186 this.OL = createDOMFunc("ol"); | |
| 1187 /** @id MochiKit.DOM.LI */ | |
| 1188 this.LI = createDOMFunc("li"); | |
| 1189 /** @id MochiKit.DOM.TD */ | |
| 1190 this.TD = createDOMFunc("td"); | |
| 1191 /** @id MochiKit.DOM.TR */ | |
| 1192 this.TR = createDOMFunc("tr"); | |
| 1193 /** @id MochiKit.DOM.TBODY */ | |
| 1194 this.TBODY = createDOMFunc("tbody"); | |
| 1195 /** @id MochiKit.DOM.THEAD */ | |
| 1196 this.THEAD = createDOMFunc("thead"); | |
| 1197 /** @id MochiKit.DOM.TFOOT */ | |
| 1198 this.TFOOT = createDOMFunc("tfoot"); | |
| 1199 /** @id MochiKit.DOM.TABLE */ | |
| 1200 this.TABLE = createDOMFunc("table"); | |
| 1201 /** @id MochiKit.DOM.TH */ | |
| 1202 this.TH = createDOMFunc("th"); | |
| 1203 /** @id MochiKit.DOM.INPUT */ | |
| 1204 this.INPUT = createDOMFunc("input"); | |
| 1205 /** @id MochiKit.DOM.SPAN */ | |
| 1206 this.SPAN = createDOMFunc("span"); | |
| 1207 /** @id MochiKit.DOM.A */ | |
| 1208 this.A = createDOMFunc("a"); | |
| 1209 /** @id MochiKit.DOM.DIV */ | |
| 1210 this.DIV = createDOMFunc("div"); | |
| 1211 /** @id MochiKit.DOM.IMG */ | |
| 1212 this.IMG = createDOMFunc("img"); | |
| 1213 /** @id MochiKit.DOM.BUTTON */ | |
| 1214 this.BUTTON = createDOMFunc("button"); | |
| 1215 /** @id MochiKit.DOM.TT */ | |
| 1216 this.TT = createDOMFunc("tt"); | |
| 1217 /** @id MochiKit.DOM.PRE */ | |
| 1218 this.PRE = createDOMFunc("pre"); | |
| 1219 /** @id MochiKit.DOM.H1 */ | |
| 1220 this.H1 = createDOMFunc("h1"); | |
| 1221 /** @id MochiKit.DOM.H2 */ | |
| 1222 this.H2 = createDOMFunc("h2"); | |
| 1223 /** @id MochiKit.DOM.H3 */ | |
| 1224 this.H3 = createDOMFunc("h3"); | |
| 1225 /** @id MochiKit.DOM.BR */ | |
| 1226 this.BR = createDOMFunc("br"); | |
| 1227 /** @id MochiKit.DOM.HR */ | |
| 1228 this.HR = createDOMFunc("hr"); | |
| 1229 /** @id MochiKit.DOM.LABEL */ | |
| 1230 this.LABEL = createDOMFunc("label"); | |
| 1231 /** @id MochiKit.DOM.TEXTAREA */ | |
| 1232 this.TEXTAREA = createDOMFunc("textarea"); | |
| 1233 /** @id MochiKit.DOM.FORM */ | |
| 1234 this.FORM = createDOMFunc("form"); | |
| 1235 /** @id MochiKit.DOM.P */ | |
| 1236 this.P = createDOMFunc("p"); | |
| 1237 /** @id MochiKit.DOM.SELECT */ | |
| 1238 this.SELECT = createDOMFunc("select"); | |
| 1239 /** @id MochiKit.DOM.OPTION */ | |
| 1240 this.OPTION = createDOMFunc("option"); | |
| 1241 /** @id MochiKit.DOM.OPTGROUP */ | |
| 1242 this.OPTGROUP = createDOMFunc("optgroup"); | |
| 1243 /** @id MochiKit.DOM.LEGEND */ | |
| 1244 this.LEGEND = createDOMFunc("legend"); | |
| 1245 /** @id MochiKit.DOM.FIELDSET */ | |
| 1246 this.FIELDSET = createDOMFunc("fieldset"); | |
| 1247 /** @id MochiKit.DOM.STRONG */ | |
| 1248 this.STRONG = createDOMFunc("strong"); | |
| 1249 /** @id MochiKit.DOM.CANVAS */ | |
| 1250 this.CANVAS = createDOMFunc("canvas"); | |
| 1251 | |
| 1252 /** @id MochiKit.DOM.$ */ | |
| 1253 this.$ = this.getElement; | |
| 1254 | |
| 1255 this.EXPORT_TAGS = { | |
| 1256 ":common": this.EXPORT, | |
| 1257 ":all": m.concat(this.EXPORT, this.EXPORT_OK) | |
| 1258 }; | |
| 1259 | |
| 1260 m.nameFunctions(this); | |
| 1261 | |
| 1262 } | |
| 1263 }); | |
| 1264 | |
| 1265 | |
| 1266 MochiKit.DOM.__new__(((typeof(window) == "undefined") ? this : window)); | |
| 1267 | |
| 1268 // | |
| 1269 // XXX: Internet Explorer blows | |
| 1270 // | |
| 1271 if (MochiKit.__export__) { | |
| 1272 withWindow = MochiKit.DOM.withWindow; | |
| 1273 withDocument = MochiKit.DOM.withDocument; | |
| 1274 } | |
| 1275 | |
| 1276 MochiKit.Base._exportSymbols(this, MochiKit.DOM); |
