/*

    Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)

    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 "qwebelement.h"

#include "CSSComputedStyleDeclaration.h"

#include "CSSMutableStyleDeclaration.h"

#include "CSSParser.h"

#include "CSSRule.h"

#include "CSSRuleList.h"

#include "CSSStyleRule.h"

#include "Document.h"

#include "DocumentFragment.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "HTMLElement.h"

#include "JSGlobalObject.h"

#include "JSHTMLElement.h"

#include "JSObject.h"

#include "NodeList.h"

#include "PropertyNameArray.h"

#include "RenderImage.h"

#include "StaticNodeList.h"

#include "qt_runtime.h"

#include "qwebframe.h"

#include "qwebframe_p.h"

#include "runtime_root.h"

#include <parser/SourceCode.h>

#include <wtf/Vector.h>

#include <wtf/text/CString.h>

#include <QPainter>

using namespace WebCore;

class QWebElementPrivate {

public:

};

/*!

    \class QWebElement

    \since 4.6

    \brief The QWebElement class provides convenient access to DOM elements in

    a QWebFrame.

    \inmodule QtWebKit

    A QWebElement object allows easy access to the document model, represented

    by a tree-like structure of DOM elements. The root of the tree is called

    the document element and can be accessed using

    QWebFrame::documentElement().

    Specific elements can be accessed using findAll() and findFirst(). These

    elements are identified using CSS selectors. The code snippet below

    demonstrates the use of findAll().

    \snippet webkitsnippets/webelement/main.cpp FindAll

    The first list contains all \c span elements in the document. The second

    list contains \c span elements that are children of \c p, classified with

    \c intro.

    Using findFirst() is more efficient than calling findAll(), and extracting

    the first element only in the list returned.

    Alternatively you can traverse the document manually using firstChild() and

    nextSibling():

    \snippet webkitsnippets/webelement/main.cpp Traversing with QWebElement

    Individual elements can be inspected or changed using methods such as attribute()

    or setAttribute(). For examle, to capture the user's input in a text field for later

    use (auto-completion), a browser could do something like this:

    \snippet webkitsnippets/webelement/main.cpp autocomplete1

    When the same page is later revisited, the browser can fill in the text field automatically

    by modifying the value attribute of the input element:

    \snippet webkitsnippets/webelement/main.cpp autocomplete2

    Another use case is to emulate a click event on an element. The following

    code snippet demonstrates how to call the JavaScript DOM method click() of

    a submit button:

    \snippet webkitsnippets/webelement/main.cpp Calling a DOM element method

    The underlying content of QWebElement is explicitly shared. Creating a copy

    of a QWebElement does not create a copy of the content. Instead, both

    instances point to the same element.

    The contents of child elements can be converted to plain text with

    toPlainText(); to XHTML using toInnerXml(). To include the element's tag in

    the output, use toOuterXml().

    It is possible to replace the contents of child elements using

    setPlainText() and setInnerXml(). To replace the element itself and its

    contents, use setOuterXml().

    \section1 Examples

    The \l{DOM Traversal Example} shows one way to traverse documents in a running

    example.

    The \l{Simple Selector Example} can be used to experiment with the searching

    features of this class and provides sample code you can start working with.

*/

/*!

    Constructs a null web element.

*/

QWebElement::QWebElement()

    : d(0)

    , m_element(0)

{

}

/*!

    \internal

*/

QWebElement::QWebElement(WebCore::Element* domElement)

    : d(0)

    , m_element(domElement)

{

    if (m_element)

        m_element->ref();

}

/*!

    \internal

*/

QWebElement::QWebElement(WebCore::Node* node)

    : d(0)

    , m_element(0)

{

    if (node && node->isHTMLElement()) {

        m_element = static_cast<HTMLElement*>(node);

        m_element->ref();

    }

}

/*!

    Constructs a copy of \a other.

*/

QWebElement::QWebElement(const QWebElement &other)

    : d(0)

    , m_element(other.m_element)

{

    if (m_element)

        m_element->ref();

}

/*!

    Assigns \a other to this element and returns a reference to this element.

*/

QWebElement &QWebElement::operator=(const QWebElement &other)

{

    // ### handle "d" assignment

    if (this != &other) {

        Element *otherElement = other.m_element;

        if (otherElement)

            otherElement->ref();

        if (m_element)

            m_element->deref();

        m_element = otherElement;

    }

    return *this;

}

