File indexing completed on 2024-05-05 16:10:10

 /**
  * This file is part of the DOM implementation for KDE.
  *
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2003 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2002 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.
  *
  */
 // -------------------------------------------------------------------------
 //#define DEBUG
 //#define DEBUG_LAYOUT
 //#define PAR_DEBUG
 //#define EVENT_DEBUG
 //#define UNSUPPORTED_ATTR
 
 #include "html_elementimpl.h"
 #include "dtd.h"
 #include "html_documentimpl.h"
 #include "htmltokenizer.h"
 
 #include <khtmlview.h>
 #include <khtml_part.h>
 
 #include <rendering/render_object.h>
 #include <rendering/render_replaced.h>
 #include <css/css_valueimpl.h>
 #include <css/css_stylesheetimpl.h>
 #include <css/cssproperties.h>
 #include <css/cssvalues.h>
 #include <xml/dom_textimpl.h>
 #include <xml/dom2_eventsimpl.h>
 #include <dom/dom_doc.h>
 
 #include "khtml_debug.h"
 
 #undef FOCUS_EVENT  // for win32, MinGW
 
 using namespace DOM;
 using namespace khtml;
 
 HTMLElementImpl::HTMLElementImpl(DocumentImpl *doc)
     : ElementImpl(doc)
 {
     m_htmlCompat = doc && doc->htmlMode() != DocumentImpl::XHtml;
 }
 
 HTMLElementImpl::~HTMLElementImpl()
 {
 }
 
 bool HTMLElementImpl::isInline() const
 {
     if (renderer()) {
         return ElementImpl::isInline();
     }
 
     switch (id()) {
     case ID_A:
     case ID_FONT:
     case ID_TT:
     case ID_U:
     case ID_B:
     case ID_I:
     case ID_S:
     case ID_STRIKE:
     case ID_BIG:
     case ID_SMALL:
 
     // %phrase
     case ID_EM:
     case ID_STRONG:
     case ID_DFN:
     case ID_CODE:
     case ID_SAMP:
     case ID_KBD:
     case ID_VAR:
     case ID_CITE:
     case ID_ABBR:
     case ID_ACRONYM:
 
     // %special
     case ID_SUB:
     case ID_SUP:
     case ID_SPAN:
     case ID_NOBR:
     case ID_WBR:
         return true;
 
     default:
         return ElementImpl::isInline();
     }
 }
 
 DOMString HTMLElementImpl::namespaceURI() const
 {
     return DOMString(XHTML_NAMESPACE);
 }
 
 void HTMLElementImpl::parseAttribute(AttributeImpl *attr)
 {
     DOMString indexstring;
     switch (attr->id()) {
     case ATTR_ALIGN:
         if (attr->val()) {
             if (strcasecmp(attr->value(), "middle") == 0) {
                 addCSSProperty(CSS_PROP_TEXT_ALIGN, CSS_VAL_CENTER);
             } else {
                 addCSSProperty(CSS_PROP_TEXT_ALIGN, attr->value().lower());
             }
         } else {
             removeCSSProperty(CSS_PROP_TEXT_ALIGN);
         }
         break;
 // the core attributes...
     case ATTR_ID:
         // unique id
         setHasID();
         document()->incDOMTreeVersion(DocumentImpl::TV_IDNameHref);
         break;
     case ATTR_CLASS:
         if (attr->val()) {
             DOMString v = attr->value();
             const QChar *characters = v.unicode();
             unsigned length = v.length();
             unsigned i;
             for (i = 0; i < length && characters[i].isSpace(); ++i) { }
             setHasClass(i < length);
             attributes()->setClass(v);
         } else {
             setHasClass(false);
         }
         document()->incDOMTreeVersion(DocumentImpl::TV_Class);
         break;
     case ATTR_NAME:
         document()->incDOMTreeVersion(DocumentImpl::TV_IDNameHref);
         break;
     case ATTR_CONTENTEDITABLE:
         setContentEditable(attr);
         break;
     case ATTR_STYLE:
         getInlineStyleDecls()->updateFromAttribute(attr->value());
         setChanged();
         break;
     case ATTR_TABINDEX:
         indexstring = getAttribute(ATTR_TABINDEX);
         if (attr->val()) {
             setTabIndex(attr->value().toInt());
         } else {
             setNoTabIndex();
         }
         break;
 // i18n attributes
     case ATTR_LANG:
         break;
     case ATTR_DIR:
         addCSSProperty(CSS_PROP_DIRECTION, attr->value().lower());
         break;
 // standard events
     case ATTR_ONCLICK:
         setHTMLEventListener(EventImpl::KHTML_ECMA_CLICK_EVENT,
                              document()->createHTMLEventListener(attr->value().string(), "onclick", this));
         break;
     case ATTR_ONDBLCLICK:
         setHTMLEventListener(EventImpl::KHTML_ECMA_DBLCLICK_EVENT,
                              document()->createHTMLEventListener(attr->value().string(), "ondblclick", this));
         break;
     case ATTR_ONMOUSEDOWN:
         setHTMLEventListener(EventImpl::MOUSEDOWN_EVENT,
                              document()->createHTMLEventListener(attr->value().string(), "onmousedown", this));
         break;
     case ATTR_ONMOUSEMOVE:
         setHTMLEventListener(EventImpl::MOUSEMOVE_EVENT,
                              document()->createHTMLEventListener(attr->value().string(), "onmousemove", this));
         break;
     case ATTR_ONMOUSEOUT:
         setHTMLEventListener(EventImpl::MOUSEOUT_EVENT,
                              document()->createHTMLEventListener(attr->value().string(), "onmouseout", this));
         break;
     case ATTR_ONMOUSEOVER:
         setHTMLEventListener(EventImpl::MOUSEOVER_EVENT,
                              document()->createHTMLEventListener(attr->value().string(), "onmouseover", this));
         break;
     case ATTR_ONMOUSEUP:
         setHTMLEventListener(EventImpl::MOUSEUP_EVENT,
                              document()->createHTMLEventListener(attr->value().string(), "onmouseup", this));
         break;
     case ATTR_ONKEYDOWN:
         setHTMLEventListener(EventImpl::KEYDOWN_EVENT,
                              document()->createHTMLEventListener(attr->value().string(), "onkeydown", this));
         break;
     case ATTR_ONKEYPRESS:
         setHTMLEventListener(EventImpl::KEYPRESS_EVENT,
                              document()->createHTMLEventListener(attr->value().string(), "onkeypress", this));
         break;
     case ATTR_ONKEYUP:
         setHTMLEventListener(EventImpl::KEYUP_EVENT,
                              document()->createHTMLEventListener(attr->value().string(), "onkeyup", this));
         break;
     case ATTR_ONFOCUS:
         setHTMLEventListener(EventImpl::FOCUS_EVENT,
                              document()->createHTMLEventListener(attr->value().string(), "onfocus", this));
         break;
     case ATTR_ONBLUR:
         setHTMLEventListener(EventImpl::BLUR_EVENT,
                              document()->createHTMLEventListener(attr->value().string(), "onblur", this));
         break;
     case ATTR_ONSCROLL:
         setHTMLEventListener(EventImpl::SCROLL_EVENT,
                              document()->createHTMLEventListener(attr->value().string(), "onscroll", this));
         break;
 // other misc attributes
     default:
 #ifdef UNSUPPORTED_ATTR
         qCDebug(KHTML_LOG) << "UATTR: <" << this->nodeName().string() << "> ["
                  << attr->name().string() << "]=[" << attr->value().string() << "]";
 #endif
         break;
     }
 }
 
 void HTMLElementImpl::recalcStyle(StyleChange ch)
 {
     ElementImpl::recalcStyle(ch);
 
     if (m_render /*&& changed*/) {
         m_render->updateFromElement();
     }
 }
 
 void HTMLElementImpl::addCSSProperty(int id, const DOMString &value)
 {
     if (!m_hasCombinedStyle) {
         createNonCSSDecl();
     }
     nonCSSStyleDecls()->setProperty(id, value, false);
     setChanged();
 }
 
 void HTMLElementImpl::addCSSProperty(int id, int value)
 {
     if (!m_hasCombinedStyle) {
         createNonCSSDecl();
     }
     nonCSSStyleDecls()->setProperty(id, value, false);
     setChanged();
 }
 
 void HTMLElementImpl::addCSSLength(int id, const DOMString &value, bool numOnly, bool multiLength)
 {
     if (!m_hasCombinedStyle) {
         createNonCSSDecl();
     }
 
     // strip attribute garbage to avoid CSS parsing errors
     // ### create specialized hook that avoids parsing every
     // value twice!
     if (value.implementation()) {
         // match \s*[+-]?\d*(\.\d*)?[%\*]?
         unsigned i = 0, j = 0;
         QChar *s = value.implementation()->s;
         unsigned l = value.implementation()->l;
 
         while (i < l && s[i].isSpace()) {
             ++i;
         }
         if (i < l && (s[i] == '+' || s[i] == '-')) {
             ++i;
         }
         while (i < l && s[i].isDigit()) {
             ++i, ++j;
         }
 
         // no digits!
         if (j == 0) {
             return;
         }
 
         int v = qBound(-8192, QString::fromRawData(s, i).toInt(), 8191);
         const char *suffix = "px";
         if (!numOnly || multiLength) {
             // look if we find a % or *
             while (i < l) {
                 if (multiLength && s[i] == '*') {
                     suffix = "";
                     break;
                 }
                 if (s[i] == '%') {
                     suffix = "%";
                     break;
                 }
                 ++i;
             }
         }
         if (numOnly) {
             suffix = "";
         }
 
         QString ns = QString::number(v) + suffix;
         nonCSSStyleDecls()->setLengthProperty(id, DOMString(ns), false, multiLength);
         setChanged();
         return;
     }
 
     nonCSSStyleDecls()->setLengthProperty(id, value, false, multiLength);
     setChanged();
 }
 
 static inline bool isHexDigit(const QChar &c)
 {
     return (c >= '0' && c <= '9') ||
            (c >= 'a' && c <= 'f') ||
            (c >= 'A' && c <= 'F');
 }
 
 static inline int toHex(const QChar &c)
 {
     return ((c >= '0' && c <= '9')
             ? (c.unicode() - '0')
             : ((c >= 'a' && c <= 'f')
                ? (c.unicode() - 'a' + 10)
                : ((c >= 'A' && c <= 'F')
                   ? (c.unicode() - 'A' + 10)
                   : -1)));
 }
 
 /* color parsing that tries to match as close as possible IE 6. */
 void HTMLElementImpl::addHTMLColor(int id, const DOMString &c)
 {
     if (!m_hasCombinedStyle) {
         createNonCSSDecl();
     }
 
     // this is the only case no color gets applied in IE.
     if (!c.length()) {
         removeCSSProperty(id);
         return;
     }
 
     if (nonCSSStyleDecls()->setProperty(id, c, false)) {
         return;
     }
 
     QString color = c.string();
     // not something that fits the specs.
 
     // we're emulating IEs color parser here. It maps transparent to black, otherwise it tries to build a rgb value
     // out of everyhting you put in. The algorithm is experimentally determined, but seems to work for all test cases I have.
 
     // the length of the color value is rounded up to the next
     // multiple of 3. each part of the rgb triple then gets one third
     // of the length.
     //
     // Each triplet is parsed byte by byte, mapping
     // each number to a hex value (0-9a-fA-F to their values
     // everything else to 0).
     //
     // The highest non zero digit in all triplets is remembered, and
     // used as a normalization point to normalize to values between 0
     // and 255.
 
     if (color.toLower() != "transparent") {
         if (color[0] == '#') {
             color.remove(0,  1);
         }
         int basicLength = (color.length() + 2) / 3;
         if (basicLength > 1) {
             // IE ignores colors with three digits or less
 //      qDebug("trying to fix up color '%s'. basicLength=%d, length=%d",
 //         color.toLatin1().constData(), basicLength, color.length() );
             int colors[3] = { 0, 0, 0 };
             int component = 0;
             int pos = 0;
             int maxDigit = basicLength - 1;
             while (component < 3) {
                 // search forward for digits in the string
                 int numDigits = 0;
                 while (pos < (int)color.length() && numDigits < basicLength) {
                     int hex = toHex(color[pos]);
                     colors[component] = (colors[component] << 4);
                     if (hex > 0) {
                         colors[component] += hex;
                         maxDigit = qMin(maxDigit, numDigits);
                     }
                     numDigits++;
                     pos++;
                 }
                 while (numDigits++ < basicLength) {
                     colors[component] <<= 4;
                 }
                 component++;
             }
             maxDigit = basicLength - maxDigit;
 //      qDebug("color is %x %x %x, maxDigit=%d",  colors[0], colors[1], colors[2], maxDigit );
 
             // normalize to 00-ff. The highest filled digit counts, minimum is 2 digits
             maxDigit -= 2;
             colors[0] >>= 4 * maxDigit;
             colors[1] >>= 4 * maxDigit;
             colors[2] >>= 4 * maxDigit;
 //      qDebug("normalized color is %x %x %x",  colors[0], colors[1], colors[2] );
             //  assert( colors[0] < 0x100 && colors[1] < 0x100 && colors[2] < 0x100 );
 
             color.sprintf("#%02x%02x%02x", colors[0], colors[1], colors[2]);
 //      qDebug( "trying to add fixed color string '%s'", color.toLatin1().constData() );
             if (nonCSSStyleDecls()->setProperty(id, DOMString(color), false)) {
                 return;
             }
         }
     }
     nonCSSStyleDecls()->setProperty(id, CSS_VAL_BLACK, false);
 }
 
 void HTMLElementImpl::removeCSSProperty(int id)
 {
     if (!m_hasCombinedStyle) {
         return;
     }
     nonCSSStyleDecls()->setParent(document()->elementSheet());
     nonCSSStyleDecls()->removeProperty(id);
     setChanged();
 }
 
 DOMString HTMLElementImpl::innerHTML() const
 {
     QString result = ""; //Use QString to accumulate since DOMString is poor for appends
     for (NodeImpl *child = firstChild(); child != nullptr; child = child->nextSibling()) {
         DOMString kid = child->toString();
         result += QString::fromRawData(kid.unicode(), kid.length());
     }
     return result;
 }
 
 DOMString HTMLElementImpl::innerText() const
 {
     QString text = "";
     if (!firstChild()) {
         return text;
     }
 
     const NodeImpl *n = this;
     // find the next text/image after the anchor, to get a position
     while (n) {
         if (n->firstChild()) {
             n = n->firstChild();
         } else if (n->nextSibling()) {
             n = n->nextSibling();
         } else {
             NodeImpl *next = nullptr;
             while (!next) {
                 n = n->parentNode();
                 if (!n || n == (NodeImpl *)this) {
                     goto end;
                 }
                 next = n->nextSibling();
             }
             n = next;
         }
         if (n->isTextNode()) {
             DOMStringImpl *data = static_cast<const TextImpl *>(n)->string();
             text += QString::fromRawData(data->s, data->l);
         }
     }
 end:
     return text;
 }
 
 DocumentFragment HTMLElementImpl::createContextualFragment(const DOMString &html)
 {
     // IE originally restricted innerHTML to a small subset of elements;
     // and we largely matched that. Mozilla's embrace of innerHTML, however, extended
     // it to pretty much everything, and so the web (and HTML5) requires it now.
     // For now, we accept everything, but do not do context-based recovery in the parser.
     if (!document()->isHTMLDocument()) {
         return DocumentFragment();
     }
 
     DocumentFragmentImpl *fragment = new DocumentFragmentImpl(docPtr());
     DocumentFragment f(fragment);
     {
         HTMLTokenizer tok(docPtr(), fragment);
         tok.begin();
         tok.write(html.string(), true);
         tok.end();
     }
 
     // Exceptions are ignored because none ought to happen here.
     int ignoredExceptionCode;
 
     // we need to pop <html> and <body> elements and remove <head> to
     // accomadate folks passing complete HTML documents to make the
     // child of an element.
     for (NodeImpl *node = fragment->firstChild(); node;) {
         if (node->id() == ID_HTML || node->id() == ID_BODY) {
             NodeImpl *firstChild = node->firstChild();
             NodeImpl *child = firstChild;
             while (child) {
                 NodeImpl *nextChild = child->nextSibling();
                 fragment->insertBefore(child, node, ignoredExceptionCode);
                 child = nextChild;
             }
             if (!firstChild) {
                 NodeImpl *nextNode = node->nextSibling();
                 fragment->removeChild(node, ignoredExceptionCode);
                 node = nextNode;
             } else {
                 fragment->removeChild(node, ignoredExceptionCode);
                 node = firstChild;
             }
         } else if (node->id() == ID_HEAD) {
             NodeImpl *nextNode = node->nextSibling();
             fragment->removeChild(node, ignoredExceptionCode);
             node = nextNode;
         } else {
             node = node->nextSibling();
         }
     }
 
     return f;
 }
 
 void HTMLElementImpl::setInnerHTML(const DOMString &html, int &exceptioncode)
 {
     if (id() == ID_SCRIPT || id() == ID_STYLE) {
         // Script and CSS source shouldn't be parsed as HTML.
         removeChildren();
         appendChild(document()->createTextNode(html), exceptioncode);
         return;
     }
 
     DocumentFragment fragment = createContextualFragment(html);
     if (fragment.isNull()) {
         exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
         return;
     }
 
     // Make sure adding the new child is ok, before removing all children (#96187)
     checkAddChild(fragment.handle(), exceptioncode);
     if (exceptioncode) {
         return;
     }
 
     removeChildren();
     appendChild(fragment.handle(), exceptioncode);
 }
 
 void HTMLElementImpl::setInnerText(const DOMString &text, int &exceptioncode)
 {
     // following the IE specs.
     if (endTagRequirement(id()) == FORBIDDEN) {
         exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
         return;
     }
     // IE disallows innerHTML on inline elements. I don't see why we should have this restriction, as our
     // dhtml engine can cope with it. Lars
     //if ( isInline() ) return false;
     switch (id()) {
     case ID_COL:
     case ID_COLGROUP:
     case ID_FRAMESET:
     case ID_HEAD:
     case ID_HTML:
     case ID_TABLE:
     case ID_TBODY:
     case ID_TFOOT:
     case ID_THEAD:
     case ID_TR:
         exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
         return;
     default:
         break;
     }
 
     removeChildren();
 
     TextImpl *t = new TextImpl(docPtr(), text.implementation());
     appendChild(t, exceptioncode);
 }
 
 void HTMLElementImpl::addHTMLAlignment(DOMString alignment)
 {
     //qDebug("alignment is %s", alignment.string().toLatin1().constData() );
     // vertical alignment with respect to the current baseline of the text
     // right or left means floating images
     int propfloat = -1;
     int propvalign = -1;
     if (strcasecmp(alignment, "absmiddle") == 0) {
         propvalign = CSS_VAL_MIDDLE;
     } else if (strcasecmp(alignment, "absbottom") == 0) {
         propvalign = CSS_VAL_BOTTOM;
     } else if (strcasecmp(alignment, "left") == 0) {
         propfloat = CSS_VAL_LEFT;
         propvalign = CSS_VAL_TOP;
     } else if (strcasecmp(alignment, "right") == 0) {
         propfloat = CSS_VAL_RIGHT;
         propvalign = CSS_VAL_TOP;
     } else if (strcasecmp(alignment, "top") == 0) {
         propvalign = CSS_VAL_TOP;
     } else if (strcasecmp(alignment, "middle") == 0) {
         propvalign = CSS_VAL__KHTML_BASELINE_MIDDLE;
     } else if (strcasecmp(alignment, "center") == 0) {
         propvalign = CSS_VAL_MIDDLE;
     } else if (strcasecmp(alignment, "bottom") == 0) {
         propvalign = CSS_VAL_BASELINE;
     } else if (strcasecmp(alignment, "texttop") == 0) {
         propvalign = CSS_VAL_TEXT_TOP;
     }
 
     if (propfloat != -1) {
         addCSSProperty(CSS_PROP_FLOAT, propfloat);
     }
     if (propvalign != -1) {
         addCSSProperty(CSS_PROP_VERTICAL_ALIGN, propvalign);
     }
 }
 
 DOMString HTMLElementImpl::contentEditable() const
 {
     document()->updateRendering();
 
     if (!renderer()) {
         return "false";
     }
 
     switch (renderer()->style()->userInput()) {
     case UI_ENABLED:
         return "true";
     case UI_DISABLED:
     case UI_NONE:
         return "false";
     default:;
     }
     return "inherit";
 }
 
 void HTMLElementImpl::setContentEditable(AttributeImpl *attr)
 {
     const DOMString &enabled = attr->value();
     if (enabled.isEmpty() || strcasecmp(enabled, "true") == 0) {
         addCSSProperty(CSS_PROP__KHTML_USER_INPUT, CSS_VAL_ENABLED);
     } else if (strcasecmp(enabled, "false") == 0) {
         addCSSProperty(CSS_PROP__KHTML_USER_INPUT, CSS_VAL_NONE);
     } else if (strcasecmp(enabled, "inherit") == 0) {
         addCSSProperty(CSS_PROP__KHTML_USER_INPUT, CSS_VAL_INHERIT);
     }
 }
 
 void HTMLElementImpl::setContentEditable(const DOMString &enabled)
 {
     if (enabled == "inherit") {
         int exceptionCode;
         removeAttribute(ATTR_CONTENTEDITABLE, exceptionCode);
     } else {
         setAttribute(ATTR_CONTENTEDITABLE, enabled.isEmpty() ? "true" : enabled);
     }
 }
 
 DOMString HTMLElementImpl::toString() const
 {
     if (!hasChildNodes()) {
         DOMString result = openTagStartToString();
         result += ">";
 
         if (endTagRequirement(id()) == REQUIRED) {
             result += "</";
             result += nonCaseFoldedTagName();
             result += ">";
         }
 
         return result;
     }
 
     return ElementImpl::toString();
 }
 
 // -------------------------------------------------------------------------
 HTMLGenericElementImpl::HTMLGenericElementImpl(DocumentImpl *doc, ushort i)
     : HTMLElementImpl(doc)
 {
     m_localName = LocalName::fromId(i);
 }
 
 HTMLGenericElementImpl::HTMLGenericElementImpl(DocumentImpl *doc, LocalName l)
     : HTMLElementImpl(doc),
       m_localName(l)
 {}
 
 HTMLGenericElementImpl::~HTMLGenericElementImpl()
 {
 }