File indexing completed on 2024-04-28 15:22:40

 /**
  * This file is part of the DOM implementation for KDE.
  *
  * Copyright 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright 2002-2003 Dirk Mueller (mueller@kde.org)
  * Copyright 2002-2008 Apple Computer, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "css_ruleimpl.h"
 #include "css_stylesheetimpl.h"
 #include "css_valueimpl.h"
 #include "cssparser.h"
 
 #include <dom/css_rule.h>
 #include <dom/css_stylesheet.h>
 #include <dom/dom_exception.h>
 #include <dom/dom_string.h>
 
 #include <xml/dom_docimpl.h>
 
 using namespace DOM;
 
 CSSStyleSheetImpl *CSSRuleImpl::parentStyleSheet() const
 {
     return (m_parent && m_parent->isCSSStyleSheet())  ?
            static_cast<CSSStyleSheetImpl *>(m_parent) : nullptr;
 }
 
 CSSRuleImpl *CSSRuleImpl::parentRule() const
 {
     return (m_parent && m_parent->isRule())  ?
            static_cast<CSSRuleImpl *>(m_parent) : nullptr;
 }
 
 DOM::DOMString CSSRuleImpl::cssText() const
 {
     // ###
     return DOMString();
 }
 
 void CSSRuleImpl::setCssText(DOM::DOMString /*str*/)
 {
     // ###
 }
 
 // ---------------------------------------------------------------------------
 
 CSSFontFaceRuleImpl::CSSFontFaceRuleImpl(StyleBaseImpl *parent)
     : CSSRuleImpl(parent)
 {
     m_type = CSSRule::FONT_FACE_RULE;
     m_style = nullptr;
 }
 
 CSSFontFaceRuleImpl::~CSSFontFaceRuleImpl()
 {
     if (m_style) {
         m_style->deref();
     }
 }
 
 void CSSFontFaceRuleImpl::setDeclaration(CSSStyleDeclarationImpl *decl)
 {
     assert(!m_style);
     m_style = decl;
     if (m_style) {
         m_style->ref();
     }
 }
 
 DOMString CSSFontFaceRuleImpl::cssText() const
 {
     DOMString result("@font-face");
 
     result += " { ";
     result += m_style->cssText();
     result += "}";
 
     return result;
 }
 
 // --------------------------------------------------------------------------
 
 CSSImportRuleImpl::CSSImportRuleImpl(StyleBaseImpl *parent,
                                      const DOM::DOMString &href,
                                      MediaListImpl *media)
     : CSSRuleImpl(parent)
 {
     m_type = CSSRule::IMPORT_RULE;
 
     m_lstMedia = media;
     if (!m_lstMedia) {
         m_lstMedia = new MediaListImpl(this, DOMString());
     }
     m_lstMedia->setParent(this);
     m_lstMedia->ref();
 
     m_strHref = href;
     m_styleSheet = nullptr;
 
     m_cachedSheet = nullptr;
 
     init();
 }
 CSSImportRuleImpl::CSSImportRuleImpl(StyleBaseImpl *parent,
                                      const DOM::DOMString &href,
                                      const DOM::DOMString &media)
     : CSSRuleImpl(parent)
 {
     m_type = CSSRule::IMPORT_RULE;
 
     m_lstMedia = new MediaListImpl(this, media);
     m_lstMedia->ref();
 
     m_strHref = href;
     m_styleSheet = nullptr;
 
     m_cachedSheet = nullptr;
 
     init();
 }
 
 CSSImportRuleImpl::~CSSImportRuleImpl()
 {
     if (m_lstMedia) {
         m_lstMedia->setParent(nullptr);
         m_lstMedia->deref();
     }
     if (m_styleSheet) {
         m_styleSheet->setParent(nullptr);
         m_styleSheet->deref();
     }
 
     if (m_cachedSheet) {
         m_cachedSheet->deref(this);
     }
 }
 
 void CSSImportRuleImpl::checkLoaded() const
 {
     if (isLoading()) {
         return;
     }
     CSSRuleImpl::checkLoaded();
 }
 
 void CSSImportRuleImpl::setStyleSheet(const DOM::DOMString &url, const DOM::DOMString &sheetStr, const DOM::DOMString &charset, const DOM::DOMString &mimetype)
 {
     if (m_styleSheet) {
         m_styleSheet->setParent(nullptr);
         m_styleSheet->deref();
     }
     m_styleSheet = new CSSStyleSheetImpl(this, url);
     m_styleSheet->setCharset(charset);
     m_styleSheet->ref();
 
     CSSStyleSheetImpl *parent = parentStyleSheet();
     bool strict = parent ? parent->useStrictParsing() : true;
     DOMString sheet = sheetStr;
     if (strict && !khtml::isAcceptableCSSMimetype(mimetype)) {
         sheet = "";
     }
     m_styleSheet->parseString(sheet, strict);
     m_loading = false;
     m_done = true;
 
     checkLoaded();
 }
 
 void CSSImportRuleImpl::error(int /*err*/, const QString &/*text*/)
 {
     if (m_styleSheet) {
         m_styleSheet->setParent(nullptr);
         m_styleSheet->deref();
     }
     m_styleSheet = nullptr;
 
     m_loading = false;
     m_done = true;
 
     checkLoaded();
 }
 
 bool CSSImportRuleImpl::isLoading() const
 {
     return (m_loading || (m_styleSheet && m_styleSheet->isLoading()));
 }
 
 void CSSImportRuleImpl::init()
 {
     m_loading = 0;
     m_done = false;
     khtml::DocLoader *docLoader = nullptr;
     StyleBaseImpl *root = this;
     StyleBaseImpl *parent;
     while ((parent = root->parent())) {
         root = parent;
     }
     if (root->isCSSStyleSheet()) {
         docLoader = static_cast<CSSStyleSheetImpl *>(root)->docLoader();
     }
 
     DOMString absHref = m_strHref;
     CSSStyleSheetImpl *parentSheet = parentStyleSheet();
     if (!parentSheet->href().isNull()) {
         // use parent styleheet's URL as the base URL
         absHref = QUrl(parentSheet->href().string()).resolved(QUrl(m_strHref.string())).toString();
     }
     /*
         else {
           // use documents's URL as the base URL
           DocumentImpl *doc = static_cast<CSSStyleSheetImpl*>(root)->doc();
           absHref = QUrl(doc->URL()).resolved(QUrl(m_strHref.string())).toString();
         }
     */
     // Check for a cycle in our import chain.  If we encounter a stylesheet
     // in our parent chain with the same URL, then just bail.
     for (parent = static_cast<StyleBaseImpl *>(this)->parent();
             parent;
             parent = parent->parent())
         if (absHref == parent->baseURL().url()) {
             return;
         }
 
     m_cachedSheet = docLoader->requestStyleSheet(absHref, parentStyleSheet()->charset().string());
 
     if (m_cachedSheet) {
         // if the import rule is issued dynamically, the sheet may have already been
         // removed from the pending sheet count, so let the doc know
         // the sheet being imported is pending.
         checkPending();
 
         m_loading = true;
         m_cachedSheet->ref(this);
     }
 }
 
 DOMString CSSImportRuleImpl::cssText() const
 {
     DOMString result = "@import url(\"";
     result += m_strHref;
     result += "\")";
 
     if (m_lstMedia) {
         result += " ";
         result += m_lstMedia->mediaText();
     }
     result += ";";
 
     return result;
 }
 
 // --------------------------------------------------------------------------
 CSSMediaRuleImpl::CSSMediaRuleImpl(StyleBaseImpl *parent, MediaListImpl *mediaList, CSSRuleListImpl *ruleList)
     :   CSSRuleImpl(parent)
 {
     m_type = CSSRule::MEDIA_RULE;
     m_lstMedia = mediaList;
     if (m_lstMedia) {
         m_lstMedia->ref();
     }
     m_lstCSSRules = ruleList;
     m_lstCSSRules->ref();
 }
 
 CSSMediaRuleImpl::CSSMediaRuleImpl(StyleBaseImpl *parent)
     :   CSSRuleImpl(parent)
 {
     m_type = CSSRule::MEDIA_RULE;
     m_lstMedia = nullptr;
     m_lstCSSRules = new CSSRuleListImpl();
     m_lstCSSRules->ref();
 }
 
 CSSMediaRuleImpl::CSSMediaRuleImpl(StyleBaseImpl *parent, const DOM::DOMString &media)
     :   CSSRuleImpl(parent)
 {
     m_type = CSSRule::MEDIA_RULE;
     m_lstMedia = new MediaListImpl(this, media);
     m_lstMedia->ref();
     m_lstCSSRules = new CSSRuleListImpl();
     m_lstCSSRules->ref();
 }
 
 CSSMediaRuleImpl::~CSSMediaRuleImpl()
 {
     if (m_lstMedia) {
         m_lstMedia->setParent(nullptr);
         m_lstMedia->deref();
     }
     for (unsigned int i = 0; i < m_lstCSSRules->length(); ++i) {
         m_lstCSSRules->item(i)->setParent(nullptr);
     }
     m_lstCSSRules->deref();
 }
 
 unsigned long CSSMediaRuleImpl::append(CSSRuleImpl *rule)
 {
     return rule ? m_lstCSSRules->insertRule(rule, m_lstCSSRules->length()) : 0;
 }
 
 unsigned long CSSMediaRuleImpl::insertRule(const DOMString &rule,
         unsigned long index)
 {
     CSSParser p(strictParsing);
     CSSRuleImpl *newRule = p.parseRule(parentStyleSheet(), rule);
 
     return newRule ? m_lstCSSRules->insertRule(newRule, index) : 0;
 }
 
 DOM::DOMString CSSMediaRuleImpl::cssText() const
 {
     DOMString result("@media ");
     if (m_lstMedia) {
         result += m_lstMedia->mediaText();
         result += " ";
     }
     result += "{ \n";
 
     if (m_lstCSSRules) {
         unsigned len = m_lstCSSRules->length();
         for (unsigned i = 0; i < len; i++) {
             result += "  ";
             result += m_lstCSSRules->item(i)->cssText();
             result += "\n";
         }
     }
 
     result += "}";
     return result;
 }
 
 // ---------------------------------------------------------------------------
 
 CSSPageRuleImpl::CSSPageRuleImpl(StyleBaseImpl *parent)
     : CSSRuleImpl(parent)
 {
     m_type = CSSRule::PAGE_RULE;
     m_style = nullptr;
 }
 
 CSSPageRuleImpl::~CSSPageRuleImpl()
 {
     if (m_style) {
         m_style->deref();
     }
 }
 
 DOM::DOMString CSSPageRuleImpl::selectorText() const
 {
     // ###
     return DOMString();
 }
 
 void CSSPageRuleImpl::setSelectorText(DOM::DOMString /*str*/)
 {
     // ###
 }
 
 // --------------------------------------------------------------------------
 
 CSSStyleRuleImpl::CSSStyleRuleImpl(StyleBaseImpl *parent)
     : CSSRuleImpl(parent)
 {
     m_type = CSSRule::STYLE_RULE;
     m_style = nullptr;
     m_selector = nullptr;
 }
 
 CSSStyleRuleImpl::~CSSStyleRuleImpl()
 {
     if (m_style) {
         m_style->setParent(nullptr);
         m_style->deref();
     }
     qDeleteAll(*m_selector);
     delete m_selector;
 }
 
 DOMString CSSStyleRuleImpl::cssText() const
 {
     DOMString result(selectorText());
 
     result += " { ";
     result += m_style->cssText();
     result += "}";
 
     return result;
 }
 
 DOM::DOMString CSSStyleRuleImpl::selectorText() const
 {
     if (m_selector) {
         DOMString str;
         foreach (CSSSelector *s, *m_selector) {
             if (s != m_selector->at(0)) {
                 str += ", ";
             }
             str += s->selectorText();
         }
         return str;
     }
     return DOMString();
 }
 
 void CSSStyleRuleImpl::setSelectorText(DOM::DOMString /*str*/)
 {
     // ###
 }
 
 bool CSSStyleRuleImpl::parseString(const DOMString &/*string*/, bool)
 {
     // ###
     return false;
 }
 
 void CSSStyleRuleImpl::setDeclaration(CSSStyleDeclarationImpl *style)
 {
     if (m_style != style) {
         if (m_style) {
             m_style->deref();
         }
         m_style = style;
         if (m_style) {
             m_style->ref();
         }
     }
 }
 
 // --------------------------------------------------------------------
 
 CSSNamespaceRuleImpl::CSSNamespaceRuleImpl(StyleBaseImpl *parent, const DOMString &prefix, const DOMString &ns)
     : CSSRuleImpl(parent)
 {
     m_type      = CSSRule::NAMESPACE_RULE;
     m_prefix    = prefix;
     m_namespace = ns;
 }
 
 // --------------------------------------------------------------------
 
 CSSRuleListImpl::CSSRuleListImpl(StyleListImpl *const list, bool omitCharsetRules)
 {
     m_list = list;
     if (list && omitCharsetRules) {
         m_list = nullptr;
         unsigned len = list->length();
         for (unsigned i = 0; i < len; ++i) {
             StyleBaseImpl *rule = list->item(i);
             if (rule->isRule() && !rule->isCharsetRule()) {
                 append(static_cast<CSSRuleImpl *>(rule));
             }
         }
     } else if (m_list) {
         m_list->ref();
     }
 }
 
 CSSRuleListImpl::~CSSRuleListImpl()
 {
     CSSRuleImpl *rule;
     while (!m_lstCSSRules.isEmpty() && (rule = m_lstCSSRules.takeFirst())) {
         rule->deref();
     }
     if (m_list) {
         m_list->deref();
     }
 }
 
 unsigned long CSSRuleListImpl::length() const
 {
     return m_list ? m_list->length() : m_lstCSSRules.count();
 }
 
 CSSRuleImpl *CSSRuleListImpl::item(unsigned long index)
 {
     if (m_list) {
         StyleBaseImpl *rule = m_list->item(index);
         assert(!rule || rule->isRule());
         return static_cast<CSSRuleImpl *>(rule);
     }
     return index < length() ? m_lstCSSRules.at(index) : nullptr;
 }
 
 void CSSRuleListImpl::deleteRule(unsigned long index)
 {
     assert(!m_list);
     if (index + 1 > (unsigned) m_lstCSSRules.size()) {
         return;
         // ### Throw INDEX_SIZE_ERR exception here (TODO)
     }
     CSSRuleImpl *rule = m_lstCSSRules.takeAt(index);
     rule->deref();
 }
 
 void CSSRuleListImpl::append(CSSRuleImpl *rule)
 {
     assert(!m_list);
     rule->ref();
     m_lstCSSRules.append(rule);
 }
 
 unsigned long CSSRuleListImpl::insertRule(CSSRuleImpl *rule,
         unsigned long index)
 {
     assert(!m_list);
     if (index > (unsigned) m_lstCSSRules.size()) {
         return 0;
         // ### Throw INDEX_SIZE_ERR exception here (TODO)
     }
 
     if (rule) {
         m_lstCSSRules.insert(index, rule);
         rule->ref();
         return index;
     }
 
     return 0;
 }