--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webengine/osswebengine/WebCore/html/HTMLObjectElement.cpp Mon Mar 30 12:54:55 2009 +0300
@@ -0,0 +1,540 @@
+/*
+ * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
+ * (C) 1999 Antti Koivisto (koivisto@kde.org)
+ * (C) 2000 Stefan Schimanski (1Stein@gmx.de)
+ * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2007 Trolltech ASA
+ *
+ * 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 "config.h"
+#include "HTMLObjectElement.h"
+
+#include "CSSHelper.h"
+#include "EventNames.h"
+#include "ExceptionCode.h"
+#include "Frame.h"
+#include "FrameLoader.h"
+#include "FrameLoaderClient.h"
+#include "FrameView.h"
+#include "HTMLDocument.h"
+#include "HTMLFormElement.h"
+#include "HTMLImageLoader.h"
+#include "HTMLNames.h"
+#if PLATFORM(SYMBIAN)
+#include "HTMLTokenizer.h"
+#include "WebCoreWidget.h"
+#endif
+#include "Image.h"
+#include "MIMETypeRegistry.h"
+#include "RenderImage.h"
+#include "RenderPartObject.h"
+#include "RenderWidget.h"
+#include "Text.h"
+
+#if ENABLE(SVG)
+#include "SVGDocument.h"
+#endif
+
+namespace WebCore {
+
+using namespace EventNames;
+using namespace HTMLNames;
+
+HTMLObjectElement::HTMLObjectElement(Document* doc)
+ : HTMLPlugInElement(objectTag, doc)
+ , m_needWidgetUpdate(false)
+ , m_useFallbackContent(false)
+ , m_imageLoader(0)
+ , m_complete(false)
+ , m_docNamedItem(true)
+{
+#if PLATFORM(SYMBIAN)
+ HTMLTokenizer* tokenizer = static_cast<HTMLTokenizer*>(doc->document()->tokenizer());
+ m_canLoadPlugin = tokenizer ? tokenizer->isExecutingDocumentWrite() && tokenizer->isExecutingExternalScript() : false ;
+#endif
+}
+
+HTMLObjectElement::~HTMLObjectElement()
+{
+#if USE(JAVASCRIPTCORE_BINDINGS)
+ // m_instance should have been cleaned up in detach().
+ ASSERT(!m_instance);
+#endif
+
+ delete m_imageLoader;
+}
+
+#if USE(JAVASCRIPTCORE_BINDINGS)
+KJS::Bindings::Instance *HTMLObjectElement::getInstance() const
+{
+ Frame* frame = document()->frame();
+ if (!frame)
+ return 0;
+
+#if PLATFORM(SYMBIAN)
+ // if the plugin is already destroyed, need to clear the instance;
+ // this happens in out of memory situation.
+ if (m_instance) {
+ RenderWidget* renderWidget = (renderer() && renderer()->isWidget()) ? static_cast<RenderWidget*>(renderer()) : 0;
+ if (renderWidget && renderWidget->widget()) {
+ MWebCoreWidget* view = renderWidget->widget()->getView();
+ if (!view || !view->pluginScriptableObject()) {
+ m_instance = 0;
+ return m_instance.get();
+ }
+ }
+ }
+#endif
+
+ if (m_instance)
+ return m_instance.get();
+
+ RenderWidget* renderWidget = (renderer() && renderer()->isWidget()) ? static_cast<RenderWidget*>(renderer()) : 0;
+ if (renderWidget && !renderWidget->widget()) {
+ document()->updateLayoutIgnorePendingStylesheets();
+ renderWidget = (renderer() && renderer()->isWidget()) ? static_cast<RenderWidget*>(renderer()) : 0;
+ }
+ if (renderWidget && renderWidget->widget())
+ m_instance = frame->createScriptInstanceForWidget(renderWidget->widget());
+
+ return m_instance.get();
+}
+#endif
+
+void HTMLObjectElement::parseMappedAttribute(MappedAttribute *attr)
+{
+ String val = attr->value();
+ int pos;
+ if (attr->name() == typeAttr) {
+ m_serviceType = val.lower();
+ pos = m_serviceType.find(";");
+ if (pos != -1)
+ m_serviceType = m_serviceType.left(pos);
+ if (renderer())
+ m_needWidgetUpdate = true;
+ if (!isImageType() && m_imageLoader) {
+ delete m_imageLoader;
+ m_imageLoader = 0;
+ }
+ } else if (attr->name() == dataAttr) {
+ m_url = parseURL(val);
+ if (renderer())
+ m_needWidgetUpdate = true;
+ if (renderer() && isImageType()) {
+ if (!m_imageLoader)
+ m_imageLoader = new HTMLImageLoader(this);
+ m_imageLoader->updateFromElement();
+ }
+ } else if (attr->name() == classidAttr) {
+ m_classId = val;
+ if (renderer())
+ m_needWidgetUpdate = true;
+ } else if (attr->name() == onloadAttr) {
+ setHTMLEventListener(loadEvent, attr);
+ } else if (attr->name() == onunloadAttr) {
+ setHTMLEventListener(unloadEvent, attr);
+ } else if (attr->name() == nameAttr) {
+ String newNameAttr = attr->value();
+ if (isDocNamedItem() && inDocument() && document()->isHTMLDocument()) {
+ HTMLDocument *doc = static_cast<HTMLDocument *>(document());
+ doc->removeNamedItem(oldNameAttr);
+ doc->addNamedItem(newNameAttr);
+ }
+ oldNameAttr = newNameAttr;
+ } else if (attr->name() == idAttr) {
+ String newIdAttr = attr->value();
+ if (isDocNamedItem() && inDocument() && document()->isHTMLDocument()) {
+ HTMLDocument* doc = static_cast<HTMLDocument*>(document());
+ doc->removeDocExtraNamedItem(oldIdAttr);
+ doc->addDocExtraNamedItem(newIdAttr);
+ }
+ oldIdAttr = newIdAttr;
+ // also call superclass
+ HTMLPlugInElement::parseMappedAttribute(attr);
+ } else
+ HTMLPlugInElement::parseMappedAttribute(attr);
+}
+
+bool HTMLObjectElement::rendererIsNeeded(RenderStyle* style)
+{
+ if (m_useFallbackContent || isImageType())
+ return HTMLPlugInElement::rendererIsNeeded(style);
+
+ Frame* frame = document()->frame();
+ if (!frame)
+ return false;
+
+ return true;
+}
+
+RenderObject *HTMLObjectElement::createRenderer(RenderArena* arena, RenderStyle* style)
+{
+ if (m_useFallbackContent)
+ return RenderObject::createObject(this, style);
+ if (isImageType())
+ return new (arena) RenderImage(this);
+ return new (arena) RenderPartObject(this);
+}
+
+void HTMLObjectElement::attach()
+{
+ HTMLPlugInElement::attach();
+
+ if (renderer() && !m_useFallbackContent) {
+ if (isImageType()) {
+ if (!m_imageLoader)
+ m_imageLoader = new HTMLImageLoader(this);
+ m_imageLoader->updateFromElement();
+ if (renderer()) {
+ RenderImage* imageObj = static_cast<RenderImage*>(renderer());
+ imageObj->setCachedImage(m_imageLoader->image());
+ }
+ } else {
+ if (m_needWidgetUpdate) {
+ // Set m_needWidgetUpdate to false before calling updateWidget because updateWidget may cause
+ // this method or recalcStyle (which also calls updateWidget) to be called.
+ m_needWidgetUpdate = false;
+ static_cast<RenderPartObject*>(renderer())->updateWidget(true);
+ } else {
+ m_needWidgetUpdate = true;
+ setChanged();
+ }
+ }
+ }
+}
+
+void HTMLObjectElement::finishedParsing()
+{
+ // The parser just reached </object>.
+ setComplete(true);
+
+ HTMLPlugInElement::finishedParsing();
+}
+
+void HTMLObjectElement::setComplete(bool complete)
+{
+ if (complete != m_complete) {
+ m_complete = complete;
+ if (complete && !m_useFallbackContent) {
+ m_needWidgetUpdate = true;
+ if (inDocument())
+ setChanged();
+ }
+ }
+}
+
+void HTMLObjectElement::detach()
+{
+ if (attached() && renderer() && !m_useFallbackContent) {
+ // Update the widget the next time we attach (detaching destroys the plugin).
+ m_needWidgetUpdate = true;
+ }
+
+#if USE(JAVASCRIPTCORE_BINDINGS)
+ m_instance = 0;
+#endif
+ HTMLPlugInElement::detach();
+}
+
+void HTMLObjectElement::insertedIntoDocument()
+{
+ if (isDocNamedItem() && document()->isHTMLDocument()) {
+ HTMLDocument *doc = static_cast<HTMLDocument *>(document());
+ doc->addNamedItem(oldNameAttr);
+ doc->addDocExtraNamedItem(oldIdAttr);
+ }
+
+ HTMLPlugInElement::insertedIntoDocument();
+}
+
+void HTMLObjectElement::removedFromDocument()
+{
+ if (isDocNamedItem() && document()->isHTMLDocument()) {
+ HTMLDocument *doc = static_cast<HTMLDocument *>(document());
+ doc->removeNamedItem(oldNameAttr);
+ doc->removeDocExtraNamedItem(oldIdAttr);
+ }
+
+ HTMLPlugInElement::removedFromDocument();
+}
+
+void HTMLObjectElement::recalcStyle(StyleChange ch)
+{
+ if (!m_useFallbackContent && m_needWidgetUpdate && renderer() && !isImageType()) {
+ detach();
+ attach();
+ }
+ HTMLPlugInElement::recalcStyle(ch);
+}
+
+void HTMLObjectElement::childrenChanged()
+{
+ updateDocNamedItem();
+ if (inDocument() && !m_useFallbackContent) {
+ m_needWidgetUpdate = true;
+ setChanged();
+ }
+}
+
+bool HTMLObjectElement::isURLAttribute(Attribute *attr) const
+{
+ return (attr->name() == dataAttr || (attr->name() == usemapAttr && attr->value().domString()[0] != '#'));
+}
+
+bool HTMLObjectElement::isImageType()
+{
+ if (m_serviceType.isEmpty() && m_url.startsWith("data:")) {
+ // Extract the MIME type from the data URL.
+ int index = m_url.find(';');
+ if (index == -1)
+ index = m_url.find(',');
+ if (index != -1) {
+ int len = index - 5;
+ if (len > 0)
+ m_serviceType = m_url.substring(5, len);
+ else
+ m_serviceType = "text/plain"; // Data URLs with no MIME type are considered text/plain.
+ }
+ }
+ if (Frame* frame = document()->frame()) {
+ KURL completedURL(frame->loader()->completeURL(m_url));
+ return frame->loader()->client()->objectContentType(completedURL, m_serviceType) == ObjectContentImage;
+ }
+
+ return Image::supportsType(m_serviceType);
+}
+
+void HTMLObjectElement::renderFallbackContent()
+{
+ if (m_useFallbackContent)
+ return;
+
+ // Mark ourselves as using the fallback content.
+ m_useFallbackContent = true;
+
+ // Now do a detach and reattach.
+ // FIXME: Style gets recalculated which is suboptimal.
+ detach();
+ attach();
+}
+
+void HTMLObjectElement::updateDocNamedItem()
+{
+ // The rule is "<object> elements with no children other than
+ // <param> elements, unknown elements and whitespace can be
+ // found by name in a document, and other <object> elements cannot."
+ bool wasNamedItem = m_docNamedItem;
+ bool isNamedItem = true;
+ Node* child = firstChild();
+ while (child && isNamedItem) {
+ if (child->isElementNode()) {
+ Element* element = static_cast<Element*>(child);
+ if (HTMLElement::isRecognizedTagName(element->tagQName()) && !element->hasTagName(paramTag))
+ isNamedItem = false;
+ } else if (child->isTextNode()) {
+ if (!static_cast<Text*>(child)->containsOnlyWhitespace())
+ isNamedItem = false;
+ } else
+ isNamedItem = false;
+ child = child->nextSibling();
+ }
+ if (isNamedItem != wasNamedItem && document()->isHTMLDocument()) {
+ HTMLDocument* doc = static_cast<HTMLDocument*>(document());
+ if (isNamedItem) {
+ doc->addNamedItem(oldNameAttr);
+ doc->addDocExtraNamedItem(oldIdAttr);
+ } else {
+ doc->removeNamedItem(oldNameAttr);
+ doc->removeDocExtraNamedItem(oldIdAttr);
+ }
+ }
+ m_docNamedItem = isNamedItem;
+}
+
+String HTMLObjectElement::code() const
+{
+ return getAttribute(codeAttr);
+}
+
+void HTMLObjectElement::setCode(const String& value)
+{
+ setAttribute(codeAttr, value);
+}
+
+String HTMLObjectElement::archive() const
+{
+ return getAttribute(archiveAttr);
+}
+
+void HTMLObjectElement::setArchive(const String& value)
+{
+ setAttribute(archiveAttr, value);
+}
+
+String HTMLObjectElement::border() const
+{
+ return getAttribute(borderAttr);
+}
+
+void HTMLObjectElement::setBorder(const String& value)
+{
+ setAttribute(borderAttr, value);
+}
+
+String HTMLObjectElement::codeBase() const
+{
+ return getAttribute(codebaseAttr);
+}
+
+void HTMLObjectElement::setCodeBase(const String& value)
+{
+ setAttribute(codebaseAttr, value);
+}
+
+String HTMLObjectElement::codeType() const
+{
+ return getAttribute(codetypeAttr);
+}
+
+void HTMLObjectElement::setCodeType(const String& value)
+{
+ setAttribute(codetypeAttr, value);
+}
+
+String HTMLObjectElement::data() const
+{
+ return getAttribute(dataAttr);
+}
+
+void HTMLObjectElement::setData(const String& value)
+{
+ setAttribute(dataAttr, value);
+}
+
+bool HTMLObjectElement::declare() const
+{
+ return !getAttribute(declareAttr).isNull();
+}
+
+void HTMLObjectElement::setDeclare(bool declare)
+{
+ setAttribute(declareAttr, declare ? "" : 0);
+}
+
+int HTMLObjectElement::hspace() const
+{
+ return getAttribute(hspaceAttr).toInt();
+}
+
+void HTMLObjectElement::setHspace(int value)
+{
+ setAttribute(hspaceAttr, String::number(value));
+}
+
+String HTMLObjectElement::standby() const
+{
+ return getAttribute(standbyAttr);
+}
+
+void HTMLObjectElement::setStandby(const String& value)
+{
+ setAttribute(standbyAttr, value);
+}
+
+void HTMLObjectElement::setTabIndex(int tabIndex)
+{
+ setAttribute(tabindexAttr, String::number(tabIndex));
+}
+
+String HTMLObjectElement::type() const
+{
+ return getAttribute(typeAttr);
+}
+
+void HTMLObjectElement::setType(const String& value)
+{
+ setAttribute(typeAttr, value);
+}
+
+String HTMLObjectElement::useMap() const
+{
+ return getAttribute(usemapAttr);
+}
+
+void HTMLObjectElement::setUseMap(const String& value)
+{
+ setAttribute(usemapAttr, value);
+}
+
+int HTMLObjectElement::vspace() const
+{
+ return getAttribute(vspaceAttr).toInt();
+}
+
+void HTMLObjectElement::setVspace(int value)
+{
+ setAttribute(vspaceAttr, String::number(value));
+}
+
+bool HTMLObjectElement::containsJavaApplet() const
+{
+ if (MIMETypeRegistry::isJavaAppletMIMEType(type()))
+ return true;
+
+ Node* child = firstChild();
+ while (child) {
+ if (child->isElementNode()) {
+ Element* e = static_cast<Element*>(child);
+ if (e->hasTagName(paramTag) &&
+ e->getAttribute(nameAttr).domString().lower() == "type" &&
+ MIMETypeRegistry::isJavaAppletMIMEType(e->getAttribute(valueAttr).domString()))
+ return true;
+ else if (e->hasTagName(objectTag) && static_cast<HTMLObjectElement*>(e)->containsJavaApplet())
+ return true;
+ else if (e->hasTagName(appletTag))
+ return true;
+ }
+ child = child->nextSibling();
+ }
+
+ return false;
+}
+
+#if ENABLE(SVG)
+SVGDocument* HTMLObjectElement::getSVGDocument(ExceptionCode& ec) const
+{
+ Document* doc = contentDocument();
+ if (doc && doc->isSVGDocument())
+ return static_cast<SVGDocument*>(doc);
+ // Spec: http://www.w3.org/TR/SVG/struct.html#InterfaceGetSVGDocument
+ ec = NOT_SUPPORTED_ERR;
+ return 0;
+}
+#endif
+
+#if PLATFORM(SYMBIAN)
+bool HTMLObjectElement::isFocusable() const
+{
+ if (!renderer() || (renderer()->style() && renderer()->style()->visibility() != VISIBLE) ||
+ renderer()->width() == 0 || renderer()->height() == 0)
+ return false;
+ return static_cast<RenderPartObject*>(renderer())->isFocusable();
+}
+#endif
+
+}