/*!

    Destroys the element. However, the underlying DOM element is not destroyed.

*/

QWebElement::~QWebElement()

{

    delete d;

    if (m_element)

        m_element->deref();

}

bool QWebElement::operator==(const QWebElement& o) const

{

    return m_element == o.m_element;

}

bool QWebElement::operator!=(const QWebElement& o) const

{

    return m_element != o.m_element;

}

/*!

    Returns true if the element is a null element; otherwise returns false.

*/

bool QWebElement::isNull() const

{

    return !m_element;

}

/*!

    Returns a new list of child elements matching the given CSS selector

    \a selectorQuery. If there are no matching elements, an empty list is

    returned.

    \l{Standard CSS2 selector} syntax is used for the query.

    \note This search is performed recursively.

    \sa findFirst()

*/

QWebElementCollection QWebElement::findAll(const QString &selectorQuery) const

{

    return QWebElementCollection(*this, selectorQuery);

}

/*!

    Returns the first child element that matches the given CSS selector

    \a selectorQuery.

    \l{Standard CSS2 selector} syntax is used for the query.

    \note This search is performed recursively.

    \sa findAll()

*/

QWebElement QWebElement::findFirst(const QString &selectorQuery) const

{

    if (!m_element)

        return QWebElement();

    ExceptionCode exception = 0; // ###

    return QWebElement(m_element->querySelector(selectorQuery, exception).get());

}

/*!

    Replaces the existing content of this element with \a text.

    This is equivalent to setting the HTML innerText property.

    \sa toPlainText()

*/

void QWebElement::setPlainText(const QString &text)

{

    if (!m_element || !m_element->isHTMLElement())

        return;

    ExceptionCode exception = 0;

    static_cast<HTMLElement*>(m_element)->setInnerText(text, exception);

}

/*!

    Returns the text between the start and the end tag of this

    element.

    This is equivalent to reading the HTML innerText property.

    \sa setPlainText()

*/

QString QWebElement::toPlainText() const

{

    if (!m_element || !m_element->isHTMLElement())

        return QString();

    return static_cast<HTMLElement*>(m_element)->innerText();

}

/*!

    Replaces the contents of this element as well as its own tag with

    \a markup. The string may contain HTML or XML tags, which is parsed and

    formatted before insertion into the document.

    \note This is currently only implemented for (X)HTML elements.

    \sa toOuterXml(), toInnerXml(), setInnerXml()

*/

void QWebElement::setOuterXml(const QString &markup)

{

    if (!m_element || !m_element->isHTMLElement())

        return;

    ExceptionCode exception = 0;

    static_cast<HTMLElement*>(m_element)->setOuterHTML(markup, exception);

}

/*!

    Returns this element converted to XML, including the start and the end

    tags as well as its attributes.

    \note This is currently implemented for (X)HTML elements only.

    \sa setOuterXml(), setInnerXml(), toInnerXml()

*/

QString QWebElement::toOuterXml() const

{

    if (!m_element || !m_element->isHTMLElement())

        return QString();

    return static_cast<HTMLElement*>(m_element)->outerHTML();

}

/*!

    Replaces the contents of this element with \a markup. The string may

    contain HTML or XML tags, which is parsed and formatted before insertion

    into the document.

    \note This is currently implemented for (X)HTML elements only.

    \sa toInnerXml(), toOuterXml(), setOuterXml()

*/

void QWebElement::setInnerXml(const QString &markup)

{

    if (!m_element || !m_element->isHTMLElement())

        return;

    ExceptionCode exception = 0;

    static_cast<HTMLElement*>(m_element)->setInnerHTML(markup, exception);

}

/*!

    Returns the XML content between the element's start and end tags.

    \note This is currently implemented for (X)HTML elements only.

    \sa setInnerXml(), setOuterXml(), toOuterXml()

*/

QString QWebElement::toInnerXml() const

{

    if (!m_element || !m_element->isHTMLElement())

        return QString();

    return static_cast<HTMLElement*>(m_element)->innerHTML();

}

/*!

    Adds an attribute with the given \a name and \a value. If an attribute with

    the same name exists, its value is replaced by \a value.

    \sa attribute(), attributeNS(), setAttributeNS()

*/

void QWebElement::setAttribute(const QString &name, const QString &value)

{

    if (!m_element)

        return;

    ExceptionCode exception = 0;

    m_element->setAttribute(name, value, exception);

}

