PageRenderTime 103ms CodeModel.GetById 13ms app.highlight 75ms RepoModel.GetById 1ms app.codeStats 1ms

/static/scripts/IE7.js

https://bitbucket.org/cistrome/cistrome-harvard/
JavaScript | 1902 lines | 1762 code | 62 blank | 78 comment | 89 complexity | e79e55948fe2e50033db7da147b9b01c MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1// timestamp: Sun, 03 Feb 2008 19:26:22
   2/*
   3  IE7/IE8.js - copyright 2004-2008, Dean Edwards
   4  http://dean.edwards.name/IE7/
   5  http://www.opensource.org/licenses/mit-license.php
   6*/
   7
   8/* W3C compliance for Microsoft Internet Explorer */
   9
  10/* credits/thanks:
  11  Shaggy, Martijn Wargers, Jimmy Cerra, Mark D Anderson,
  12  Lars Dieckow, Erik Arvidsson, Gellért Gyuris, James Denny,
  13  Unknown W Brackets, Benjamin Westfarer, Rob Eberhardt,
  14  Bill Edney, Kevin Newman, James Crompton, Matthew Mastracci,
  15  Doug Wright, Richard York, Kenneth Kolano, MegaZone,
  16  Thomas Verelst, Mark 'Tarquin' Wilton-Jones, Rainer ?hlfors,
  17  David Zulaica, Ken Kolano, Kevin Newman
  18*/
  19
  20// =======================================================================
  21// TO DO
  22// =======================================================================
  23
  24// PNG - unclickable content
  25
  26// =======================================================================
  27// TEST/BUGGY
  28// =======================================================================
  29
  30// hr{margin:1em auto} (doesn't look right in IE5)
  31
  32(function() {
  33
  34IE7 = {
  35  toString: function(){return "IE7 version 2.0 (beta3)"}
  36};
  37var appVersion = IE7.appVersion = navigator.appVersion.match(/MSIE (\d\.\d)/)[1];
  38
  39if (/ie7_off/.test(top.location.search) || appVersion < 5) return;
  40
  41var Undefined = K();
  42var quirksMode = document.compatMode != "CSS1Compat";
  43var documentElement = document.documentElement, body, viewport;
  44var ANON = "!";
  45var HEADER = ":link{ie7-link:link}:visited{ie7-link:visited}";
  46
  47// -----------------------------------------------------------------------
  48// external
  49// -----------------------------------------------------------------------
  50
  51var RELATIVE = /^[\w\.]+[^:]*$/;
  52function makePath(href, path) {
  53  if (RELATIVE.test(href)) href = (path || "") + href;
  54  return href;
  55};
  56
  57function getPath(href, path) {
  58  href = makePath(href, path);
  59  return href.slice(0, href.lastIndexOf("/") + 1);
  60};
  61
  62// get the path to this script
  63var script = document.scripts[document.scripts.length - 1];
  64var path = getPath(script.src);
  65
  66// we'll use microsoft's http request object to load external files
  67try {
  68  var httpRequest = new ActiveXObject("Microsoft.XMLHTTP");
  69} catch (e) {
  70  // ActiveX disabled
  71}
  72
  73var fileCache = {};
  74function loadFile(href, path) {
  75try {
  76  href = makePath(href, path);
  77  if (!fileCache[href]) {
  78    // easy to load a file huh?
  79    httpRequest.open("GET", href, false);
  80    httpRequest.send();
  81    if (httpRequest.status == 0 || httpRequest.status == 200) {
  82      fileCache[href] = httpRequest.responseText;
  83    }
  84  }
  85} catch (e) {
  86  // ignore errors
  87} finally {
  88  return fileCache[href] || "";
  89}};
  90
  91// -----------------------------------------------------------------------
  92// IE5.0 compatibility
  93// -----------------------------------------------------------------------
  94
  95
  96if (appVersion < 5.5) {
  97  undefined = Undefined();
  98
  99  ANON = "HTML:!"; // for anonymous content
 100  
 101  // Fix String.replace (Safari1.x/IE5.0).
 102  var GLOBAL = /(g|gi)$/;
 103  var _String_replace = String.prototype.replace; 
 104  String.prototype.replace = function(expression, replacement) {
 105    if (typeof replacement == "function") { // Safari doesn't like functions
 106      if (expression && expression.constructor == RegExp) {
 107        var regexp = expression;
 108        var global = regexp.global;
 109        if (global == null) global = GLOBAL.test(regexp);
 110        // we have to convert global RexpExps for exec() to work consistently
 111        if (global) regexp = new RegExp(regexp.source); // non-global
 112      } else {
 113        regexp = new RegExp(rescape(expression));
 114      }
 115      var match, string = this, result = "";
 116      while (string && (match = regexp.exec(string))) {
 117        result += string.slice(0, match.index) + replacement.apply(this, match);
 118        string = string.slice(match.index + match[0].length);
 119        if (!global) break;
 120      }
 121      return result + string;
 122    }
 123    return _String_replace.apply(this, arguments);
 124  };
 125  
 126  Array.prototype.pop = function() {
 127    if (this.length) {
 128      var i = this[this.length - 1];
 129      this.length--;
 130      return i;
 131    }
 132    return undefined;
 133  };
 134  
 135  Array.prototype.push = function() {
 136    for (var i = 0; i < arguments.length; i++) {
 137      this[this.length] = arguments[i];
 138    }
 139    return this.length;
 140  };
 141  
 142  var ns = this;
 143  Function.prototype.apply = function(o, a) {
 144    if (o === undefined) o = ns;
 145    else if (o == null) o = window;
 146    else if (typeof o == "string") o = new String(o);
 147    else if (typeof o == "number") o = new Number(o);
 148    else if (typeof o == "boolean") o = new Boolean(o);
 149    if (arguments.length == 1) a = [];
 150    else if (a[0] && a[0].writeln) a[0] = a[0].documentElement.document || a[0];
 151    var $ = "#ie7_apply", r;
 152    o[$] = this;
 153    switch (a.length) { // unroll for speed
 154      case 0: r = o[$](); break;
 155      case 1: r = o[$](a[0]); break;
 156      case 2: r = o[$](a[0],a[1]); break;
 157      case 3: r = o[$](a[0],a[1],a[2]); break;
 158      case 4: r = o[$](a[0],a[1],a[2],a[3]); break;
 159      case 5: r = o[$](a[0],a[1],a[2],a[3],a[4]); break;
 160      default:
 161        var b = [], i = a.length - 1;
 162        do b[i] = "a[" + i + "]"; while (i--);
 163        eval("r=o[$](" + b + ")");
 164    }
 165    if (typeof o.valueOf == "function") { // not a COM object
 166      delete o[$];
 167    } else {
 168      o[$] = undefined;
 169      if (r && r.writeln) r = r.documentElement.document || r;
 170    }
 171    return r;
 172  };
 173  
 174  Function.prototype.call = function(o) {
 175    return this.apply(o, _slice.apply(arguments, [1]));
 176  };
 177
 178  // block elements are "inline" according to IE5.0 so we'll fix it
 179  HEADER += "address,blockquote,body,dd,div,dt,fieldset,form,"+
 180    "frame,frameset,h1,h2,h3,h4,h5,h6,iframe,noframes,object,p,"+
 181    "hr,applet,center,dir,menu,pre,dl,li,ol,ul{display:block}";
 182}
 183
 184// -----------------------------------------------------------------------
 185// OO support
 186// -----------------------------------------------------------------------
 187
 188
 189// This is a cut-down version of base2 (http://code.google.com/p/base2/)
 190
 191var _slice = Array.prototype.slice;
 192
 193// private
 194var _FORMAT = /%([1-9])/g;
 195var _LTRIM = /^\s\s*/;
 196var _RTRIM = /\s\s*$/;
 197var _RESCAPE = /([\/()[\]{}|*+-.,^$?\\])/g;           // safe regular expressions
 198var _BASE = /\bbase\b/;
 199var _HIDDEN = ["constructor", "toString"];            // only override these when prototyping
 200
 201var prototyping;
 202
 203function Base(){};
 204Base.extend = function(_instance, _static) {
 205  // Build the prototype.
 206  prototyping = true;
 207  var _prototype = new this;
 208  extend(_prototype, _instance);
 209  prototyping = false;
 210
 211  // Create the wrapper for the constructor function.
 212  var _constructor = _prototype.constructor;
 213  function klass() {
 214    // Don't call the constructor function when prototyping.
 215    if (!prototyping) _constructor.apply(this, arguments);
 216  };
 217  _prototype.constructor = klass;
 218
 219  // Build the static interface.
 220  klass.extend = arguments.callee;
 221  extend(klass, _static);
 222  klass.prototype = _prototype;
 223  return klass;
 224};
 225Base.prototype.extend = function(source) {
 226  return extend(this, source);
 227};
 228
 229// A collection of regular expressions and their associated replacement values.
 230// A Base class for creating parsers.
 231
 232var _HASH   = "#";
 233var _KEYS   = "~";
 234
 235var _RG_ESCAPE_CHARS    = /\\./g;
 236var _RG_ESCAPE_BRACKETS = /\(\?[:=!]|\[[^\]]+\]/g;
 237var _RG_BRACKETS        = /\(/g;
 238
 239var RegGrp = Base.extend({
 240  constructor: function(values) {
 241    this[_KEYS] = [];
 242    this.merge(values);
 243  },
 244
 245  exec: function(string) {
 246    var items = this, keys = this[_KEYS];    
 247    return String(string).replace(new RegExp(this, this.ignoreCase ? "gi" : "g"), function() {
 248      var item, offset = 1, i = 0;
 249      // Loop through the RegGrp items.
 250      while ((item = items[_HASH + keys[i++]])) {
 251        var next = offset + item.length + 1;
 252        if (arguments[offset]) { // do we have a result?
 253          var replacement = item.replacement;
 254          switch (typeof replacement) {
 255            case "function":
 256              return replacement.apply(items, _slice.call(arguments, offset, next));
 257            case "number":
 258              return arguments[offset + replacement];
 259            default:
 260              return replacement;
 261          }
 262        }
 263        offset = next;
 264      }
 265    });
 266  },
 267
 268  add: function(expression, replacement) {
 269    if (expression instanceof RegExp) {
 270      expression = expression.source;
 271    }
 272    if (!this[_HASH + expression]) this[_KEYS].push(String(expression));
 273    this[_HASH + expression] = new RegGrp.Item(expression, replacement);
 274  },
 275
 276  merge: function(values) {
 277    for (var i in values) this.add(i, values[i]);
 278  },
 279
 280  toString: function() {
 281    // back references not supported in simple RegGrp
 282    return "(" + this[_KEYS].join(")|(") + ")";
 283  }
 284}, {
 285  IGNORE: "$0",
 286
 287  Item: Base.extend({
 288    constructor: function(expression, replacement) {
 289      expression = expression instanceof RegExp ? expression.source : String(expression);
 290
 291      if (typeof replacement == "number") replacement = String(replacement);
 292      else if (replacement == null) replacement = "";
 293
 294      // does the pattern use sub-expressions?
 295      if (typeof replacement == "string" && /\$(\d+)/.test(replacement)) {
 296        // a simple lookup? (e.g. "$2")
 297        if (/^\$\d+$/.test(replacement)) {
 298          // store the index (used for fast retrieval of matched strings)
 299          replacement = parseInt(replacement.slice(1));
 300        } else { // a complicated lookup (e.g. "Hello $2 $1")
 301          // build a function to do the lookup
 302          var Q = /'/.test(replacement.replace(/\\./g, "")) ? '"' : "'";
 303          replacement = replacement.replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\$(\d+)/g, Q +
 304            "+(arguments[$1]||" + Q+Q + ")+" + Q);
 305          replacement = new Function("return " + Q + replacement.replace(/(['"])\1\+(.*)\+\1\1$/, "$1") + Q);
 306        }
 307      }
 308
 309      this.length = RegGrp.count(expression);
 310      this.replacement = replacement;
 311      this.toString = K(expression);
 312    }
 313  }),
 314
 315  count: function(expression) {
 316    // Count the number of sub-expressions in a RegExp/RegGrp.Item.
 317    expression = String(expression).replace(_RG_ESCAPE_CHARS, "").replace(_RG_ESCAPE_BRACKETS, "");
 318    return match(expression, _RG_BRACKETS).length;
 319  }
 320});
 321
 322// =========================================================================
 323// lang/extend.js
 324// =========================================================================
 325
 326function extend(object, source) { // or extend(object, key, value)
 327  if (object && source) {
 328    var proto = (typeof source == "function" ? Function : Object).prototype;
 329    // Add constructor, toString etc
 330    var i = _HIDDEN.length, key;
 331    if (prototyping) while (key = _HIDDEN[--i]) {
 332      var value = source[key];
 333      if (value != proto[key]) {
 334        if (_BASE.test(value)) {
 335          _override(object, key, value)
 336        } else {
 337          object[key] = value;
 338        }
 339      }
 340    }
 341    // Copy each of the source object's properties to the target object.
 342    for (key in source) if (proto[key] === undefined) {
 343      var value = source[key];
 344      // Check for method overriding.
 345      if (object[key] && typeof value == "function" && _BASE.test(value)) {
 346        _override(object, key, value);
 347      } else {
 348        object[key] = value;
 349      }
 350    }
 351  }
 352  return object;
 353};
 354
 355function _override(object, name, method) {
 356  // Override an existing method.
 357  var ancestor = object[name];
 358  object[name] = function() {
 359    var previous = this.base;
 360    this.base = ancestor;
 361    var returnValue = method.apply(this, arguments);
 362    this.base = previous;
 363    return returnValue;
 364  };
 365};
 366
 367function combine(keys, values) {
 368  // Combine two arrays to make a hash.
 369  if (!values) values = keys;
 370  var hash = {};
 371  for (var i in keys) hash[i] = values[i];
 372  return hash;
 373};
 374
 375function format(string) {
 376  // Replace %n with arguments[n].
 377  // e.g. format("%1 %2%3 %2a %1%3", "she", "se", "lls");
 378  // ==> "she sells sea shells"
 379  // Only %1 - %9 supported.
 380  var args = arguments;
 381  var _FORMAT = new RegExp("%([1-" + arguments.length + "])", "g");
 382  return String(string).replace(_FORMAT, function(match, index) {
 383    return index < args.length ? args[index] : match;
 384  });
 385};
 386
 387function match(string, expression) {
 388  // Same as String.match() except that this function will return an empty
 389  // array if there is no match.
 390  return String(string).match(expression) || [];
 391};
 392
 393function rescape(string) {
 394  // Make a string safe for creating a RegExp.
 395  return String(string).replace(_RESCAPE, "\\$1");
 396};
 397
 398// http://blog.stevenlevithan.com/archives/faster-trim-javascript
 399function trim(string) {
 400  return String(string).replace(_LTRIM, "").replace(_RTRIM, "");
 401};
 402
 403function K(k) {
 404  return function() {
 405    return k;
 406  };
 407};
 408
 409// -----------------------------------------------------------------------
 410// parsing
 411// -----------------------------------------------------------------------
 412
 413var Parser = RegGrp.extend({ignoreCase: true});
 414
 415var ENCODED = /\x01(\d+)/g,
 416    QUOTES  = /'/g, 
 417    STRING = /^\x01/,
 418    UNICODE = /\\([\da-fA-F]{1,4})/g;
 419
 420var _strings = [];
 421
 422var encoder = new Parser({
 423  // comments
 424  "<!\\-\\-|\\-\\->": "",
 425  "\\/\\*[^*]*\\*+([^\\/][^*]*\\*+)*\\/": "",
 426  // get rid
 427  "@(namespace|import)[^;\\n]+[;\\n]": "",
 428  // strings
 429  "'(\\\\.|[^'\\\\])*'": encodeString,
 430  '"(\\\\.|[^"\\\\])*"': encodeString,
 431  // white space
 432  "\\s+": " "
 433});
 434
 435function encode(cssText) {
 436  return encoder.exec(cssText);
 437};
 438
 439function decode(cssText) {
 440  return cssText.replace(ENCODED, function(match, index) {
 441    return _strings[index - 1];
 442  });
 443};
 444
 445function encodeString(string) {
 446  return "\x01" + _strings.push(string.replace(UNICODE, function(match, chr) {
 447    return eval("'\\u" + "0000".slice(chr.length) + chr + "'");
 448  }).slice(1, -1).replace(QUOTES, "\\'"));
 449};
 450
 451function getString(value) {
 452  return STRING.test(value) ? _strings[value.slice(1) - 1] : value;
 453};
 454
 455// clone a "width" function to create a "height" function
 456var rotater = new RegGrp({
 457  Width: "Height",
 458  width: "height",
 459  Left:  "Top",
 460  left:  "top",
 461  Right: "Bottom",
 462  right: "bottom",
 463  onX:   "onY"
 464});
 465
 466function rotate(fn) {
 467  return rotater.exec(fn);
 468};
 469
 470// -----------------------------------------------------------------------
 471// event handling
 472// -----------------------------------------------------------------------
 473
 474var eventHandlers = [];
 475
 476function addResize(handler) {
 477  addRecalc(handler);
 478  addEventHandler(window, "onresize", handler);
 479};
 480
 481// add an event handler (function) to an element
 482function addEventHandler(element, type, handler) {
 483  element.attachEvent(type, handler);
 484  // store the handler so it can be detached later
 485  eventHandlers.push(arguments);
 486};
 487
 488// remove an event handler assigned to an element by IE7
 489function removeEventHandler(element, type, handler) {
 490try {
 491  element.detachEvent(type, handler);
 492} catch (ignore) {
 493  // write a letter of complaint to microsoft..
 494}};
 495
 496// remove event handlers (they eat memory)
 497addEventHandler(window, "onunload", function() {
 498  var handler;
 499  while (handler = eventHandlers.pop()) {
 500    removeEventHandler(handler[0], handler[1], handler[2]);
 501  }
 502});
 503
 504function register(handler, element, condition) { // -@DRE
 505  //var set = handler[element.uniqueID];
 506  if (!handler.elements) handler.elements = {};
 507  if (condition) handler.elements[element.uniqueID] = element;
 508  else delete handler.elements[element.uniqueID];
 509  //return !set && condition;
 510  return condition;
 511};
 512
 513addEventHandler(window, "onbeforeprint", function() {
 514  if (!IE7.CSS.print) new StyleSheet("print");
 515  IE7.CSS.print.recalc();
 516});
 517
 518// -----------------------------------------------------------------------
 519// pixel conversion
 520// -----------------------------------------------------------------------
 521
 522// this is handy because it means that web developers can mix and match
 523//  measurement units in their style sheets. it is not uncommon to
 524//  express something like padding in "em" units whilst border thickness
 525//  is most often expressed in pixels.
 526
 527var PIXEL = /^\d+(px)?$/i;
 528var PERCENT = /^\d+%$/;
 529var getPixelValue = function(element, value) {
 530  if (PIXEL.test(value)) return parseInt(value);
 531  var style = element.style.left;
 532  var runtimeStyle = element.runtimeStyle.left;
 533  element.runtimeStyle.left = element.currentStyle.left;
 534  element.style.left = value || 0;
 535  value = element.style.pixelLeft;
 536  element.style.left = style;
 537  element.runtimeStyle.left = runtimeStyle;
 538  return value;
 539};
 540
 541// -----------------------------------------------------------------------
 542// generic
 543// -----------------------------------------------------------------------
 544
 545var $IE7 = "ie7-";
 546
 547var Fix = Base.extend({
 548  constructor: function() {
 549    this.fixes = [];
 550    this.recalcs = [];
 551  },
 552  init: Undefined
 553});
 554
 555// a store for functions that will be called when refreshing IE7
 556var recalcs = [];
 557function addRecalc(recalc) {
 558  recalcs.push(recalc);
 559};
 560
 561IE7.recalc = function() {
 562  IE7.HTML.recalc();
 563  // re-apply style sheet rules (re-calculate ie7 classes)
 564  IE7.CSS.recalc();
 565  // apply global fixes to the document
 566  for (var i = 0; i < recalcs.length; i++) recalcs[i]();
 567};
 568
 569function isFixed(element) {
 570  return element.currentStyle["ie7-position"] == "fixed";
 571};
 572
 573// original style
 574function getDefinedStyle(element, propertyName) {
 575  return element.currentStyle[$IE7 + propertyName] || element.currentStyle[propertyName];
 576};
 577
 578function setOverrideStyle(element, propertyName, value) {
 579  if (element.currentStyle[$IE7 + propertyName] == null) {
 580    element.runtimeStyle[$IE7 + propertyName] = element.currentStyle[propertyName];
 581  }
 582  element.runtimeStyle[propertyName] = value;
 583};
 584
 585// create a temporary element which is used to inherit styles
 586//  from the target element. the temporary element can be resized
 587//  to determine pixel widths/heights
 588function createTempElement(tagName) {
 589  var element = document.createElement(tagName || "object");
 590  element.style.cssText = "position:absolute;padding:0;display:block;border:none;clip:rect(0 0 0 0);left:-9999";
 591  element.ie7_anon = true;
 592  return element;
 593};
 594
 595
 596// =========================================================================
 597// ie7-cssQuery.js
 598// =========================================================================
 599
 600function cssQuery(selector, context, single) {
 601  if (!_cache[selector]) {
 602    reg = []; // store for RegExp objects
 603    var fn = "";
 604    var selectors = cssParser.escape(selector).split(",");
 605    for (var i = 0; i < selectors.length; i++) {
 606      _wild = _index = _list = 0; // reset
 607      _duplicate = selectors.length > 1 ? 2 : 0; // reset
 608      var block = cssParser.exec(selectors[i]) || "if(0){";
 609      if (_wild) { // IE's pesky comment nodes
 610        block += format("if(e%1.nodeName!='!'){", _index);
 611      }
 612      // check for duplicates before storing results
 613      var store = _duplicate > 1 ? _TEST : "";
 614      block += format(store + _STORE, _index);
 615      // add closing braces
 616      block += Array(match(block, /\{/g).length + 1).join("}");
 617      fn += block;
 618    }
 619    eval(format(_FN, reg) + cssParser.unescape(fn) + "return s?null:r}");
 620    _cache[selector] = _selectorFunction;
 621  }
 622  return _cache[selector](context || document, single);
 623};
 624
 625var _MSIE5 = appVersion < 6;
 626
 627var _EVALUATED = /^(href|src)$/;
 628var _ATTRIBUTES = {
 629  "class": "className",
 630  "for": "htmlFor"
 631};
 632
 633IE7._indexed = 1;
 634
 635IE7._byId = function(document, id) {
 636  var result = document.all[id] || null;
 637  // returns a single element or a collection
 638  if (!result || result.id == id) return result;
 639  // document.all has returned a collection of elements with name/id
 640  for (var i = 0; i < result.length; i++) {
 641    if (result[i].id == id) return result[i];
 642  }
 643  return null;
 644};
 645
 646IE7._getAttribute = function(element, name) {
 647  if (name == "src" && element.pngSrc) return element.pngSrc;
 648  
 649  var attribute = _MSIE5 ? (element.attributes[name] || element.attributes[_ATTRIBUTES[name.toLowerCase()]]) : element.getAttributeNode(name);
 650  if (attribute && (attribute.specified || name == "value")) {
 651    if (_EVALUATED.test(name)) {
 652      return element.getAttribute(name, 2);
 653    } else if (name == "class") {
 654     return element.className.replace(/\sie7_\w+/g, "");
 655    } else if (name == "style") {
 656     return element.style.cssText;
 657    } else {
 658     return attribute.nodeValue;
 659    }
 660  }
 661  return null;
 662};
 663
 664var names = "colSpan,rowSpan,vAlign,dateTime,accessKey,tabIndex,encType,maxLength,readOnly,longDesc";
 665// Convert the list of strings to a hash, mapping the lowercase name to the camelCase name.
 666extend(_ATTRIBUTES, combine(names.toLowerCase().split(","), names.split(",")));
 667
 668IE7._getNextElementSibling = function(node) {
 669  // return the next element to the supplied element
 670  //  nextSibling is not good enough as it might return a text or comment node
 671  while (node && (node = node.nextSibling) && (node.nodeType != 1 || node.nodeName == "!")) continue;
 672  return node;
 673};
 674
 675IE7._getPreviousElementSibling = function(node) {
 676  // return the previous element to the supplied element
 677  while (node && (node = node.previousSibling) && (node.nodeType != 1 || node.nodeName == "!")) continue;
 678  return node;
 679};
 680
 681// =========================================================================
 682// CSSParser
 683// =========================================================================
 684
 685var IMPLIED_ASTERISK = /([\s>+~,]|[^(]\+|^)([#.:\[])/g,
 686    IMPLIED_SPACE =    /(^|,)([^\s>+~])/g,
 687    WHITESPACE =       /\s*([\s>+~(),]|^|$)\s*/g,
 688    WILD_CARD =        /\s\*\s/g;;
 689
 690var CSSParser = RegGrp.extend({
 691  constructor: function(items) {
 692    this.base(items);
 693    this.sorter = new RegGrp;
 694    this.sorter.add(/:not\([^)]*\)/, RegGrp.IGNORE);
 695    this.sorter.add(/([ >](\*|[\w-]+))([^: >+~]*)(:\w+-child(\([^)]+\))?)([^: >+~]*)/, "$1$3$6$4");
 696  },
 697  
 698  ignoreCase: true,
 699
 700  escape: function(selector) {
 701    return this.optimise(this.format(selector));
 702  },
 703
 704  format: function(selector) {
 705    return selector
 706      .replace(WHITESPACE, "$1")
 707      .replace(IMPLIED_SPACE, "$1 $2")
 708      .replace(IMPLIED_ASTERISK, "$1*$2");
 709  },
 710
 711  optimise: function(selector) {
 712    // optimise wild card descendant selectors
 713    return this.sorter.exec(selector.replace(WILD_CARD, ">* "));
 714  },
 715
 716  unescape: function(selector) {
 717    return decode(selector);
 718  }
 719});
 720
 721// some constants
 722var _OPERATORS = {
 723  "":   "%1!=null",
 724  "=":  "%1=='%2'",
 725  "~=": /(^| )%1( |$)/,
 726  "|=": /^%1(-|$)/,
 727  "^=": /^%1/,
 728  "$=": /%1$/,
 729  "*=": /%1/
 730};
 731
 732var _PSEUDO_CLASSES = {
 733  "first-child": "!IE7._getPreviousElementSibling(e%1)",
 734  "link":        "e%1.currentStyle['ie7-link']=='link'",
 735  "visited":     "e%1.currentStyle['ie7-link']=='visited'"
 736};
 737
 738var _VAR = "var p%2=0,i%2,e%2,n%2=e%1.";
 739var _ID = "e%1.sourceIndex";
 740var _TEST = "var g=" + _ID + ";if(!p[g]){p[g]=1;";
 741var _STORE = "r[r.length]=e%1;if(s)return e%1;";
 742var _FN = "var _selectorFunction=function(e0,s){IE7._indexed++;var r=[],p={},reg=[%1],d=document;";
 743var reg; // a store for RexExp objects
 744var _index;
 745var _wild; // need to flag certain _wild card selectors as MSIE includes comment nodes
 746var _list; // are we processing a node _list?
 747var _duplicate; // possible duplicates?
 748var _cache = {}; // store parsed selectors
 749
 750// a hideous parser
 751var cssParser = new CSSParser({
 752  " (\\*|[\\w-]+)#([\\w-]+)": function(match, tagName, id) { // descendant selector followed by ID
 753    _wild = false;
 754    var replacement = "var e%2=IE7._byId(d,'%4');if(e%2&&";
 755    if (tagName != "*") replacement += "e%2.nodeName=='%3'&&";
 756    replacement += "(e%1==d||e%1.contains(e%2))){";
 757    if (_list) replacement += format("i%1=n%1.length;", _list);
 758    return format(replacement, _index++, _index, tagName.toUpperCase(), id);
 759  },
 760  
 761  " (\\*|[\\w-]+)": function(match, tagName) { // descendant selector
 762    _duplicate++; // this selector may produce duplicates
 763    _wild = tagName == "*";
 764    var replacement = _VAR;
 765    // IE5.x does not support getElementsByTagName("*");
 766    replacement += (_wild && _MSIE5) ? "all" : "getElementsByTagName('%3')";
 767    replacement += ";for(i%2=0;(e%2=n%2[i%2]);i%2++){";
 768    return format(replacement, _index++, _list = _index, tagName.toUpperCase());
 769  },
 770  
 771  ">(\\*|[\\w-]+)": function(match, tagName) { // child selector
 772    var children = _list;
 773    _wild = tagName == "*";
 774    var replacement = _VAR;
 775    // use the children property for MSIE as it does not contain text nodes
 776    //  (but the children collection still includes comments).
 777    // the document object does not have a children collection
 778    replacement += children ? "children": "childNodes";
 779    if (!_wild && children) replacement += ".tags('%3')";
 780    replacement += ";for(i%2=0;(e%2=n%2[i%2]);i%2++){";
 781    if (_wild) {
 782      replacement += "if(e%2.nodeType==1){";
 783      _wild = _MSIE5;
 784    } else {
 785      if (!children) replacement += "if(e%2.nodeName=='%3'){";
 786    }
 787    return format(replacement, _index++, _list = _index, tagName.toUpperCase());
 788  },
 789  
 790  "\\+(\\*|[\\w-]+)": function(match, tagName) { // direct adjacent selector
 791    var replacement = "";
 792    if (_wild) replacement += "if(e%1.nodeName!='!'){";
 793    _wild = false;
 794    replacement += "e%1=IE7._getNextElementSibling(e%1);if(e%1";
 795    if (tagName != "*") replacement += "&&e%1.nodeName=='%2'";
 796    replacement += "){";
 797    return format(replacement, _index, tagName.toUpperCase());
 798  },
 799  
 800  "~(\\*|[\\w-]+)": function(match, tagName) { // indirect adjacent selector
 801    var replacement = "";
 802    if (_wild) replacement += "if(e%1.nodeName!='!'){";
 803    _wild = false;
 804    _duplicate = 2; // this selector may produce duplicates
 805    replacement += "while(e%1=e%1.nextSibling){if(e%1.ie7_adjacent==IE7._indexed)break;if(";
 806    if (tagName == "*") {
 807      replacement += "e%1.nodeType==1";
 808      if (_MSIE5) replacement += "&&e%1.nodeName!='!'";
 809    } else replacement += "e%1.nodeName=='%2'";
 810    replacement += "){e%1.ie7_adjacent=IE7._indexed;";
 811    return format(replacement, _index, tagName.toUpperCase());
 812  },
 813  
 814  "#([\\w-]+)": function(match, id) { // ID selector
 815    _wild = false;
 816    var replacement = "if(e%1.id=='%2'){";
 817    if (_list) replacement += format("i%1=n%1.length;", _list);
 818    return format(replacement, _index, id);
 819  },
 820  
 821  "\\.([\\w-]+)": function(match, className) { // class selector
 822    _wild = false;
 823    // store RegExp objects - slightly faster on IE
 824    reg.push(new RegExp("(^|\\s)" + rescape(className) + "(\\s|$)"));
 825    return format("if(e%1.className&&reg[%2].test(e%1.className)){", _index, reg.length - 1);
 826  },
 827  
 828  "\\[([\\w-]+)\\s*([^=]?=)?\\s*([^\\]]*)\\]": function(match, attr, operator, value) { // attribute selectors
 829    var alias = _ATTRIBUTES[attr] || attr;
 830    if (operator) {
 831      var getAttribute = "e%1.getAttribute('%2',2)";
 832      if (!_EVALUATED.test(attr)) {
 833        getAttribute = "e%1.%3||" + getAttribute;
 834      }
 835      attr = format("(" + getAttribute + ")", _index, attr, alias);
 836    } else {
 837      attr = format("IE7._getAttribute(e%1,'%2')", _index, attr);
 838    }
 839    var replacement = _OPERATORS[operator || ""] || "0";
 840    if (replacement && replacement.source) {
 841      reg.push(new RegExp(format(replacement.source, rescape(cssParser.unescape(value)))));
 842      replacement = "reg[%2].test(%1)";
 843      value = reg.length - 1;
 844    }
 845    return "if(" + format(replacement, attr, value) + "){";
 846  },
 847  
 848  ":+([\\w-]+)(\\(([^)]+)\\))?": function(match, pseudoClass, $2, args) { // pseudo class selectors
 849    pseudoClass = _PSEUDO_CLASSES[pseudoClass];
 850    return "if(" + (pseudoClass ? format(pseudoClass, _index, args || "")  : "0") + "){";
 851  }
 852});
 853
 854// =========================================================================
 855// ie7-css.js
 856// =========================================================================
 857
 858var HYPERLINK = /a(#[\w-]+)?(\.[\w-]+)?:(hover|active)/i;
 859var BRACE1 = /\s*\{\s*/, BRACE2 = /\s*\}\s*/, COMMA = /\s*\,\s*/;
 860var FIRST_LINE_LETTER = /(.*)(:first-(line|letter))/;
 861
 862//var UNKNOWN = /UNKNOWN|([:.])\w+\1/i;
 863
 864var styleSheets = document.styleSheets;
 865
 866IE7.CSS = new (Fix.extend({ // single instance
 867  parser: new Parser,
 868  screen: "",
 869  print: "",
 870  styles: [],
 871  rules: [],
 872  pseudoClasses: appVersion < 7 ? "first\\-child" : "",
 873  dynamicPseudoClasses: {
 874    toString: function() {
 875      var strings = [];
 876      for (var pseudoClass in this) strings.push(pseudoClass);
 877      return strings.join("|");
 878    }
 879  },
 880  
 881  init: function() {
 882    var NONE = "^\x01$";
 883    var CLASS = "\\[class=?[^\\]]*\\]";
 884    var pseudoClasses = [];
 885    if (this.pseudoClasses) pseudoClasses.push(this.pseudoClasses);
 886    var dynamicPseudoClasses = this.dynamicPseudoClasses.toString(); 
 887    if (dynamicPseudoClasses) pseudoClasses.push(dynamicPseudoClasses);
 888    pseudoClasses = pseudoClasses.join("|");
 889    var unknown = appVersion < 7 ? ["[>+~[(]|([:.])\\w+\\1"] : [CLASS];
 890    if (pseudoClasses) unknown.push(":(" + pseudoClasses + ")");
 891    this.UNKNOWN = new RegExp(unknown.join("|") || NONE, "i");
 892    var complex = appVersion < 7 ? ["\\[[^\\]]+\\]|[^\\s(\\[]+\\s*[+~]"] : [CLASS];
 893    var complexRule = complex.concat();
 894    if (pseudoClasses) complexRule.push(":(" + pseudoClasses + ")");
 895    Rule.COMPLEX = new RegExp(complexRule.join("|") || NONE, "ig");
 896    if (this.pseudoClasses) complex.push(":(" + this.pseudoClasses + ")");
 897    DynamicRule.COMPLEX = new RegExp(complex.join("|") || NONE, "i");
 898    DynamicRule.MATCH = new RegExp(dynamicPseudoClasses ? "(.*):(" + dynamicPseudoClasses + ")(.*)" : NONE, "i");
 899    
 900    this.createStyleSheet();
 901    this.refresh();
 902  },
 903  
 904	addEventHandler: function() {
 905		addEventHandler.apply(null, arguments);
 906	},
 907  
 908  addFix: function(expression, replacement) {
 909    this.parser.add(expression, replacement);
 910  },
 911  
 912  addRecalc: function(propertyName, test, handler, replacement) {
 913    // recalcs occur whenever the document is refreshed using document.recalc()
 914    test = new RegExp("([{;\\s])" + propertyName + "\\s*:\\s*" + test + "[^;}]*");
 915    var id = this.recalcs.length;
 916    if (replacement) replacement = propertyName + ":" + replacement;
 917    this.addFix(test, function(match, $1) {
 918      return (replacement ? $1 + replacement : match) + ";ie7-" + match.slice(1) + ";ie7_recalc" + id + ":1";
 919    });
 920    this.recalcs.push(arguments);
 921    return id;
 922  },
 923  
 924  apply: function() {
 925    this.getInlineStyles();
 926    new StyleSheet("screen");
 927    this.trash();
 928  },
 929  
 930  createStyleSheet: function() {
 931    // create the IE7 style sheet
 932    this.styleSheet = document.createStyleSheet();
 933    // flag it so we can ignore it during parsing
 934    this.styleSheet.ie7 = true;
 935    this.styleSheet.owningElement.ie7 = true;
 936    this.styleSheet.cssText = HEADER;
 937  },
 938  
 939  getInlineStyles: function() {
 940    // load inline styles
 941    var styleSheets = document.getElementsByTagName("style"), styleSheet;
 942    for (var i = styleSheets.length - 1; (styleSheet = styleSheets[i]); i--) {
 943      if (!styleSheet.disabled && !styleSheet.ie7) {
 944        this.styles.push(styleSheet.innerHTML);
 945      }
 946    }
 947  },
 948  
 949  getText: function(styleSheet, path) {
 950    // explorer will trash unknown selectors (it converts them to "UNKNOWN").
 951    // so we must reload external style sheets (internal style sheets can have their text
 952    //  extracted through the innerHTML property).
 953      // load the style sheet text from an external file
 954    try {
 955      var cssText = styleSheet.cssText;
 956    } catch (e) {
 957      cssText = "";
 958    }
 959    if (httpRequest) cssText = loadFile(styleSheet.href, path) || cssText;
 960    return cssText;
 961  },
 962  
 963  recalc: function() {
 964    this.screen.recalc();
 965    // we're going to read through all style rules.
 966    //  certain rules have had ie7 properties added to them.
 967    //   e.g. p{top:0; ie7_recalc2:1; left:0}
 968    //  this flags a property in the rule as needing a fix.
 969    //  the selector text is then used to query the document.
 970    //  we can then loop through the results of the query
 971    //  and fix the elements.
 972    // we ignore the IE7 rules - so count them in the header
 973    var RECALCS = /ie7_recalc\d+/g;
 974    var start = HEADER.match(/[{,]/g).length;
 975    // only calculate screen fixes. print fixes don't show up anyway
 976    var stop = start + (this.screen.cssText.match(/\{/g)||"").length;
 977    var rules = this.styleSheet.rules, rule;
 978    var calcs, calc, elements, element, i, j, k, id;
 979    // loop through all rules
 980    for (i = start; i < stop; i++) {
 981      rule = rules[i];
 982      var cssText = rule.style.cssText;
 983      // search for the "ie7_recalc" flag (there may be more than one)
 984      if (rule && (calcs = cssText.match(RECALCS))) {
 985        // use the selector text to query the document
 986        elements = cssQuery(rule.selectorText);
 987        // if there are matching elements then loop
 988        //  through the recalc functions and apply them
 989        //  to each element
 990        if (elements.length) for (j = 0; j < calcs.length; j++) {
 991          // get the matching flag (e.g. ie7_recalc3)
 992          id = calcs[j];
 993          // extract the numeric id from the end of the flag
 994          //  and use it to index the collection of recalc
 995          //  functions
 996          calc = IE7.CSS.recalcs[id.slice(10)][2];
 997          for (k = 0; (element = elements[k]); k++) {
 998            // apply the fix
 999            if (element.currentStyle[id]) calc(element, cssText);
1000          }
1001        }
1002      }
1003    }
1004  },
1005  
1006  refresh: function() {
1007    this.styleSheet.cssText = HEADER + this.screen + this.print;
1008  },
1009  
1010  trash: function() {
1011    // trash the old style sheets
1012    for (var i = 0; i < styleSheets.length; i++) {
1013      if (!styleSheets[i].ie7) {
1014        try {
1015          var cssText = styleSheets[i].cssText;
1016        } catch (e) {
1017          cssText = "";
1018        }
1019        if (cssText) styleSheets[i].cssText = "";
1020      }
1021    }
1022  }
1023}));
1024
1025// -----------------------------------------------------------------------
1026//  IE7 StyleSheet class
1027// -----------------------------------------------------------------------
1028
1029var StyleSheet = Base.extend({
1030  constructor: function(media) {
1031    this.media = media;
1032    this.load();
1033    IE7.CSS[media] = this;
1034    IE7.CSS.refresh();
1035  },
1036  
1037  createRule: function(selector, cssText) {
1038    if (IE7.CSS.UNKNOWN.test(selector)) {
1039      var match;
1040      if (PseudoElement && (match = selector.match(PseudoElement.MATCH))) {
1041        return new PseudoElement(match[1], match[2], cssText);
1042      } else if (match = selector.match(DynamicRule.MATCH)) {
1043        if (!HYPERLINK.test(match[0]) || DynamicRule.COMPLEX.test(match[0])) {
1044          return new DynamicRule(selector, match[1], match[2], match[3], cssText);
1045        }
1046      } else return new Rule(selector, cssText);
1047    }
1048    return selector + " {" + cssText + "}";
1049  },
1050  
1051  getText: function() {
1052    // store for style sheet text
1053    var _inlineStyles = [].concat(IE7.CSS.styles);
1054    // parse media decalarations
1055    var MEDIA = /@media\s+([^{]*)\{([^@]+\})\s*\}/gi;
1056    var ALL = /\ball\b|^$/i, SCREEN = /\bscreen\b/i, PRINT = /\bprint\b/i;
1057    function _parseMedia(cssText, media) {
1058      _filterMedia.value = media;
1059      return cssText.replace(MEDIA, _filterMedia);
1060    };
1061    function _filterMedia(match, media, cssText) {
1062      media = _simpleMedia(media);
1063      switch (media) {
1064        case "screen":
1065        case "print":
1066          if (media != _filterMedia.value) return "";
1067        case "all":
1068          return cssText;
1069      }
1070      return "";
1071    };
1072    function _simpleMedia(media) {
1073      if (ALL.test(media)) return "all";
1074      else if (SCREEN.test(media)) return (PRINT.test(media)) ? "all" : "screen";
1075      else if (PRINT.test(media)) return "print";
1076    };
1077    var self = this;
1078    function _getCSSText(styleSheet, path, media, level) {
1079      var cssText = "";
1080      if (!level) {
1081        media = _simpleMedia(styleSheet.media);
1082        level = 0;
1083      }
1084      if (media == "all" || media == self.media) {
1085        // IE only allows importing style sheets three levels deep.
1086        // it will crash if you try to access a level below this
1087        if (level < 3) {
1088          // loop through imported style sheets
1089          for (var i = 0; i < styleSheet.imports.length; i++) {
1090            // call this function recursively to get all imported style sheets
1091            cssText += _getCSSText(styleSheet.imports[i], getPath(styleSheet.href, path), media, level + 1);
1092          }
1093        }
1094        // retrieve inline style or load an external style sheet
1095        cssText += encode(styleSheet.href ? _loadStyleSheet(styleSheet, path) : _inlineStyles.pop() || "");
1096        cssText = _parseMedia(cssText, self.media);
1097      }
1098      return cssText;
1099    };
1100    // store loaded cssText URLs
1101    var fileCache = {};
1102    // load an external style sheet
1103    function _loadStyleSheet(styleSheet, path) {
1104      var url = makePath(styleSheet.href, path);
1105      // if the style sheet has already loaded then don't duplicate it
1106      if (fileCache[url]) return "";
1107      // load from source
1108      fileCache[url] = (styleSheet.disabled) ? "" :
1109        _fixUrls(IE7.CSS.getText(styleSheet, path), getPath(styleSheet.href, path));
1110      return fileCache[url];
1111    };
1112    // fix css paths
1113    // we're lumping all css text into one big style sheet so relative
1114    //  paths have to be fixed. this is necessary anyway because of other
1115    //  explorer bugs.
1116    var URL = /(url\s*\(\s*['"]?)([\w\.]+[^:\)]*['"]?\))/gi;
1117    function _fixUrls(cssText, pathname) {
1118      // hack & slash
1119      return cssText.replace(URL, "$1" + pathname.slice(0, pathname.lastIndexOf("/") + 1) + "$2");
1120    };
1121
1122    // load all style sheets in the document
1123    for (var i = 0; i < styleSheets.length; i++) {
1124      if (!styleSheets[i].disabled && !styleSheets[i].ie7) {
1125        this.cssText += _getCSSText(styleSheets[i]);
1126      }
1127    }
1128  },
1129  
1130  load: function() {
1131    this.cssText = "";
1132    this.getText();
1133    this.parse();
1134    this.cssText = decode(this.cssText);
1135    fileCache = {};
1136  },
1137  
1138  parse: function() {
1139    this.cssText = IE7.CSS.parser.exec(this.cssText);
1140    
1141    // parse the style sheet
1142    var offset = IE7.CSS.rules.length;
1143    var rules = this.cssText.split(BRACE2), rule;
1144    var selectors, cssText, i, j;
1145    for (i = 0; i < rules.length; i++) {
1146      rule = rules[i].split(BRACE1);
1147      selectors = rule[0].split(COMMA);
1148      cssText = rule[1];
1149      for (j = 0; j < selectors.length; j++) {
1150        selectors[j] = cssText ? this.createRule(selectors[j], cssText) : "";
1151      }
1152      rules[i] = selectors.join("\n");
1153    }
1154    this.cssText = rules.join("\n");
1155    this.rules = IE7.CSS.rules.slice(offset);
1156  },
1157  
1158  recalc: function() {
1159    var rule, i;
1160    for (i = 0; (rule = this.rules[i]); i++) rule.recalc();
1161  },
1162  
1163  toString: function() {
1164    return "@media " + this.media + "{" + this.cssText + "}";
1165  }
1166});
1167
1168var PseudoElement;
1169
1170// -----------------------------------------------------------------------
1171// IE7 style rules
1172// -----------------------------------------------------------------------
1173
1174var Rule = IE7.Rule = Base.extend({
1175  // properties
1176  constructor: function(selector, cssText) {
1177    this.id = IE7.CSS.rules.length;
1178    this.className = Rule.PREFIX + this.id;
1179    selector = selector.match(FIRST_LINE_LETTER) || selector || "*";
1180    this.selector = selector[1] || selector;
1181    this.selectorText = this.parse(this.selector) + (selector[2] || "");
1182    this.cssText = cssText;
1183    this.MATCH = new RegExp("\\s" + this.className + "(\\s|$)", "g");
1184    IE7.CSS.rules.push(this);
1185    this.init();
1186  },
1187  
1188  init: Undefined,
1189  
1190  add: function(element) {
1191    // allocate this class
1192    element.className += " " + this.className;
1193  },
1194  
1195  recalc: function() {
1196    // execute the underlying css query for this class
1197    var match = cssQuery(this.selector);
1198    // add the class name for all matching elements
1199    for (var i = 0; i < match.length; i++) this.add(match[i]);
1200  },
1201
1202  parse: function(selector) {
1203    // attempt to preserve specificity for "loose" parsing by
1204    //  removing unknown tokens from a css selector but keep as
1205    //  much as we can..
1206    var simple = selector.replace(Rule.CHILD, " ").replace(Rule.COMPLEX, "");
1207    if (appVersion < 7) simple = simple.replace(Rule.MULTI, "");
1208    var tags = match(simple, Rule.TAGS).length - match(selector, Rule.TAGS).length;
1209    var classes = match(simple, Rule.CLASSES).length - match(selector, Rule.CLASSES).length + 1;
1210    while (classes > 0 && Rule.CLASS.test(simple)) {
1211      simple = simple.replace(Rule.CLASS, "");
1212      classes--;
1213    }
1214    while (tags > 0 && Rule.TAG.test(simple)) {
1215      simple = simple.replace(Rule.TAG, "$1*");
1216      tags--;
1217    }
1218    simple += "." + this.className;
1219    classes = Math.min(classes, 2);
1220    tags = Math.min(tags, 2);
1221    var score = -10 * classes - tags;
1222    if (score > 0) {
1223      simple = simple + "," + Rule.MAP[score] + " " + simple;
1224    }
1225    return simple;
1226  },
1227  
1228  remove: function(element) {
1229    // deallocate this class
1230    element.className = element.className.replace(this.MATCH, "$1");
1231  },
1232  
1233  toString: function() {
1234    return format("%1 {%2}", this.selectorText, this.cssText);
1235  }
1236}, {
1237  CHILD: />/g,
1238  CLASS: /\.[\w-]+/,
1239  CLASSES: /[.:\[]/g,
1240  MULTI: /(\.[\w-]+)+/g,
1241  PREFIX: "ie7_class",
1242  TAG: /^\w+|([\s>+~])\w+/,
1243  TAGS: /^\w|[\s>+~]\w/g,
1244  MAP: {
1245    1:  "html",
1246    2:  "html body",
1247    10: ".ie7_html",
1248    11: "html.ie7_html",
1249    12: "html.ie7_html body",
1250    20: ".ie7_html .ie7_body",
1251    21: "html.ie7_html .ie7_body",
1252    22: "html.ie7_html body.ie7_body"
1253  }
1254});
1255
1256// -----------------------------------------------------------------------
1257// IE7 dynamic style
1258// -----------------------------------------------------------------------
1259
1260// object properties:
1261// attach: the element that an event handler will be attached to
1262// target: the element that will have the IE7 class applied
1263
1264var DynamicRule = Rule.extend({
1265  // properties
1266  constructor: function(selector, attach, dynamicPseudoClass, target, cssText) {
1267    // initialise object properties
1268    this.attach = attach || "*";
1269    this.dynamicPseudoClass = IE7.CSS.dynamicPseudoClasses[dynamicPseudoClass];
1270    this.target = target;
1271    this.base(selector, cssText);
1272  },
1273  
1274  recalc: function() {
1275    // execute the underlying css query for this class
1276    var attaches = cssQuery(this.attach), attach;
1277    // process results
1278    for (var i = 0; attach = attaches[i]; i++) {
1279      // retrieve the event handler's target element(s)
1280      var target = this.target ? cssQuery(this.target, attach) : [attach];
1281      // attach event handlers for dynamic pseudo-classes
1282      if (target.length) this.dynamicPseudoClass.apply(attach, target, this);
1283    }
1284  }
1285});
1286
1287// -----------------------------------------------------------------------
1288//  IE7 dynamic pseudo-classes
1289// -----------------------------------------------------------------------
1290
1291var DynamicPseudoClass = Base.extend({
1292  constructor: function(name, apply) {
1293    this.name = name;
1294    this.apply = apply;
1295    this.instances = {};
1296    IE7.CSS.dynamicPseudoClasses[name] = this;
1297  },
1298  
1299  register: function(instance) {
1300    // an "instance" is actually an Arguments object
1301    var _class = instance[2];
1302    instance.id = _class.id + instance[0].uniqueID;
1303    if (!this.instances[instance.id]) {
1304      var target = instance[1], j;
1305      for (j = 0; j < target.length; j++) _class.add(target[j]);
1306      this.instances[instance.id] = instance;
1307    }
1308  },
1309  
1310  unregister: function(instance) {
1311    if (this.instances[instance.id]) {
1312      var _class = instance[2];
1313      var target = instance[1], j;
1314      for (j = 0; j < target.length; j++) _class.remove(target[j]);
1315      delete this.instances[instance.id];
1316    }
1317  }
1318});
1319  
1320// -----------------------------------------------------------------------
1321// dynamic pseudo-classes
1322// -----------------------------------------------------------------------
1323
1324if (appVersion < 7) {
1325  var Hover = new DynamicPseudoClass("hover", function(element) {
1326    var instance = arguments;
1327    IE7.CSS.addEventHandler(element, appVersion < 5.5 ? "onmouseover" : "onmouseenter", function() {
1328      Hover.register(instance);
1329    });
1330    IE7.CSS.addEventHandler(element, appVersion < 5.5 ? "onmouseout" : "onmouseleave", function() {
1331      Hover.unregister(instance);
1332    });
1333  });
1334  
1335  // globally trap the mouseup event (thanks Martijn!)
1336  addEventHandler(document, "onmouseup", function() {
1337    var instances = Hover.instances;
1338    for (var i in instances)
1339      if (!instances[i][0].contains(event.srcElement))
1340        Hover.unregister(instances[i]);
1341  });
1342}
1343
1344// -----------------------------------------------------------------------
1345// propertyName: inherit;
1346// -----------------------------------------------------------------------
1347
1348IE7.CSS.addRecalc("[\\w-]+", "inherit", function(element, cssText) {
1349  var inherited = cssText.match(/[\w-]+\s*:\s*inherit/g);
1350  for (var i = 0; i < inherited.length; i++) {
1351    var propertyName = inherited[i].replace(/ie7\-|\s*:\s*inherit/g, "").replace(/\-([a-z])/g, function(match, chr) {
1352      return chr.toUpperCase()
1353    });
1354    element.runtimeStyle[propertyName] = element.parentElement.currentStyle[propertyName];
1355  }
1356});
1357
1358// =========================================================================
1359// ie7-html.js
1360// =========================================================================
1361
1362// default font-sizes
1363//HEADER += "h1{font-size:2em}h2{font-size:1.5em;}h3{font-size:1.17em;}h4{font-size:1em}h5{font-size:.83em}h6{font-size:.67em}";
1364
1365IE7.HTML = new (Fix.extend({ // single instance  
1366  fixed: {},
1367  
1368  init: Undefined,
1369  
1370  addFix: function() {
1371    // fixes are a one-off, they are applied when the document is loaded
1372    this.fixes.push(arguments);
1373  },
1374  
1375  apply: function() {
1376    for (var i = 0; i < this.fixes.length; i++) {
1377      var match = cssQuery(this.fixes[i][0]);
1378      var fix = this.fixes[i][1];
1379      for (var j = 0; j < match.length; j++) fix(match[j]);
1380    }
1381  },
1382  
1383  addRecalc: function() {
1384    // recalcs occur whenever the document is refreshed using document.recalc()
1385    this.recalcs.push(arguments);
1386  },
1387  
1388  recalc: function() {
1389    // loop through the fixes
1390    for (var i = 0; i < this.recalcs.length; i++) {
1391      var match = cssQuery(this.recalcs[i][0]);
1392      var recalc = this.recalcs[i][1], element;
1393      var key = Math.pow(2, i);
1394      for (var j = 0; (element = match[j]); j++) {
1395        var uniqueID = element.uniqueID;
1396        if ((this.fixed[uniqueID] & key) == 0) {
1397          element = recalc(element) || element;
1398          this.fixed[uniqueID] |= key;
1399        }
1400      }
1401    }
1402  }
1403}));
1404
1405if (appVersion < 7) {  
1406  // provide support for the <abbr> tag.
1407  //  this is a proper fix, it preserves the DOM structure and
1408  //  <abbr> elements report the correct tagName & namespace prefix
1409  document.createElement("abbr");
1410  
1411  // bind to the first child control
1412  IE7.HTML.addRecalc("label", function(label) {
1413    if (!label.htmlFor) {
1414      var firstChildControl = cssQuery("input,textarea", label, true);
1415      if (firstChildControl) {
1416        addEventHandler(label, "onclick", function() {
1417          firstChildControl.click();
1418        });
1419      }
1420    }
1421  });
1422}
1423
1424// =========================================================================
1425// ie7-layout.js
1426// =========================================================================
1427
1428var NUMERIC = "[.\\d]";
1429
1430new function(_) {
1431var layout = IE7.Layout = this;
1432
1433  // big, ugly box-model hack + min/max stuff
1434  
1435  // #tantek > #erik > #dean { voice-family: hacker; }
1436  
1437  // -----------------------------------------------------------------------
1438  // "layout"
1439  // -----------------------------------------------------------------------
1440  
1441  HEADER += "*{boxSizing:content-box}";
1442  
1443  // does an element have "layout" ?
1444  IE7.hasLayout = appVersion < 5.5 ? function(element) {
1445    // element.currentStyle.hasLayout doesn't work for IE5.0
1446    return element.clientWidth;
1447  } : function(element) {
1448    return element.currentStyle.hasLayout;
1449  };
1450  
1451  // give an element "layout"
1452  layout.boxSizing = function(element) {
1453    if (!IE7.hasLayout(element)) {
1454    //#  element.runtimeStyle.fixedHeight =
1455      element.style.height = "0cm";
1456      if (element.currentStyle.verticalAlign == "auto")
1457        element.runtimeStyle.verticalAlign = "top";
1458      // when an element acquires "layout", margins no longer collapse correctly
1459      collapseMargins(element);
1460    }
1461  };
1462  
1463  // -----------------------------------------------------------------------
1464  // Margin Collapse
1465  // -----------------------------------------------------------------------
1466  
1467  function collapseMargins(element) {
1468    if (element != viewport && element.currentStyle.position != "absolute") {
1469      collapseMargin(element, "marginTop");
1470      collapseMargin(element, "marginBottom");
1471    }
1472  };
1473  
1474  function collapseMargin(element, type) {
1475    if (!element.runtimeStyle[type]) {
1476      var parentElement = element.parentElement;
1477      if (parentElement && IE7.hasLayout(parentElement) && !IE7[type == "marginTop" ? "_getPreviousElementSibling" : "_getNextElementSibling"](element)) return;
1478      var child = cssQuery(">*:" + (type == "marginTop" ? "first" : "last") + "-child", element, true);
1479      if (child && child.currentStyle.styleFloat == "none" && IE7.hasLayout(child)) {
1480        collapseMargin(child, type);
1481        margin = _getMargin(element, element.currentStyle[type]);
1482        childMargin = _getMargin(child, child.currentStyle[type]);
1483        if (margin < 0 || childMargin < 0) {
1484          element.runtimeStyle[type] = margin + childMargin;
1485        } else {
1486          element.runtimeStyle[type] = Math.max(childMargin, margin);
1487        }
1488        child.runtimeStyle[type] = "0px";
1489      }
1490    }
1491  };
1492  
1493  function _getMargin(element, value) {
1494    return value == "auto" ? 0 : getPixelValue(element, value);
1495  };
1496  
1497  // -----------------------------------------------------------------------
1498  // box-model
1499  // -----------------------------------------------------------------------
1500  
1501  // constants
1502  var UNIT = /^[.\d][\w%]*$/, AUTO = /^(auto|0cm)$/;
1503  
1504  var applyWidth, appl

Large files files are truncated, but you can click here to view the full file