Debian Codegraph @

closure-library/closure/goog/cssom/iframe/style.js

raw
1 // Copyright 2007 The Closure Library Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS-IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 // All Rights Reserved.
15
16 /**
17 * @fileoverview Provides utility routines for copying modified
18 * {@code CSSRule} objects from the parent document into iframes so that any
19 * content in the iframe will be styled as if it was inline in the parent
20 * document.
21 *
22 * <p>
23 * For example, you might have this CSS rule:
24 *
25 * #content .highlighted { background-color: yellow; }
26 *
27 * And this DOM structure:
28 *
29 * <div id="content">
30 * <iframe />
31 * </div>
32 *
33 * Then inside the iframe you have:
34 *
35 * <body>
36 * <div class="highlighted">
37 * </body>
38 *
39 * If you copied the CSS rule directly into the iframe, it wouldn't match the
40 * .highlighted div. So we rewrite the original stylesheets based on the
41 * context where the iframe is going to be inserted. In this case the CSS
42 * selector would be rewritten to:
43 *
44 * body .highlighted { background-color: yellow; }
45 * </p>
46 *
47 */
48
49
50 goog.provide('goog.cssom.iframe.style');
51
52 goog.require('goog.asserts');
53 goog.require('goog.cssom');
54 goog.require('goog.dom');
55 goog.require('goog.dom.NodeType');
56 goog.require('goog.dom.TagName');
57 goog.require('goog.dom.classlist');
58 goog.require('goog.string');
59 goog.require('goog.style');
60 goog.require('goog.userAgent');
61
62
63 /**
64 * Regexp that matches "a", "a:link", "a:visited", etc.
65 * @type {RegExp}
66 * @private
67 */
68 goog.cssom.iframe.style.selectorPartAnchorRegex_ =
69 /a(:(link|visited|active|hover))?/;
70
71
72 /**
73 * Delimiter between selectors (h1, h2)
74 * @type {string}
75 * @private
76 */
77 goog.cssom.iframe.style.SELECTOR_DELIMITER_ = ',';
78
79
80 /**
81 * Delimiter between selector parts (.main h1)
82 * @type {string}
83 * @private
84 */
85 goog.cssom.iframe.style.SELECTOR_PART_DELIMITER_ = ' ';
86
87
88 /**
89 * Delimiter marking the start of a css rules section ( h1 { )
90 * @type {string}
91 * @private
92 */
93 goog.cssom.iframe.style.DECLARATION_START_DELIMITER_ = '{';
94
95
96 /**
97 * Delimiter marking the end of a css rules section ( } )
98 * @type {string}
99 * @private
100 */
101 goog.cssom.iframe.style.DECLARATION_END_DELIMITER_ = '}\n';
102
103
104
105 /**
106 * Class representing a CSS rule set. A rule set is something like this:
107 * h1, h2 { font-family: Arial; color: red; }
108 * @constructor
109 * @private
110 */
111 goog.cssom.iframe.style.CssRuleSet_ = function() {
112 /**
113 * Text of the declarations inside the rule set.
114 * For example: 'font-family: Arial; color: red;'
115 * @type {string}
116 */
117 this.declarationText = '';
118
119 /**
120 * Array of CssSelector objects, one for each selector.
121 * Example: [h1, h2]
122 * @type {Array<goog.cssom.iframe.style.CssSelector_>}
123 */
124 this.selectors = [];
125 };
126
127
128 /**
129 * Initializes the rule set from a {@code CSSRule}.
130 *
131 * @param {CSSRule} cssRule The {@code CSSRule} to initialize from.
132 * @return {boolean} True if initialization succeeded. We only support
133 * {@code CSSStyleRule} and {@code CSSFontFaceRule} objects.
134 */
135 goog.cssom.iframe.style.CssRuleSet_.prototype.initializeFromCssRule = function(
136 cssRule) {
137 var ruleStyle = cssRule.style; // Cache object for performance.
138 if (!ruleStyle) {
139 return false;
140 }
141 var selector;
142 var declarations = '';
143 if (ruleStyle && (selector = cssRule.selectorText) &&
144 (declarations = ruleStyle.cssText)) {
145 // IE get confused about cssText context if a stylesheet uses the
146 // mid-pass hack, and it ends up with an open comment (/*) but no
147 // closing comment. This will effectively comment out large parts
148 // of generated stylesheets later. This errs on the safe side by
149 // always tacking on an empty comment to force comments to be closed
150 // We used to check for a troublesome open comment using a regular
151 // expression, but it's faster not to check and always do this.
152 if (goog.userAgent.IE) {
153 declarations += '/* */';
154 }
155 } else if (cssRule.cssText) {
156 var cssSelectorMatch = /([^\{]+)\{/;
157 var endTagMatch = /\}[^\}]*$/g;
158 // cssRule.cssText contains both selector and declarations:
159 // parse them out.
160 selector = cssSelectorMatch.exec(cssRule.cssText)[1];
161 // Remove selector, {, and trailing }.
162 declarations =
163 cssRule.cssText.replace(cssSelectorMatch, '').replace(endTagMatch, '');
164 }
165 if (selector) {
166 this.setSelectorsFromString(selector);
167 this.declarationText = declarations;
168 return true;
169 }
170 return false;
171 };
172
173
174 /**
175 * Parses a selectors string (which may contain multiple comma-delimited
176 * selectors) and loads the results into this.selectors.
177 * @param {string} selectorsString String containing selectors.
178 */
179 goog.cssom.iframe.style.CssRuleSet_.prototype.setSelectorsFromString = function(
180 selectorsString) {
181 this.selectors = [];
182 var selectors = selectorsString.split(/,\s*/gm);
183 for (var i = 0; i < selectors.length; i++) {
184 var selector = selectors[i];
185 if (selector.length > 0) {
186 this.selectors.push(new goog.cssom.iframe.style.CssSelector_(selector));
187 }
188 }
189 };
190
191
192 /**
193 * Make a copy of this ruleset.
194 * @return {!goog.cssom.iframe.style.CssRuleSet_} A new CssRuleSet containing
195 * the same data as this one.
196 */
197 goog.cssom.iframe.style.CssRuleSet_.prototype.clone = function() {
198 var newRuleSet = new goog.cssom.iframe.style.CssRuleSet_();
199 newRuleSet.selectors = this.selectors.concat();
200 newRuleSet.declarationText = this.declarationText;
201 return newRuleSet;
202 };
203
204
205 /**
206 * Set the declaration text with properties from a given object.
207 * @param {Object} sourceObject Object whose properties and values should
208 * be used to generate the declaration text.
209 * @param {boolean=} opt_important Whether !important should be added to each
210 * declaration.
211 */
212 goog.cssom.iframe.style.CssRuleSet_.prototype.setDeclarationTextFromObject =
213 function(sourceObject, opt_important) {
214 var stringParts = [];
215 // TODO(user): for ... in is costly in IE6 (extra garbage collection).
216 for (var prop in sourceObject) {
217 var value = sourceObject[prop];
218 if (value) {
219 stringParts.push(
220 prop, ':', value, (opt_important ? ' !important' : ''), ';');
221 }
222 }
223 this.declarationText = stringParts.join('');
224 };
225
226
227 /**
228 * Serializes this CssRuleSet_ into an array as a series of strings.
229 * The array can then be join()-ed to get a string representation
230 * of this ruleset.
231 * @param {Array<string>} array The array to which to append strings.
232 */
233 goog.cssom.iframe.style.CssRuleSet_.prototype.writeToArray = function(array) {
234 var selectorCount = this.selectors.length;
235 var matchesAnchorTag = false;
236 for (var i = 0; i < selectorCount; i++) {
237 var selectorParts = this.selectors[i].parts;
238 var partCount = selectorParts.length;
239 for (var j = 0; j < partCount; j++) {
240 array.push(
241 selectorParts[j].inputString_,
242 goog.cssom.iframe.style.SELECTOR_PART_DELIMITER_);
243 }
244 if (i < (selectorCount - 1)) {
245 array.push(goog.cssom.iframe.style.SELECTOR_DELIMITER_);
246 }
247 if (goog.userAgent.GECKO && !goog.userAgent.isVersionOrHigher('1.9a')) {
248 // In Gecko pre-1.9 (Firefox 2 and lower) we need to add !important
249 // to rulesets that match "A" tags, otherwise Gecko's built-in
250 // stylesheet will take precedence when designMode is on.
251 matchesAnchorTag = matchesAnchorTag ||
252 goog.cssom.iframe.style.selectorPartAnchorRegex_.test(
253 selectorParts[partCount - 1].inputString_);
254 }
255 }
256 var declarationText = this.declarationText;
257 if (matchesAnchorTag) {
258 declarationText =
259 goog.cssom.iframe.style.makeColorRuleImportant_(declarationText);
260 }
261 array.push(
262 goog.cssom.iframe.style.DECLARATION_START_DELIMITER_, declarationText,
263 goog.cssom.iframe.style.DECLARATION_END_DELIMITER_);
264 };
265
266
267 /**
268 * Regexp that matches "color: value;".
269 * @type {RegExp}
270 * @private
271 */
272 goog.cssom.iframe.style.colorImportantReplaceRegex_ =
273 /(^|;|{)\s*color:([^;]+);/g;
274
275
276 /**
277 * Adds !important to a css color: rule
278 * @param {string} cssText Text of the CSS rule(s) to modify.
279 * @return {string} Text with !important added to the color: rule if found.
280 * @private
281 */
282 goog.cssom.iframe.style.makeColorRuleImportant_ = function(cssText) {
283 // Replace to insert a "! important" string.
284 return cssText.replace(
285 goog.cssom.iframe.style.colorImportantReplaceRegex_,
286 '$1 color: $2 ! important; ');
287 };
288
289
290
291 /**
292 * Represents a single CSS selector, as described in
293 * http://www.w3.org/TR/REC-CSS2/selector.html
294 * Currently UNSUPPORTED are the following selector features:
295 * <ul>
296 * <li>pseudo-classes (:hover)
297 * <li>child selectors (div > h1)
298 * <li>adjacent sibling selectors (div + h1)
299 * <li>attribute selectors (input[type=submit])
300 * </ul>
301 * @param {string=} opt_selectorString String containing selectors to parse.
302 * @constructor
303 * @private
304 */
305 goog.cssom.iframe.style.CssSelector_ = function(opt_selectorString) {
306
307 /**
308 * Object to track ancestry matches to speed up repeatedly testing this
309 * CssSelector against the same NodeAncestry object.
310 * @type {Object}
311 * @private
312 */
313 this.ancestryMatchCache_ = {};
314 if (opt_selectorString) {
315 this.setPartsFromString_(opt_selectorString);
316 }
317 };
318
319
320 /**
321 * Parses a selector string into individual parts.
322 * @param {string} selectorString A string containing a CSS selector.
323 * @private
324 */
325 goog.cssom.iframe.style.CssSelector_.prototype.setPartsFromString_ = function(
326 selectorString) {
327 var parts = [];
328 var selectorPartStrings = selectorString.split(/\s+/gm);
329 for (var i = 0; i < selectorPartStrings.length; i++) {
330 if (!selectorPartStrings[i]) {
331 continue; // Skip empty strings.
332 }
333 var part =
334 new goog.cssom.iframe.style.CssSelectorPart_(selectorPartStrings[i]);
335 parts.push(part);
336 }
337 this.parts = parts;
338 };
339
340
341 /**
342 * Tests to see what part of a DOM element hierarchy would be matched by
343 * this selector, and returns the indexes of the matching element and matching
344 * selector part.
345 * <p>
346 * For example, given this hierarchy:
347 * document > html > body > div.content > div.sidebar > p
348 * and this CSS selector:
349 * body div.sidebar h1
350 * This would return {elementIndex: 4, selectorPartIndex: 1},
351 * indicating that the element at index 4 matched
352 * the css selector at index 1.
353 * </p>
354 * @param {goog.cssom.iframe.style.NodeAncestry_} elementAncestry Object
355 * representing an element and its ancestors.
356 * @return {Object} Object with the properties elementIndex and
357 * selectorPartIndex, or null if there was no match.
358 */
359 goog.cssom.iframe.style.CssSelector_.prototype.matchElementAncestry = function(
360 elementAncestry) {
361
362 var ancestryUid = elementAncestry.uid;
363 if (this.ancestryMatchCache_[ancestryUid]) {
364 return this.ancestryMatchCache_[ancestryUid];
365 }
366
367 // Walk through the selector parts and see how far down the element hierarchy
368 // we can go while matching the selector parts.
369 var elementIndex = 0;
370 var match = null;
371 var selectorPart = null;
372 var lastSelectorPart = null;
373 var ancestorNodes = elementAncestry.nodes;
374 var ancestorNodeCount = ancestorNodes.length;
375
376 for (var i = 0; i <= this.parts.length; i++) {
377 selectorPart = this.parts[i];
378 while (elementIndex < ancestorNodeCount) {
379 var currentElementInfo = ancestorNodes[elementIndex];
380 if (selectorPart && selectorPart.testElement(currentElementInfo)) {
381 match = {elementIndex: elementIndex, selectorPartIndex: i};
382 elementIndex++;
383 break;
384 } else if (
385 lastSelectorPart &&
386 lastSelectorPart.testElement(currentElementInfo)) {
387 match = {elementIndex: elementIndex, selectorPartIndex: i - 1};
388 }
389 elementIndex++;
390 }
391 lastSelectorPart = selectorPart;
392 }
393 this.ancestryMatchCache_[ancestryUid] = match;
394 return match;
395 };
396
397
398
399 /**
400 * Represents one part of a CSS Selector. For example in the selector
401 * 'body #foo .bar', body, #foo, and .bar would be considered selector parts.
402 * In the official CSS spec these are called "simple selectors".
403 * @param {string} selectorPartString A string containing the selector part
404 * in css format.
405 * @constructor
406 * @private
407 */
408 goog.cssom.iframe.style.CssSelectorPart_ = function(selectorPartString) {
409 // Only one CssSelectorPart instance should exist for a given string.
410 var cacheEntry =
411 goog.cssom.iframe.style.CssSelectorPart_.instances_[selectorPartString];
412 if (cacheEntry) {
413 return cacheEntry;
414 }
415
416 // Optimization to avoid the more-expensive lookahead.
417 var identifiers;
418 if (selectorPartString.match(/[#\.]/)) {
419 // Lookahead regexp, won't work on IE 5.0.
420 identifiers = selectorPartString.split(/(?=[#\.])/);
421 } else {
422 identifiers = [selectorPartString];
423 }
424 var properties = {};
425 for (var i = 0; i < identifiers.length; i++) {
426 var identifier = identifiers[i];
427 if (identifier.charAt(0) == '.') {
428 properties.className = identifier.substring(1, identifier.length);
429 } else if (identifier.charAt(0) == '#') {
430 properties.id = identifier.substring(1, identifier.length);
431 } else {
432 properties.tagName = identifier.toUpperCase();
433 }
434 }
435 this.inputString_ = selectorPartString;
436 this.matchProperties_ = properties;
437 this.testedElements_ = {};
438 goog.cssom.iframe.style.CssSelectorPart_.instances_[selectorPartString] =
439 this;
440 };
441
442
443 /**
444 * Cache of existing CssSelectorPart_ instances.
445 * @type {Object}
446 * @private
447 */
448 goog.cssom.iframe.style.CssSelectorPart_.instances_ = {};
449
450
451 /**
452 * Test whether an element matches this selector part, considered in isolation.
453 * @param {Object} elementInfo Element properties to test.
454 * @return {boolean} Whether the element matched.
455 */
456 goog.cssom.iframe.style.CssSelectorPart_.prototype.testElement = function(
457 elementInfo) {
458
459 var elementUid = elementInfo.uid;
460 var cachedMatch = this.testedElements_[elementUid];
461 if (typeof cachedMatch != 'undefined') {
462 return cachedMatch;
463 }
464
465 var matchProperties = this.matchProperties_;
466 var testTag = matchProperties.tagName;
467 var testClass = matchProperties.className;
468 var testId = matchProperties.id;
469
470 var matched = true;
471 if (testTag && testTag != '*' && testTag != elementInfo.nodeName) {
472 matched = false;
473 } else if (testId && testId != elementInfo.id) {
474 matched = false;
475 } else if (testClass && !elementInfo.classNames[testClass]) {
476 matched = false;
477 }
478
479 this.testedElements_[elementUid] = matched;
480 return matched;
481 };
482
483
484
485 /**
486 * Represents an element and all its parent/ancestor nodes.
487 * This class exists as an optimization so we run tests on an element
488 * hierarchy multiple times without walking the dom each time.
489 * @param {Element} el The DOM element whose ancestry should be stored.
490 * @constructor
491 * @private
492 */
493 goog.cssom.iframe.style.NodeAncestry_ = function(el) {
494 var node = el;
495 var nodeUid = goog.getUid(node);
496
497 // Return an existing object from the cache if one exits for this node.
498 var ancestry = goog.cssom.iframe.style.NodeAncestry_.instances_[nodeUid];
499 if (ancestry) {
500 return ancestry;
501 }
502
503 var nodes = [];
504 do {
505 var nodeInfo = {id: node.id, nodeName: node.nodeName};
506 nodeInfo.uid = goog.getUid(nodeInfo);
507 var className = node.className;
508 var classNamesLookup = {};
509 if (className) {
510 var classNames = goog.dom.classlist.get(goog.asserts.assertElement(node));
511 for (var i = 0; i < classNames.length; i++) {
512 classNamesLookup[classNames[i]] = 1;
513 }
514 }
515 nodeInfo.classNames = classNamesLookup;
516 nodes.unshift(nodeInfo);
517 } while (node = node.parentNode);
518
519 /**
520 * Array of nodes in order of hierarchy from the top of the document
521 * to the node passed to the constructor
522 * @type {Array<Node>}
523 */
524 this.nodes = nodes;
525
526 this.uid = goog.getUid(this);
527 goog.cssom.iframe.style.NodeAncestry_.instances_[nodeUid] = this;
528 };
529
530
531 /**
532 * Object for caching existing NodeAncestry instances.
533 * @private
534 */
535 goog.cssom.iframe.style.NodeAncestry_.instances_ = {};
536
537
538 /**
539 * Throw away all cached dom information. Call this if you've modified
540 * the structure or class/id attributes of your document and you want
541 * to recalculate the currently applied CSS rules.
542 */
543 goog.cssom.iframe.style.resetDomCache = function() {
544 goog.cssom.iframe.style.NodeAncestry_.instances_ = {};
545 };
546
547
548 /**
549 * Inspects a document and returns all active rule sets
550 * @param {Document} doc The document from which to read CSS rules.
551 * @return {!Array<goog.cssom.iframe.style.CssRuleSet_>} An array of CssRuleSet
552 * objects representing all the active rule sets in the document.
553 * @private
554 */
555 goog.cssom.iframe.style.getRuleSetsFromDocument_ = function(doc) {
556 var ruleSets = [];
557 var styleSheets = goog.cssom.getAllCssStyleSheets(doc.styleSheets);
558 for (var i = 0, styleSheet; styleSheet = styleSheets[i]; i++) {
559 var domRuleSets = goog.cssom.getCssRulesFromStyleSheet(styleSheet);
560 if (domRuleSets && domRuleSets.length) {
561 for (var j = 0, n = domRuleSets.length; j < n; j++) {
562 var ruleSet = new goog.cssom.iframe.style.CssRuleSet_();
563 if (ruleSet.initializeFromCssRule(domRuleSets[j])) {
564 ruleSets.push(ruleSet);
565 }
566 }
567 }
568 }
569 return ruleSets;
570 };
571
572
573 /**
574 * Static object to cache rulesets read from documents. Inspecting all
575 * active css rules is an expensive operation, so its best to only do
576 * it once and then cache the results.
577 * @type {Object}
578 * @private
579 */
580 goog.cssom.iframe.style.ruleSetCache_ = {};
581
582
583 /**
584 * Cache of ruleset objects keyed by document unique ID.
585 * @type {Object}
586 * @private
587 */
588 goog.cssom.iframe.style.ruleSetCache_.ruleSetCache_ = {};
589
590
591 /**
592 * Loads ruleset definitions from a document. If the cache already
593 * has rulesets for this document the cached version will be replaced.
594 * @param {Document} doc The document from which to load rulesets.
595 */
596 goog.cssom.iframe.style.ruleSetCache_.loadRuleSetsForDocument = function(doc) {
597 var docUid = goog.getUid(doc);
598 goog.cssom.iframe.style.ruleSetCache_.ruleSetCache_[docUid] =
599 goog.cssom.iframe.style.getRuleSetsFromDocument_(doc);
600 };
601
602
603 /**
604 * Retrieves the array of css rulesets for this document. A cached
605 * version will be used when possible.
606 * @param {Document} doc The document for which to get rulesets.
607 * @return {!Array<goog.cssom.iframe.style.CssRuleSet_>} An array of CssRuleSet
608 * objects representing the css rule sets in the supplied document.
609 */
610 goog.cssom.iframe.style.ruleSetCache_.getRuleSetsForDocument = function(doc) {
611 var docUid = goog.getUid(doc);
612 var cache = goog.cssom.iframe.style.ruleSetCache_.ruleSetCache_;
613 if (!cache[docUid]) {
614 goog.cssom.iframe.style.ruleSetCache_.loadRuleSetsForDocument(doc);
615 }
616 // Build a cloned copy of rulesets array, so if object in the returned array
617 // get modified future calls will still return the original unmodified
618 // versions.
619 var ruleSets = cache[docUid];
620 var ruleSetsCopy = [];
621 for (var i = 0; i < ruleSets.length; i++) {
622 ruleSetsCopy.push(ruleSets[i].clone());
623 }
624 return ruleSetsCopy;
625 };
626
627
628 /**
629 * Array of CSS properties that are inherited by child nodes, according to
630 * the CSS 2.1 spec. Properties that may be set to relative values, such
631 * as font-size, and line-height, are omitted.
632 * @type {Array<string>}
633 * @private
634 */
635 goog.cssom.iframe.style.inheritedProperties_ = [
636 'color',
637 'visibility',
638 'quotes',
639 'list-style-type',
640 'list-style-image',
641 'list-style-position',
642 'list-style',
643 'page-break-inside',
644 'orphans',
645 'widows',
646 'font-family',
647 'font-style',
648 'font-variant',
649 'font-weight',
650 'text-indent',
651 'text-align',
652 'text-transform',
653 'white-space',
654 'caption-side',
655 'border-collapse',
656 'border-spacing',
657 'empty-cells',
658 'cursor'
659 ];
660
661
662 /**
663 * Array of CSS 2.1 properties that directly effect text nodes.
664 * @type {Array<string>}
665 * @private
666 */
667 goog.cssom.iframe.style.textProperties_ = [
668 'font-family', 'font-size', 'font-weight', 'font-variant', 'font-style',
669 'color', 'text-align', 'text-decoration', 'text-indent', 'text-transform',
670 'letter-spacing', 'white-space', 'word-spacing'
671 ];
672
673
674 /**
675 * Reads the current css rules from element's document, and returns them
676 * rewriting selectors so that any rules that formerly applied to element will
677 * be applied to doc.body. This makes it possible to replace a block in a page
678 * with an iframe and preserve the css styling of the contents.
679 *
680 * @param {Element} element The element for which context should be calculated.
681 * @param {boolean=} opt_forceRuleSetCacheUpdate Flag to force the internal
682 * cache of rulesets to refresh itself before we read the same.
683 * @param {boolean=} opt_copyBackgroundContext Flag indicating that if the
684 * {@code element} has a transparent background, background rules
685 * from the nearest ancestor element(s) that have background-color
686 * and/or background-image set should be copied.
687 * @return {string} String containing all CSS rules present in the original
688 * document, with modified selectors.
689 * @see goog.cssom.iframe.style.getBackgroundContext.
690 */
691 goog.cssom.iframe.style.getElementContext = function(
692 element, opt_forceRuleSetCacheUpdate, opt_copyBackgroundContext) {
693 var sourceDocument = element.ownerDocument;
694 if (opt_forceRuleSetCacheUpdate) {
695 goog.cssom.iframe.style.ruleSetCache_.loadRuleSetsForDocument(
696 sourceDocument);
697 }
698 var ruleSets = goog.cssom.iframe.style.ruleSetCache_.getRuleSetsForDocument(
699 sourceDocument);
700
701 var elementAncestry = new goog.cssom.iframe.style.NodeAncestry_(element);
702 var bodySelectorPart = new goog.cssom.iframe.style.CssSelectorPart_('body');
703
704 for (var i = 0; i < ruleSets.length; i++) {
705 var ruleSet = ruleSets[i];
706 var selectors = ruleSet.selectors;
707 // Cache selectors.length since we may be adding rules in the loop.
708 var ruleCount = selectors.length;
709 for (var j = 0; j < ruleCount; j++) {
710 var selector = selectors[j];
711 // Test whether all or part of this selector would match
712 // this element or one of its ancestors
713 var match = selector.matchElementAncestry(elementAncestry);
714 if (match) {
715 var ruleIndex = match.selectorPartIndex;
716 var selectorParts = selector.parts;
717 var lastSelectorPartIndex = selectorParts.length - 1;
718 var selectorCopy;
719 if (match.elementIndex == elementAncestry.nodes.length - 1 ||
720 ruleIndex < lastSelectorPartIndex) {
721 // Either the first part(s) of the selector matched this element,
722 // or the first part(s) of the selector matched a parent element
723 // and there are more parts of the selector that could target
724 // children of this element.
725 // So we inject a new selector, replacing the part that matched this
726 // element with 'body' so it will continue to match.
727 var selectorPartsCopy = selectorParts.concat();
728 selectorPartsCopy.splice(0, ruleIndex + 1, bodySelectorPart);
729 selectorCopy = new goog.cssom.iframe.style.CssSelector_();
730 selectorCopy.parts = selectorPartsCopy;
731 selectors.push(selectorCopy);
732 } else if (ruleIndex > 0 && ruleIndex == lastSelectorPartIndex) {
733 // The rule didn't match this element, but the entire rule did
734 // match an ancestor element. In this case we want to copy
735 // just the last part of the rule, to give it a chance to be applied
736 // to additional matching elements inside this element.
737 // Example DOM structure: body > div.funky > ul > li#editme
738 // Example CSS selector: .funky ul
739 // New CSS selector: body ul
740 selectorCopy = new goog.cssom.iframe.style.CssSelector_();
741 selectorCopy.parts =
742 [bodySelectorPart, selectorParts[lastSelectorPartIndex]];
743 selectors.push(selectorCopy);
744 }
745 }
746 }
747 }
748
749 // Insert a new ruleset, setting the current inheritable styles of this
750 // element as the defaults for everything under in the frame.
751 var defaultPropertiesRuleSet = new goog.cssom.iframe.style.CssRuleSet_();
752 var computedStyle = goog.cssom.iframe.style.getComputedStyleObject_(element);
753
754 // Copy inheritable styles so they are applied to everything under HTML.
755 var htmlSelector = new goog.cssom.iframe.style.CssSelector_();
756 htmlSelector.parts = [new goog.cssom.iframe.style.CssSelectorPart_('html')];
757 defaultPropertiesRuleSet.selectors = [htmlSelector];
758 var defaultProperties = {};
759 for (var i = 0, prop; prop = goog.cssom.iframe.style.inheritedProperties_[i];
760 i++) {
761 defaultProperties[prop] = computedStyle[goog.string.toCamelCase(prop)];
762 }
763 defaultPropertiesRuleSet.setDeclarationTextFromObject(defaultProperties);
764 ruleSets.push(defaultPropertiesRuleSet);
765
766 var bodyRuleSet = new goog.cssom.iframe.style.CssRuleSet_();
767 var bodySelector = new goog.cssom.iframe.style.CssSelector_();
768 bodySelector.parts = [new goog.cssom.iframe.style.CssSelectorPart_('body')];
769 // Core set of sane property values for BODY, to prevent copied
770 // styles from completely breaking the display.
771 var bodyProperties = {
772 position: 'relative',
773 top: '0',
774 left: '0',
775 right: 'auto', // Override any existing right value so 'left' works.
776 display: 'block',
777 visibility: 'visible'
778 };
779 // Text formatting property values, to keep text nodes directly under BODY
780 // looking right.
781 for (i = 0; prop = goog.cssom.iframe.style.textProperties_[i]; i++) {
782 bodyProperties[prop] = computedStyle[goog.string.toCamelCase(prop)];
783 }
784 if (opt_copyBackgroundContext &&
785 goog.cssom.iframe.style.isTransparentValue_(
786 computedStyle['backgroundColor'])) {
787 // opt_useAncestorBackgroundRules means that, if the original element
788 // has a transparent background, background properties rules should be
789 // added to explicitly make the body have the same background appearance
790 // as in the original element, even if its positioned somewhere else
791 // in the DOM.
792 var bgProperties = goog.cssom.iframe.style.getBackgroundContext(element);
793 bodyProperties['background-color'] = bgProperties['backgroundColor'];
794 var elementBgImage = computedStyle['backgroundImage'];
795 if (!elementBgImage || elementBgImage == 'none') {
796 bodyProperties['background-image'] = bgProperties['backgroundImage'];
797 bodyProperties['background-repeat'] = bgProperties['backgroundRepeat'];
798 bodyProperties['background-position'] =
799 bgProperties['backgroundPosition'];
800 }
801 }
802
803 bodyRuleSet.setDeclarationTextFromObject(bodyProperties, true);
804 bodyRuleSet.selectors = [bodySelector];
805 ruleSets.push(bodyRuleSet);
806
807 // Write outputTextParts to doc.
808 var ruleSetStrings = [];
809 ruleCount = ruleSets.length;
810 for (i = 0; i < ruleCount; i++) {
811 ruleSets[i].writeToArray(ruleSetStrings);
812 }
813 return ruleSetStrings.join('');
814 };
815
816
817 /**
818 * Tests whether a value is equivalent to 'transparent'.
819 * @param {string} colorValue The value to test.
820 * @return {boolean} Whether the value is transparent.
821 * @private
822 */
823 goog.cssom.iframe.style.isTransparentValue_ = function(colorValue) {
824 return colorValue == 'transparent' || colorValue == 'rgba(0, 0, 0, 0)';
825 };
826
827
828 /**
829 * Returns an object containing the set of computedStyle/currentStyle
830 * values for the given element. Note that this should be used with
831 * caution as it ignores the fact that currentStyle and computedStyle
832 * are not the same for certain properties.
833 *
834 * @param {Element} element The element whose computed style to return.
835 * @return {Object} Object containing style properties and values.
836 * @private
837 */
838 goog.cssom.iframe.style.getComputedStyleObject_ = function(element) {
839 // Return an object containing the element's computedStyle/currentStyle.
840 // The resulting object can be re-used to read multiple properties, which
841 // is faster than calling goog.style.getComputedStyle every time.
842 return element.currentStyle ||
843 goog.dom.getOwnerDocument(element).defaultView.getComputedStyle(
844 element, '') ||
845 {};
846 };
847
848
849 /**
850 * RegExp that splits a value like "10px" or "-1em" into parts.
851 * @private
852 * @type {RegExp}
853 */
854 goog.cssom.iframe.style.valueWithUnitsRegEx_ = /^(-?)([0-9]+)([a-z]*|%)/;
855
856
857 /**
858 * Given an object containing a set of styles, returns a two-element array
859 * containing the values of background-position-x and background-position-y.
860 * @param {Object} styleObject Object from which to read style properties.
861 * @return {Array<string>} The background-position values in the order [x, y].
862 * @private
863 */
864 goog.cssom.iframe.style.getBackgroundXYValues_ = function(styleObject) {
865 // Gecko only has backgroundPosition, containing both values.
866 // IE has only backgroundPositionX/backgroundPositionY.
867 // WebKit has both.
868 if (styleObject['backgroundPositionY']) {
869 return [
870 styleObject['backgroundPositionX'], styleObject['backgroundPositionY']
871 ];
872 } else {
873 return (styleObject['backgroundPosition'] || '0 0').split(' ');
874 }
875 };
876
877
878 /**
879 * Generates a set of CSS properties that can be used to make another
880 * element's background look like the background of a given element.
881 * This is useful when you want to copy the CSS context of an element,
882 * but the element's background is transparent. In the original context
883 * you would see the ancestor's backround color/image showing through,
884 * but in the new context there might be a something different underneath.
885 * Note that this assumes the element you're copying context from has a
886 * fairly standard positioning/layout - it assumes that when the element
887 * has a transparent background what you're going to see through it is its
888 * ancestors.
889 * @param {Element} element The element from which to copy background styles.
890 * @return {!Object} Object containing background* properties.
891 */
892 goog.cssom.iframe.style.getBackgroundContext = function(element) {
893 var propertyValues = {'backgroundImage': 'none'};
894 var ancestor = element;
895 var currentIframeWindow;
896 // Walk up the DOM tree to find the ancestor nodes whose backgrounds
897 // may be visible underneath this element. Background-image and
898 // background-color don't have to come from the same node, but as soon
899 // an element with background-color is found there's no need to continue
900 // because backgrounds farther up the chain won't be visible.
901 // (This implementation is not sophisticated enough to handle opacity,
902 // or multple layered partially-transparent background images.)
903 while ((ancestor = /** @type {!Element} */ (ancestor.parentNode)) &&
904 ancestor.nodeType == goog.dom.NodeType.ELEMENT) {
905 var computedStyle =
906 goog.cssom.iframe.style.getComputedStyleObject_(ancestor);
907 // Copy background color if a non-transparent value is found.
908 var backgroundColorValue = computedStyle['backgroundColor'];
909 if (!goog.cssom.iframe.style.isTransparentValue_(backgroundColorValue)) {
910 propertyValues['backgroundColor'] = backgroundColorValue;
911 }
912 // If a background image value is found, copy background-image,
913 // background-repeat, and background-position.
914 if (computedStyle['backgroundImage'] &&
915 computedStyle['backgroundImage'] != 'none') {
916 propertyValues['backgroundImage'] = computedStyle['backgroundImage'];
917 propertyValues['backgroundRepeat'] = computedStyle['backgroundRepeat'];
918 // Calculate the offset between the original element and the element
919 // providing the background image, so the background position can be
920 // adjusted.
921 var relativePosition;
922 if (currentIframeWindow) {
923 relativePosition =
924 goog.style.getFramedPageOffset(element, currentIframeWindow);
925 var frameElement = currentIframeWindow.frameElement;
926 var iframeRelativePosition = goog.style.getRelativePosition(
927 /** @type {!Element} */ (frameElement), ancestor);
928 var iframeBorders = goog.style.getBorderBox(frameElement);
929 relativePosition.x += iframeRelativePosition.x + iframeBorders.left;
930 relativePosition.y += iframeRelativePosition.y + iframeBorders.top;
931 } else {
932 relativePosition = goog.style.getRelativePosition(element, ancestor);
933 }
934 var backgroundXYValues =
935 goog.cssom.iframe.style.getBackgroundXYValues_(computedStyle);
936 // Parse background-repeat-* values in the form "10px", and adjust them.
937 for (var i = 0; i < 2; i++) {
938 var positionValue = backgroundXYValues[i];
939 var coordinate = i == 0 ? 'X' : 'Y';
940 var positionProperty = 'backgroundPosition' + coordinate;
941 // relative position to its ancestor.
942 var positionValueParts =
943 goog.cssom.iframe.style.valueWithUnitsRegEx_.exec(positionValue);
944 if (positionValueParts) {
945 var value =
946 parseInt(positionValueParts[1] + positionValueParts[2], 10);
947 var units = positionValueParts[3];
948 // This only attempts to handle pixel values for now (plus
949 // '0anything', which is equivalent to 0px).
950 // TODO(user) Convert non-pixel values to pixels when possible.
951 if (value == 0 || units == 'px') {
952 value -=
953 (coordinate == 'X' ? relativePosition.x : relativePosition.y);
954 }
955 positionValue = value + units;
956 }
957 propertyValues[positionProperty] = positionValue;
958 }
959 propertyValues['backgroundPosition'] =
960 propertyValues['backgroundPositionX'] + ' ' +
961 propertyValues['backgroundPositionY'];
962 }
963 if (propertyValues['backgroundColor']) {
964 break;
965 }
966 if (ancestor.tagName == goog.dom.TagName.HTML) {
967 try {
968 currentIframeWindow = goog.dom.getWindow(
969 /** @type {Document} */ (ancestor.parentNode));
970 // This could theoretically throw a security exception if the parent
971 // iframe is in a different domain.
972 ancestor = currentIframeWindow.frameElement;
973 if (!ancestor) {
974 // Loop has reached the top level window.
975 break;
976 }
977 } catch (e) {
978 // We don't have permission to go up to the parent window, stop here.
979 break;
980 }
981 }
982 }
983 return propertyValues;
984 };