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

 /**
  * 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) 2000 Simon Hausmann (hausmann@kde.org)
  *           (C) 2001-2003 Dirk Mueller (mueller@kde.org)
  *
  * 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 "html/html_baseimpl.h"
 #include "html/html_documentimpl.h"
 
 #include "khtmlview.h"
 #include "khtml_part.h"
 #include "khtmlpart_p.h"
 
 #include "rendering/render_frames.h"
 #include "rendering/render_body.h"
 #include "css/cssstyleselector.h"
 #include "css/css_stylesheetimpl.h"
 #include "css/cssproperties.h"
 #include "css/cssvalues.h"
 #include "misc/loader.h"
 #include "dom/dom_string.h"
 #include "dom/dom_doc.h"
 #include "xml/dom2_eventsimpl.h"
 
 #include <QUrl>
 #include "khtml_debug.h"
 
 #undef FOCUS_EVENT  // for win32, MinGW
 
 using namespace DOM;
 using namespace khtml;
 
 HTMLBodyElementImpl::HTMLBodyElementImpl(DocumentImpl *doc)
     : HTMLElementImpl(doc),
       m_bgSet(false), m_fgSet(false)
 {
     m_styleSheet = nullptr;
 }
 
 HTMLBodyElementImpl::~HTMLBodyElementImpl()
 {
     if (m_styleSheet) {
         m_styleSheet->deref();
     }
 }
 
 NodeImpl::Id HTMLBodyElementImpl::id() const
 {
     return ID_BODY;
 }
 
 void HTMLBodyElementImpl::parseAttribute(AttributeImpl *attr)
 {
     switch (attr->id()) {
 
     case ATTR_BACKGROUND: {
         QString url = attr->value().trimSpaces().string();
         if (!url.isEmpty()) {
             url = document()->completeURL(url);
             addCSSProperty(CSS_PROP_BACKGROUND_IMAGE, DOMString("url('" + url + "')"));
             m_bgSet = true;
         } else {
             removeCSSProperty(CSS_PROP_BACKGROUND_IMAGE);
             m_bgSet = false;
         }
         break;
     }
     case ATTR_MARGINWIDTH: {
         KHTMLView *w = document()->view();
         if (w) {
             w->setMarginWidth(-1);    // unset this, so it doesn't override the setting here
         }
         addCSSLength(CSS_PROP_MARGIN_RIGHT, attr->value());
     }
     /* nobreak; */
     case ATTR_LEFTMARGIN:
         addCSSLength(CSS_PROP_MARGIN_LEFT, attr->value());
         break;
     case ATTR_MARGINHEIGHT: {
         KHTMLView *w = document()->view();
         if (w) {
             w->setMarginHeight(-1);    // unset this, so it doesn't override the setting here
         }
         addCSSLength(CSS_PROP_MARGIN_BOTTOM, attr->value());
     }
     /* nobreak */
     case ATTR_TOPMARGIN:
         addCSSLength(CSS_PROP_MARGIN_TOP, attr->value());
         break;
     case ATTR_BGCOLOR:
         addHTMLColor(CSS_PROP_BACKGROUND_COLOR, attr->value());
         m_bgSet = !attr->value().isNull();
         break;
     case ATTR_TEXT:
         addHTMLColor(CSS_PROP_COLOR, attr->value());
         m_fgSet = !attr->value().isNull();
         break;
     case ATTR_BGPROPERTIES:
         if (strcasecmp(attr->value(), "fixed") == 0) {
             addCSSProperty(CSS_PROP_BACKGROUND_ATTACHMENT, CSS_VAL_FIXED);
         }
         break;
     case ATTR_VLINK:
     case ATTR_ALINK:
     case ATTR_LINK: {
         if (!m_styleSheet) {
             m_styleSheet = new CSSStyleSheetImpl(this, DOMString(), true /*implicit*/);
             m_styleSheet->ref();
         }
         QString aStr;
         if (attr->id() == ATTR_LINK) {
             aStr = "a:link";
         } else if (attr->id() == ATTR_VLINK) {
             aStr = "a:visited";
         } else if (attr->id() == ATTR_ALINK) {
             aStr = "a:active";
         }
         aStr += " { color: " + attr->value().string() + "; }";
         m_styleSheet->parseString(aStr, false);
         if (attached()) {
             document()->updateStyleSelector();
         }
         break;
     }
     case ATTR_ONLOAD:
         document()->setHTMLWindowEventListener(EventImpl::LOAD_EVENT,
                                                document()->createHTMLEventListener(attr->value().string(), "onload", nullptr));
         break;
     case ATTR_ONUNLOAD:
         document()->setHTMLWindowEventListener(EventImpl::UNLOAD_EVENT,
                                                document()->createHTMLEventListener(attr->value().string(), "onunload", nullptr));
         break;
     case ATTR_ONBLUR:
         document()->setHTMLWindowEventListener(EventImpl::BLUR_EVENT,
                                                document()->createHTMLEventListener(attr->value().string(), "onblur", nullptr));
         break;
     case ATTR_ONFOCUS:
         document()->setHTMLWindowEventListener(EventImpl::FOCUS_EVENT,
                                                document()->createHTMLEventListener(attr->value().string(), "onfocus", nullptr));
         break;
     case ATTR_ONRESIZE:
         document()->setHTMLWindowEventListener(EventImpl::RESIZE_EVENT,
                                                document()->createHTMLEventListener(attr->value().string(), "onresize", nullptr));
         break;
     case ATTR_ONKEYUP:
         document()->setHTMLWindowEventListener(EventImpl::KEYUP_EVENT,
                                                document()->createHTMLEventListener(attr->value().string(), "onkeyup", nullptr));
         break;
     case ATTR_ONKEYDOWN:
         document()->setHTMLWindowEventListener(EventImpl::KEYDOWN_EVENT,
                                                document()->createHTMLEventListener(attr->value().string(), "onkeydown", nullptr));
         break;
     case ATTR_ONKEYPRESS:
         document()->setHTMLWindowEventListener(EventImpl::KEYPRESS_EVENT,
                                                document()->createHTMLEventListener(attr->value().string(), "onkeypress", nullptr));
         break;
     case ATTR_ONSCROLL:
         document()->setHTMLWindowEventListener(EventImpl::SCROLL_EVENT,
                                                document()->createHTMLEventListener(attr->value().string(), "onscroll", nullptr));
         break;
     case ATTR_ONMESSAGE:
         document()->setHTMLWindowEventListener(EventImpl::MESSAGE_EVENT,
                                                document()->createHTMLEventListener(attr->value().string(), "onmessage", nullptr));
         break;
     case ATTR_ONHASHCHANGE:
         document()->setHTMLWindowEventListener(EventImpl::HASHCHANGE_EVENT,
                                                document()->createHTMLEventListener(attr->value().string(), "onhashchange", nullptr));
         break;
     case ATTR_NOSAVE:
         break;
     default:
         HTMLElementImpl::parseAttribute(attr);
     }
 }
 
 void HTMLBodyElementImpl::insertedIntoDocument()
 {
     HTMLElementImpl::insertedIntoDocument();
 
     KHTMLView *w = document()->view();
     if (w && w->marginWidth() != -1) {
         QString s = QStringLiteral("%1").arg(w->marginWidth());
         addCSSLength(CSS_PROP_MARGIN_LEFT, s);
         addCSSLength(CSS_PROP_MARGIN_RIGHT, s);
     }
     if (w && w->marginHeight() != -1) {
         QString s = QStringLiteral("%1").arg(w->marginHeight());
         addCSSLength(CSS_PROP_MARGIN_TOP, s);
         addCSSLength(CSS_PROP_MARGIN_BOTTOM, s);
     }
 
     if (m_bgSet && !m_fgSet) {
         addCSSProperty(CSS_PROP_COLOR, CSS_VAL_BLACK);
     }
 
     if (m_styleSheet) {
         document()->updateStyleSelector();
     }
 }
 
 void HTMLBodyElementImpl::removedFromDocument()
 {
     HTMLElementImpl::removedFromDocument();
 
     if (m_styleSheet) {
         document()->updateStyleSelector();
     }
 }
 
 void HTMLBodyElementImpl::attach()
 {
     assert(!m_render);
     assert(parentNode());
 
     RenderStyle *style = document()->styleSelector()->styleForElement(this);
     style->ref();
     if (parentNode()->renderer() && parentNode()->renderer()->childAllowed()
             && style->display() != NONE) {
         if (style->display() == BLOCK)
             // only use the quirky class for block display
         {
             m_render = new(document()->renderArena()) RenderBody(this);
         } else {
             m_render = RenderObject::createObject(this, style);
         }
         m_render->setStyle(style);
         parentNode()->renderer()->addChild(m_render, nextRenderer());
     }
     style->deref();
 
     NodeBaseImpl::attach();
 }
 
 // -------------------------------------------------------------------------
 
 HTMLFrameElementImpl::HTMLFrameElementImpl(DocumentImpl *doc)
     : HTMLPartContainerElementImpl(doc)
 {
     frameBorder = true;
     frameBorderSet = false;
     marginWidth = -1;
     marginHeight = -1;
     scrolling = Qt::ScrollBarAsNeeded;
     noresize = false;
     url = QLatin1String("about:blank");
 }
 
 HTMLFrameElementImpl::~HTMLFrameElementImpl()
 {
 }
 
 NodeImpl::Id HTMLFrameElementImpl::id() const
 {
     return ID_FRAME;
 }
 
 void HTMLFrameElementImpl::ensureUniqueName()
 {
     // If we already have a name, don't do anything.
     if (!name.isEmpty()) {
         return;
     }
 
     // Use the specified name first..
     name = getAttribute(ATTR_NAME);
     if (name.isNull()) {
         name = getAttribute(ATTR_ID);
     }
 
     // Generate synthetic name if there isn't a natural one or
     // if the natural one conflicts
     KHTMLPart *parentPart = document()->part();
 
     // If there is no part, we will not load anything, so no
     // worry about names being unique or not.
     if (!parentPart) {
         return;
     }
 
     KHTMLPart *otherFrame = parentPart->findFrame(name.string());
     if (name.isEmpty() || (otherFrame && otherFrame != contentPart())) {
         name = DOMString(parentPart->requestFrameName());
     }
 
     // Make sure we're registered properly.
     parentPart->d->renameFrameForContainer(this, name.string());
 }
 
 void HTMLFrameElementImpl::defaultEventHandler(EventImpl *e)
 {
     // ### duplicated in HTMLObjectBaseElementImpl
     if (e->target() == this && m_render && m_render->isWidget()
             && static_cast<RenderWidget *>(m_render)->isRedirectedWidget()
             && qobject_cast<KHTMLView *>(static_cast<RenderWidget *>(m_render)->widget())) {
         switch (e->id())  {
         case EventImpl::MOUSEDOWN_EVENT:
         case EventImpl::MOUSEUP_EVENT:
         case EventImpl::MOUSEMOVE_EVENT:
         case EventImpl::MOUSEOUT_EVENT:
         case EventImpl::MOUSEOVER_EVENT:
         case EventImpl::KHTML_MOUSEWHEEL_EVENT:
         case EventImpl::KEYDOWN_EVENT:
         case EventImpl::KEYUP_EVENT:
         case EventImpl::KEYPRESS_EVENT:
         case EventImpl::DOMFOCUSIN_EVENT:
         case EventImpl::DOMFOCUSOUT_EVENT:
             if (static_cast<RenderWidget *>(m_render)->handleEvent(*e)) {
                 e->setDefaultHandled();
             }
         default:
             break;
         }
     }
     HTMLPartContainerElementImpl::defaultEventHandler(e);
 }
 
 void HTMLFrameElementImpl::parseAttribute(AttributeImpl *attr)
 {
     switch (attr->id()) {
     case ATTR_SRC:
         setLocation(attr->value().trimSpaces().string());
         break;
     case ATTR_FRAMEBORDER: {
         frameBorder = attr->value().toInt();
         frameBorderSet = (attr->val() != nullptr);
         // FIXME: when attached, has no effect
     }
     break;
     case ATTR_MARGINWIDTH:
         marginWidth = attr->val()->toInt();
         // FIXME: when attached, has no effect
         break;
     case ATTR_MARGINHEIGHT:
         marginHeight = attr->val()->toInt();
         // FIXME: when attached, has no effect
         break;
     case ATTR_NORESIZE:
         noresize = true;
         // FIXME: when attached, has no effect
         break;
     case ATTR_SCROLLING:
         if (strcasecmp(attr->value(), "auto") == 0) {
             scrolling = Qt::ScrollBarAsNeeded;
         } else if (strcasecmp(attr->value(), "yes") == 0) {
             scrolling = Qt::ScrollBarAlwaysOn;
         } else if (strcasecmp(attr->value(), "no") == 0) {
             scrolling = Qt::ScrollBarAlwaysOff;
         }
         // when attached, has no effect
         break;
     case ATTR_ONLOAD:
         setHTMLEventListener(EventImpl::LOAD_EVENT,
                              document()->createHTMLEventListener(attr->value().string(), "onload", this));
         break;
     case ATTR_ONUNLOAD:
         setHTMLEventListener(EventImpl::UNLOAD_EVENT,
                              document()->createHTMLEventListener(attr->value().string(), "onunload", this));
         break;
     default:
         HTMLElementImpl::parseAttribute(attr);
     }
 }
 
 void HTMLFrameElementImpl::attach()
 {
     assert(!attached());
     assert(parentNode());
 
     computeContentIfNeeded();
 
     // inherit default settings from parent frameset
     HTMLElementImpl *node = static_cast<HTMLElementImpl *>(parentNode());
     while (node) {
         if (node->id() == ID_FRAMESET) {
             HTMLFrameSetElementImpl *frameset = static_cast<HTMLFrameSetElementImpl *>(node);
             if (!frameBorderSet) {
                 frameBorder = frameset->frameBorder();
             }
             if (!noresize) {
                 noresize = frameset->noResize();
             }
             break;
         }
         node = static_cast<HTMLElementImpl *>(node->parentNode());
     }
 
     if (parentNode()->renderer() && parentNode()->renderer()->childAllowed()
             && document()->isURLAllowed(url))  {
         RenderStyle *_style = document()->styleSelector()->styleForElement(this);
         _style->ref();
         if (_style->display() != NONE) {
             m_render = new(document()->renderArena()) RenderFrame(this);
             m_render->setStyle(_style);
             parentNode()->renderer()->addChild(m_render, nextRenderer());
         }
         _style->deref();
     }
 
     // If we already have a widget, set it.
     if (m_render && childWidget()) {
         static_cast<RenderFrame *>(m_render)->setWidget(childWidget());
     }
 
     NodeBaseImpl::attach();
 }
 
 void HTMLFrameElementImpl::setWidgetNotify(QWidget *widget)
 {
     if (m_render) {
         static_cast<RenderFrame *>(m_render)->setWidget(widget);
     }
 }
 
 void HTMLFrameElementImpl::computeContent()
 {
     KHTMLPart *parentPart = document()->part();
 
     if (!parentPart) {
         return;
     }
 
     // Bail out on any disallowed URLs
     if (!document()->isURLAllowed(url)) {
         return;
     }
 
     // If we have a part already, make sure it's in the right spot...
     // (can happen if someone asks to change location while we're in process
     // of loading the original one)
     if (contentPart()) {
         setLocation(url);
         return;
     }
 
     ensureUniqueName();
 
     // Go ahead and load a part... We don't need to clear the widget here,
     // since the -frames- have their lifetime managed, using the name uniqueness.
     parentPart->loadFrameElement(this, url, name.string());
 }
 
 void HTMLFrameElementImpl::setLocation(const QString &str)
 {
     url = str;
 
     if (!document()->isURLAllowed(url)) {
         return;
     }
 
     // if we already have a child part, ask it to go there..
     KHTMLPart *childPart = contentPart();
     if (childPart) {
         childPart->openUrl(QUrl(document()->completeURL(url)));
     } else {
         setNeedComputeContent();    // otherwise, request it..
     }
 }
 
 bool HTMLFrameElementImpl::isFocusableImpl(FocusType ft) const
 {
     if (m_render != nullptr) {
         return true;
     }
     return HTMLPartContainerElementImpl::isFocusableImpl(ft);
 }
 
 void HTMLFrameElementImpl::setFocus(bool received)
 {
     HTMLElementImpl::setFocus(received);
     khtml::RenderFrame *renderFrame = static_cast<khtml::RenderFrame *>(m_render);
     if (!renderFrame || !renderFrame->widget()) {
         return;
     }
     if (received) {
         renderFrame->widget()->setFocus();
     } else {
         renderFrame->widget()->clearFocus();
     }
 }
 
 DocumentImpl *HTMLFrameElementImpl::contentDocument() const
 {
     if (!childWidget()) {
         return nullptr;
     }
 
     if (::qobject_cast<KHTMLView *>(childWidget())) {
         return static_cast<KHTMLView *>(childWidget())->part()->xmlDocImpl();
     }
 
     return nullptr;
 }
 
 KHTMLPart   *HTMLFrameElementImpl::contentPart() const
 {
     if (!childWidget()) {
         return nullptr;
     }
 
     if (::qobject_cast<KHTMLView *>(childWidget())) {
         return static_cast<KHTMLView *>(childWidget())->part();
     }
 
     return nullptr;
 }
 
 // -------------------------------------------------------------------------
 
 DOMString HTMLBodyElementImpl::aLink() const
 {
     return getAttribute(ATTR_ALINK);
 }
 
 void HTMLBodyElementImpl::setALink(const DOMString &value)
 {
     setAttribute(ATTR_ALINK, value);
 }
 
 DOMString HTMLBodyElementImpl::bgColor() const
 {
     return getAttribute(ATTR_BGCOLOR);
 }
 
 void HTMLBodyElementImpl::setBgColor(const DOMString &value)
 {
     setAttribute(ATTR_BGCOLOR, value);
 }
 
 DOMString HTMLBodyElementImpl::link() const
 {
     return getAttribute(ATTR_LINK);
 }
 
 void HTMLBodyElementImpl::setLink(const DOMString &value)
 {
     setAttribute(ATTR_LINK, value);
 }
 
 DOMString HTMLBodyElementImpl::text() const
 {
     return getAttribute(ATTR_TEXT);
 }
 
 void HTMLBodyElementImpl::setText(const DOMString &value)
 {
     setAttribute(ATTR_TEXT, value);
 }
 
 DOMString HTMLBodyElementImpl::vLink() const
 {
     return getAttribute(ATTR_VLINK);
 }
 
 void HTMLBodyElementImpl::setVLink(const DOMString &value)
 {
     setAttribute(ATTR_VLINK, value);
 }
 
 // -------------------------------------------------------------------------
 
 HTMLFrameSetElementImpl::HTMLFrameSetElementImpl(DocumentImpl *doc)
     : HTMLElementImpl(doc)
 {
     // default value for rows and cols...
     m_totalRows = 1;
     m_totalCols = 1;
 
     m_rows = m_cols = nullptr;
 
     frameborder = true;
     frameBorderSet = false;
     m_border = 4;
     noresize = false;
 
     m_resizing = false;
 }
 
 HTMLFrameSetElementImpl::~HTMLFrameSetElementImpl()
 {
     delete [] m_rows;
     delete [] m_cols;
 }
 
 NodeImpl::Id HTMLFrameSetElementImpl::id() const
 {
     return ID_FRAMESET;
 }
 
 void HTMLFrameSetElementImpl::parseAttribute(AttributeImpl *attr)
 {
     switch (attr->id()) {
     case ATTR_ROWS:
         if (!attr->val()) {
             break;
         }
         delete [] m_rows;
         m_rows = attr->val()->toLengthArray(m_totalRows);
         setChanged();
         break;
     case ATTR_COLS:
         if (!attr->val()) {
             break;
         }
         delete [] m_cols;
         m_cols = attr->val()->toLengthArray(m_totalCols);
         setChanged();
         break;
     case ATTR_FRAMEBORDER:
         // false or "no" or "0"..
         if (attr->value().toInt() == 0) {
             frameborder = false;
             m_border = 0;
         }
         frameBorderSet = true;
         break;
     case ATTR_NORESIZE:
         noresize = true;
         break;
     case ATTR_BORDER:
         m_border = attr->val()->toInt();
         if (!m_border) {
             frameborder = false;
         }
         break;
     case ATTR_ONLOAD:
         document()->setHTMLWindowEventListener(EventImpl::LOAD_EVENT,
                                                document()->createHTMLEventListener(attr->value().string(), "onload", nullptr));
         break;
     case ATTR_ONUNLOAD:
         document()->setHTMLWindowEventListener(EventImpl::UNLOAD_EVENT,
                                                document()->createHTMLEventListener(attr->value().string(), "onunload", nullptr));
         break;
     case ATTR_ONMESSAGE:
         document()->setHTMLWindowEventListener(EventImpl::MESSAGE_EVENT,
                                                document()->createHTMLEventListener(attr->value().string(), "onmessage", nullptr));
         break;
     default:
         HTMLElementImpl::parseAttribute(attr);
     }
 }
 
 void HTMLFrameSetElementImpl::attach()
 {
     assert(!attached());
     assert(parentNode());
 
     // inherit default settings from parent frameset
     HTMLElementImpl *node = static_cast<HTMLElementImpl *>(parentNode());
     while (node) {
         if (node->id() == ID_FRAMESET) {
             HTMLFrameSetElementImpl *frameset = static_cast<HTMLFrameSetElementImpl *>(node);
             if (!frameBorderSet) {
                 frameborder = frameset->frameBorder();
             }
             if (!noresize) {
                 noresize = frameset->noResize();
             }
             break;
         }
         node = static_cast<HTMLElementImpl *>(node->parentNode());
     }
 
     RenderStyle *_style = document()->styleSelector()->styleForElement(this);
     _style->ref();
     // ignore display: none
     if (parentNode()->renderer() && parentNode()->renderer()->childAllowed()) {
         m_render = new(document()->renderArena()) RenderFrameSet(this);
         m_render->setStyle(_style);
         parentNode()->renderer()->addChild(m_render, nextRenderer());
     }
     _style->deref();
 
     NodeBaseImpl::attach();
 }
 
 void HTMLFrameSetElementImpl::defaultEventHandler(EventImpl *evt)
 {
     if (evt->isMouseEvent() && !noresize && m_render) {
         static_cast<khtml::RenderFrameSet *>(m_render)->userResize(static_cast<MouseEventImpl *>(evt));
     }
 
     evt->setDefaultHandled();
     HTMLElementImpl::defaultEventHandler(evt);
 }
 
 void HTMLFrameSetElementImpl::detach()
 {
     if (attached())
         // ### send the event when we actually get removed from the doc instead of here
     {
         document()->dispatchHTMLEvent(EventImpl::UNLOAD_EVENT, false, false);
     }
 
     HTMLElementImpl::detach();
 }
 
 void HTMLFrameSetElementImpl::recalcStyle(StyleChange ch)
 {
     if (changed() && m_render) {
         m_render->setNeedsLayout(true);
 //         m_render->layout();
         setChanged(false);
     }
     HTMLElementImpl::recalcStyle(ch);
 }
 
 // -------------------------------------------------------------------------
 
 NodeImpl::Id HTMLHeadElementImpl::id() const
 {
     return ID_HEAD;
 }
 
 // -------------------------------------------------------------------------
 
 NodeImpl::Id HTMLHtmlElementImpl::id() const
 {
     return ID_HTML;
 }
 
 // -------------------------------------------------------------------------
 
 HTMLIFrameElementImpl::HTMLIFrameElementImpl(DocumentImpl *doc) : HTMLFrameElementImpl(doc)
 {
     frameBorder = false;
     marginWidth = 0;
     marginHeight = 0;
     m_frame = true;
 }
 
 void HTMLIFrameElementImpl::insertedIntoDocument()
 {
     HTMLFrameElementImpl::insertedIntoDocument();
 
     assert(!contentPart());
     setNeedComputeContent();
     computeContentIfNeeded(); // also clears
 }
 
 void HTMLIFrameElementImpl::removedFromDocument()
 {
     HTMLFrameElementImpl::removedFromDocument();
     clearChildWidget();
 }
 
 HTMLIFrameElementImpl::~HTMLIFrameElementImpl()
 {
 }
 
 NodeImpl::Id HTMLIFrameElementImpl::id() const
 {
     return ID_IFRAME;
 }
 
 void HTMLIFrameElementImpl::parseAttribute(AttributeImpl *attr)
 {
     switch (attr->id()) {
     case ATTR_WIDTH:
         if (!attr->value().isEmpty()) {
             addCSSLength(CSS_PROP_WIDTH, attr->value());
         } else {
             removeCSSProperty(CSS_PROP_WIDTH);
         }
         break;
     case ATTR_HEIGHT:
         if (!attr->value().isEmpty()) {
             addCSSLength(CSS_PROP_HEIGHT, attr->value());
         } else {
             removeCSSProperty(CSS_PROP_HEIGHT);
         }
         break;
     case ATTR_ALIGN:
         addHTMLAlignment(attr->value());
         break;
     case ATTR_SRC:
         url = attr->value().trimSpaces().string();
         setNeedComputeContent();
         // ### synchronously start the process?
         break;
     case ATTR_NAME:
         ensureUniqueName();
         break;
     case ATTR_ID:
         HTMLFrameElementImpl::parseAttribute(attr);   // want default ID handling
         ensureUniqueName();
         break;
     case ATTR_FRAMEBORDER: {
         m_frame = (!attr->val() || attr->value().toInt() > 0);
         if (attached()) {
             updateFrame();
         }
         break;
     }
     default:
         HTMLFrameElementImpl::parseAttribute(attr);
     }
 }
 
 void HTMLIFrameElementImpl::updateFrame()
 {
     if (m_frame) {
         addCSSProperty(CSS_PROP_BORDER_TOP_STYLE, CSS_VAL_OUTSET);
         addCSSProperty(CSS_PROP_BORDER_BOTTOM_STYLE, CSS_VAL_OUTSET);
         addCSSProperty(CSS_PROP_BORDER_LEFT_STYLE, CSS_VAL_OUTSET);
         addCSSProperty(CSS_PROP_BORDER_RIGHT_STYLE, CSS_VAL_OUTSET);
         addCSSLength(CSS_PROP_BORDER_WIDTH, "2");
     } else {
         addCSSProperty(CSS_PROP_BORDER_TOP_STYLE, CSS_VAL_NONE);
         addCSSProperty(CSS_PROP_BORDER_BOTTOM_STYLE, CSS_VAL_NONE);
         addCSSProperty(CSS_PROP_BORDER_LEFT_STYLE, CSS_VAL_NONE);
         addCSSProperty(CSS_PROP_BORDER_RIGHT_STYLE, CSS_VAL_NONE);
         removeCSSProperty(CSS_PROP_BORDER_WIDTH);
     }
 
 }
 
 void HTMLIFrameElementImpl::attach()
 {
     assert(!attached());
     assert(!m_render);
     assert(parentNode());
 
     updateFrame();
 
     RenderStyle *style = document()->styleSelector()->styleForElement(this);
     style->ref();
     if (document()->isURLAllowed(url) && parentNode()->renderer()
             && parentNode()->renderer()->childAllowed() && style->display() != NONE) {
         m_render = new(document()->renderArena()) RenderPartObject(this);
         m_render->setStyle(style);
         parentNode()->renderer()->addChild(m_render, nextRenderer());
     }
     style->deref();
 
     NodeBaseImpl::attach();
 
     if (m_render && childWidget()) {
         static_cast<RenderPartObject *>(m_render)->setWidget(childWidget());
     }
 }
 
 void HTMLIFrameElementImpl::computeContent()
 {
     KHTMLPart *parentPart = document()->part();
 
     if (!parentPart) {
         return;
     }
 
     if (!document()->isURLAllowed(url)) {
         return;
     }
 
     if (!inDocument()) {
         clearChildWidget();
         return;
     }
 
     // get our name in order..
     ensureUniqueName();
 
     // make sure "" is handled as about: blank
     const QString aboutBlank = QLatin1String("about:blank");
     QString effectiveURL = url;
     if (effectiveURL.isEmpty()) {
         effectiveURL = aboutBlank;
     }
 
     // qCDebug(KHTML_LOG) << "-> requesting:" << name.string() << effectiveURL << contentPart();
 
     parentPart->loadFrameElement(this, effectiveURL, name.string(), QStringList(), true);
 }
 
 void HTMLIFrameElementImpl::setWidgetNotify(QWidget *widget)
 {
     if (m_render) {
         static_cast<RenderPartObject *>(m_render)->setWidget(widget);
     }
 }