/*!

    Adds an attribute with the given \a name in \a namespaceUri with \a value.

    If an attribute with the same name exists, its value is replaced by

    \a value.

    \sa attributeNS(), attribute(), setAttribute()

*/

void QWebElement::setAttributeNS(const QString &namespaceUri, const QString &name, const QString &value)

{

    if (!m_element)

        return;

    WebCore::ExceptionCode exception = 0;

    m_element->setAttributeNS(namespaceUri, name, value, exception);

}

/*!

    Returns the attribute with the given \a name. If the attribute does not

    exist, \a defaultValue is returned.

    \sa setAttribute(), setAttributeNS(), attributeNS()

*/

QString QWebElement::attribute(const QString &name, const QString &defaultValue) const

{

    if (!m_element)

        return QString();

    if (m_element->hasAttribute(name))

        return m_element->getAttribute(name);

    else

        return defaultValue;

}

/*!

    Returns the attribute with the given \a name in \a namespaceUri. If the

    attribute does not exist, \a defaultValue is returned.

    \sa setAttributeNS(), setAttribute(), attribute()

*/

QString QWebElement::attributeNS(const QString &namespaceUri, const QString &name, const QString &defaultValue) const

{

    if (!m_element)

        return QString();

    if (m_element->hasAttributeNS(namespaceUri, name))

        return m_element->getAttributeNS(namespaceUri, name);

    else

        return defaultValue;

}

/*!

    Returns true if this element has an attribute with the given \a name;

    otherwise returns false.

    \sa attribute(), setAttribute()

*/

bool QWebElement::hasAttribute(const QString &name) const

{

    if (!m_element)

        return false;

    return m_element->hasAttribute(name);

}

/*!

    Returns true if this element has an attribute with the given \a name, in

    \a namespaceUri; otherwise returns false.

    \sa attributeNS(), setAttributeNS()

*/

bool QWebElement::hasAttributeNS(const QString &namespaceUri, const QString &name) const

{

    if (!m_element)

        return false;

    return m_element->hasAttributeNS(namespaceUri, name);

}

/*!

    Removes the attribute with the given \a name from this element.

    \sa attribute(), setAttribute(), hasAttribute()

*/

void QWebElement::removeAttribute(const QString &name)

{

    if (!m_element)

        return;

    ExceptionCode exception = 0;

    m_element->removeAttribute(name, exception);

}

/*!

    Removes the attribute with the given \a name, in \a namespaceUri, from this

    element.

    \sa attributeNS(), setAttributeNS(), hasAttributeNS()

*/

void QWebElement::removeAttributeNS(const QString &namespaceUri, const QString &name)

{

    if (!m_element)

        return;

    WebCore::ExceptionCode exception = 0;

    m_element->removeAttributeNS(namespaceUri, name, exception);

}

/*!

    Returns true if the element has any attributes defined; otherwise returns

    false;

    \sa attribute(), setAttribute()

*/

bool QWebElement::hasAttributes() const

{

    if (!m_element)

        return false;

    return m_element->hasAttributes();

}

/*!

    Return the list of attributes for the namespace given as \a namespaceUri.

    \sa attribute(), setAttribute()

*/

QStringList QWebElement::attributeNames(const QString& namespaceUri) const

{

    if (!m_element)

        return QStringList();

    QStringList attributeNameList;

    const NamedNodeMap* const attrs = m_element->attributes(/* read only = */ true);

    if (attrs) {

        const String namespaceUriString(namespaceUri); // convert QString -> String once

        const unsigned attrsCount = attrs->length();

        for (unsigned i = 0; i < attrsCount; ++i) {

            const Attribute* const attribute = attrs->attributeItem(i);

            if (namespaceUriString == attribute->namespaceURI())

                attributeNameList.append(attribute->localName());

        }

    }

    return attributeNameList;

}

/*!

    Returns true if the element has keyboard input focus; otherwise, returns false

    \sa setFocus()

*/

bool QWebElement::hasFocus() const

{

    if (!m_element)

        return false;

    if (m_element->document())

        return m_element == m_element->document()->focusedNode();

    return false;

}

/*!

    Gives keyboard input focus to this element

    \sa hasFocus()

*/

void QWebElement::setFocus()

{

    if (!m_element)

        return;

    if (m_element->document() && m_element->isFocusable())

        m_element->document()->setFocusedNode(m_element);

}

/*!

    Returns the geometry of this element, relative to its containing frame.

    \sa tagName()