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;
}
