CSSValueList* CSSVariablesDeclaration::getParsedVariable(const String& variableName) { StyleBase* result = m_variablesMap.get(variableName).get(); if (result->isValueList()) return static_cast<CSSValueList*>(result); return 0; }
StyleSheet* StyleBase::stylesheet() { StyleBase *b = this; while (b && !b->isStyleSheet()) b = b->parent(); return static_cast<StyleSheet*>(b); }
void MediaList::notifyChanged() { for (StyleBase* p = parent(); p; p = p->parent()) { if (p->isCSSStyleSheet()) return static_cast<CSSStyleSheet*>(p)->styleSheetChanged(); } }
static GroupId calculateGroupId(StyleBase* styleBase) { ASSERT(styleBase); StyleBase* current = styleBase; StyleSheet* styleSheet = 0; while (true) { // Special case: CSSStyleDeclarations might be either inline and in this case // we need to group them with their node or regular ones. if (current->isMutableStyleDeclaration()) { CSSMutableStyleDeclaration* cssMutableStyleDeclaration = static_cast<CSSMutableStyleDeclaration*>(current); if (cssMutableStyleDeclaration->isInlineStyleDeclaration()) { ASSERT(cssMutableStyleDeclaration->parent()->isStyleSheet()); return calculateGroupId(cssMutableStyleDeclaration->node()); } // Either we have no parent, or this parent is a CSSRule. ASSERT(cssMutableStyleDeclaration->parent() == cssMutableStyleDeclaration->parentRule()); } if (current->isStyleSheet()) styleSheet = static_cast<StyleSheet*>(current); StyleBase* parent = current->parent(); if (!parent) break; current = parent; } if (styleSheet) { if (Node* ownerNode = styleSheet->ownerNode()) return calculateGroupId(ownerNode); return GroupId(styleSheet); } return GroupId(current); }
String CSSVariablesDeclaration::getVariableValue(const String& variableName) { StyleBase* val = m_variablesMap.get(variableName).get(); if (val) return val->cssText(); return ""; }
CSSMutableStyleDeclaration* CSSVariablesDeclaration::getParsedVariableDeclarationBlock(const String& variableName) { StyleBase* result = m_variablesMap.get(variableName).get(); if (result->isMutableStyleDeclaration()) return static_cast<CSSMutableStyleDeclaration*>(result); return 0; }
void PageSerializer::serializeCSSStyleSheet(CSSStyleSheet* styleSheet, const KURL& url) { StringBuilder cssText; for (unsigned i = 0; i < styleSheet->length(); ++i) { StyleBase* item = styleSheet->item(i); String itemText = item->cssText(); if (!itemText.isEmpty()) { cssText.append(itemText); if (i < styleSheet->length() - 1) cssText.append("\n\n"); } // Some rules have resources associated with them that we need to retrieve. if (item->isImportRule()) { CSSImportRule* importRule = static_cast<CSSImportRule*>(item); KURL importURL = styleSheet->document()->completeURL(importRule->href()); if (m_resourceURLs.contains(importURL)) continue; serializeCSSStyleSheet(importRule->styleSheet(), importURL); } else if (item->isFontFaceRule()) { // FIXME: Add support for font face rule. It is not clear to me at this point if the actual otf/eot file can // be retrieved from the CSSFontFaceRule object. } else if (item->isStyleRule()) retrieveResourcesForCSSRule(static_cast<CSSStyleRule*>(item)); } if (url.isValid() && !m_resourceURLs.contains(url)) { // FIXME: We should check whether a charset has been specified and if none was found add one. TextEncoding textEncoding(styleSheet->charset()); ASSERT(textEncoding.isValid()); String textString = cssText.toString(); CString text = textEncoding.encode(textString.characters(), textString.length(), EntitiesForUnencodables); m_resources->append(Resource(url, String("text/css"), SharedBuffer::create(text.data(), text.length()))); m_resourceURLs.add(url); } }
void CSSMutableStyleDeclaration::setNeedsStyleRecalc() { if (m_node) { // FIXME: Ideally, this should be factored better and there // should be a subclass of CSSMutableStyleDeclaration just // for inline style declarations that handles this bool isInlineStyleDeclaration = m_node->isStyledElement() && this == static_cast<StyledElement*>(m_node)->inlineStyleDecl(); if (isInlineStyleDeclaration) { m_node->setNeedsStyleRecalc(InlineStyleChange); static_cast<StyledElement*>(m_node)->invalidateStyleAttribute(); if (m_node->document()) InspectorInstrumentation::didInvalidateStyleAttr(m_node->document(), m_node); } else m_node->setNeedsStyleRecalc(FullStyleChange); return; } StyleBase* root = this; while (StyleBase* parent = root->parent()) root = parent; if (root->isCSSStyleSheet()) { if (Document* document = static_cast<CSSStyleSheet*>(root)->document()) document->styleSelectorChanged(DeferRecalcStyle); } }
void CSSVariablesDeclaration::setChanged() { // FIXME: Make this much better (it has the same problem CSSMutableStyleDeclaration does). StyleBase* root = this; while (StyleBase* parent = root->parent()) root = parent; if (root->isCSSStyleSheet()) static_cast<CSSStyleSheet*>(root)->doc()->updateStyleSelector(); }
bool CSSStyleSheet::isLoading() { unsigned len = length(); for (unsigned i = 0; i < len; ++i) { StyleBase* rule = item(i); if (rule->isImportRule() && static_cast<CSSImportRule*>(rule)->isLoading()) return true; } return false; }
CSSMutableStyleDeclaration* CSSVariablesDeclaration::getParsedVariableDeclarationBlock(const String&) { // FIXME: Disabling declarations as variable values for now since they no longer have a common base class with CSSValues. #if 0 StyleBase* result = m_variablesMap.get(variableName).get(); if (result->isMutableStyleDeclaration()) return static_cast<CSSMutableStyleDeclaration*>(result); #endif return 0; }
CSSRule* CSSRuleList::item(unsigned index) { if (m_list) { StyleBase* rule = m_list->item(index); ASSERT(!rule || rule->isRule()); return static_cast<CSSRule*>(rule); } if (index < m_lstCSSRules.size()) return m_lstCSSRules[index].get(); return 0; }
bool XSLStyleSheet::isLoading() { unsigned len = length(); for (unsigned i = 0; i < len; ++i) { StyleBase* rule = item(i); if (rule->isImportRule()) { XSLImportRule* import = static_cast<XSLImportRule*>(rule); if (import->isLoading()) return true; } } return false; }
CSSRuleList::CSSRuleList(StyleList* list, bool omitCharsetRules) { m_list = list; if (list && omitCharsetRules) { m_list = 0; unsigned len = list->length(); for (unsigned i = 0; i < len; ++i) { StyleBase* style = list->item(i); if (style->isRule() && !style->isCharsetRule()) append(static_cast<CSSRule*>(style)); } } }
void XSLStyleSheet::clearDocuments() { m_stylesheetDoc = 0; unsigned len = length(); for (unsigned i = 0; i < len; ++i) { StyleBase* rule = item(i); if (rule->isImportRule()) { XSLImportRule* import = static_cast<XSLImportRule*>(rule); if (import->styleSheet()) import->styleSheet()->clearDocuments(); } } }
void CSSStyleSheet::styleSheetChanged() { StyleBase* root = this; while (StyleBase* parent = root->parent()) root = parent; Document* documentToUpdate = root->isCSSStyleSheet() ? static_cast<CSSStyleSheet*>(root)->document() : 0; /* FIXME: We don't need to do everything updateStyleSelector does, * basically we just need to recreate the document's selector with the * already existing style sheets. */ if (documentToUpdate) documentToUpdate->styleSelectorChanged(DeferRecalcStyle); }
Document* CSSStyleSheet::document() { StyleBase* styleObject = this; while (styleObject) { if (styleObject->isCSSStyleSheet()) { Node* ownerNode = static_cast<CSSStyleSheet*>(styleObject)->ownerNode(); if (ownerNode) return ownerNode->document(); } if (styleObject->isRule()) styleObject = static_cast<CSSRule*>(styleObject)->parentStyleSheet(); else styleObject = styleObject->parent(); } return 0; }
void CSSMutableStyleDeclaration::setNeedsStyleRecalc() { if (m_node) { if (isInlineStyleDeclaration()) { m_node->setNeedsStyleRecalc(InlineStyleChange); static_cast<StyledElement*>(m_node)->invalidateStyleAttribute(); if (m_node->document()) InspectorInstrumentation::didInvalidateStyleAttr(m_node->document(), m_node); } else m_node->setNeedsStyleRecalc(FullStyleChange); return; } StyleBase* root = this; while (StyleBase* parent = root->parent()) root = parent; if (root->isCSSStyleSheet()) { if (Document* document = static_cast<CSSStyleSheet*>(root)->document()) document->styleSelectorChanged(DeferRecalcStyle); } }
void CSSImportRule::insertedIntoParent() { CSSStyleSheet* parentSheet = parentStyleSheet(); if (!parentSheet || !parentSheet->document()) return; CachedResourceLoader* cachedResourceLoader = parentSheet->document()->cachedResourceLoader(); if (!cachedResourceLoader) return; String absHref = m_strHref; if (!parentSheet->finalURL().isNull()) // use parent styleheet's URL as the base URL absHref = KURL(parentSheet->finalURL(), m_strHref).string(); // Check for a cycle in our import chain. If we encounter a stylesheet // in our parent chain with the same URL, then just bail. StyleBase* root = this; for (StyleBase* curr = parent(); curr; curr = curr->parent()) { // FIXME: This is wrong if the finalURL was updated via document::updateBaseURL. if (curr->isCSSStyleSheet() && absHref == static_cast<CSSStyleSheet*>(curr)->finalURL().string()) return; root = curr; } ResourceRequest request(parentSheet->document()->completeURL(absHref)); if (parentSheet->isUserStyleSheet()) m_cachedSheet = cachedResourceLoader->requestUserCSSStyleSheet(request, parentSheet->charset()); else m_cachedSheet = cachedResourceLoader->requestCSSStyleSheet(request, parentSheet->charset()); if (m_cachedSheet) { // if the import rule is issued dynamically, the sheet may be // removed from the pending sheet count, so let the doc know // the sheet being imported is pending. if (parentSheet && parentSheet->loadCompleted() && root == parentSheet) parentSheet->startLoadingDynamicSheet(); m_loading = true; m_cachedSheet->addClient(this); } }
void CSSMutableStyleDeclaration::setChanged() { if (m_node) { // FIXME: Ideally, this should be factored better and there // should be a subclass of CSSMutableStyleDeclaration just // for inline style declarations that handles this bool isInlineStyleDeclaration = m_node->isStyledElement() && this == static_cast<StyledElement*>(m_node)->inlineStyleDecl(); if (isInlineStyleDeclaration) { m_node->setChanged(InlineStyleChange); static_cast<StyledElement*>(m_node)->invalidateStyleAttribute(); } else m_node->setChanged(FullStyleChange); return; } // FIXME: quick&dirty hack for KDE 3.0... make this MUCH better! (Dirk) StyleBase* root = this; while (StyleBase* parent = root->parent()) root = parent; if (root->isCSSStyleSheet()) static_cast<CSSStyleSheet*>(root)->doc()->updateStyleSelector(); }
void CSSStyleSheet::addSubresourceStyleURLs(ListHashSet<KURL>& urls) { Deque<CSSStyleSheet*> styleSheetQueue; styleSheetQueue.append(this); while (!styleSheetQueue.isEmpty()) { CSSStyleSheet* styleSheet = styleSheetQueue.takeFirst(); for (unsigned i = 0; i < styleSheet->length(); ++i) { StyleBase* styleBase = styleSheet->item(i); if (!styleBase->isRule()) continue; CSSRule* rule = static_cast<CSSRule*>(styleBase); if (rule->isImportRule()) { if (CSSStyleSheet* ruleStyleSheet = static_cast<CSSImportRule*>(rule)->styleSheet()) styleSheetQueue.append(ruleStyleSheet); } rule->addSubresourceStyleURLs(urls); } } }
xmlDocPtr XSLStyleSheet::locateStylesheetSubResource(xmlDocPtr parentDoc, const xmlChar* uri) { bool matchedParent = (parentDoc == document()); unsigned len = length(); for (unsigned i = 0; i < len; ++i) { StyleBase* rule = item(i); if (rule->isImportRule()) { XSLImportRule* import = static_cast<XSLImportRule*>(rule); XSLStyleSheet* child = import->styleSheet(); if (!child) continue; if (matchedParent) { if (child->processed()) continue; // libxslt has been given this sheet already. // Check the URI of the child stylesheet against the doc URI. // In order to ensure that libxml canonicalized both URLs, we get the original href // string from the import rule and canonicalize it using libxml before comparing it // with the URI argument. CString importHref = import->href().utf8(); xmlChar* base = xmlNodeGetBase(parentDoc, (xmlNodePtr)parentDoc); xmlChar* childURI = xmlBuildURI((const xmlChar*)importHref.data(), base); bool equalURIs = xmlStrEqual(uri, childURI); xmlFree(base); xmlFree(childURI); if (equalURIs) { child->markAsProcessed(); return child->document(); } } else { xmlDocPtr result = import->styleSheet()->locateStylesheetSubResource(parentDoc, uri); if (result) return result; } } } return 0; }