/*

 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)

 *           (C) 1999 Antti Koivisto (koivisto@kde.org)

 *           (C) 2001 Dirk Mueller (mueller@kde.org)

 *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)

 * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.

 *

 * 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 "Document.h"

#include "AXObjectCache.h"

#include "CDATASection.h"

#include "CSSStyleSheet.h"

#include "CSSValueKeywords.h"

#include "Comment.h"

#include "DOMImplementation.h"

#include "DocLoader.h"

#include "DocumentFragment.h"

#include "DocumentLoader.h"

#include "DocumentType.h"

#include "EditingText.h"

#include "Editor.h"

#include "EditorClient.h"

#include "EntityReference.h"

#include "Event.h"

#include "EventHandler.h"

#include "EventListener.h"

#include "EventNames.h"

#include "ExceptionCode.h"

#include "FocusController.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "FrameTree.h"

#include "FrameView.h"

#include "HTMLBodyElement.h"

#include "HTMLDocument.h"

#include "HTMLElementFactory.h"

#include "HTMLFrameOwnerElement.h"

#include "HTMLHeadElement.h"

#include "HTMLImageLoader.h"

#include "HTMLInputElement.h"

#include "HTMLLinkElement.h"

#include "HTMLMapElement.h"

#include "HTMLNameCollection.h"

#include "HTMLNames.h"

#include "HTMLStyleElement.h"

#if PLATFORM(SYMBIAN)

#include "HTMLTokenizer.h"

#endif

#include "HTMLTitleElement.h"

#include "HTTPParsers.h"

#include "HitTestRequest.h"

#include "HitTestResult.h"

#include "JSEditor.h"

#include "KeyboardEvent.h"

#include "Logging.h"

#include "MouseEvent.h"

#include "MouseEventWithHitTestResults.h"

#include "MutationEvent.h"

#include "NameNodeList.h"

#include "NodeFilter.h"

#include "NodeIterator.h"

#include "OverflowEvent.h"

#include "Page.h"

#include "PlatformKeyboardEvent.h"

#include "ProcessingInstruction.h"

#include "RegisteredEventListener.h"

#include "RegularExpression.h"

#include "RenderArena.h"

#include "RenderView.h"

#include "RenderWidget.h"

#include "SecurityOrigin.h"

#include "SegmentedString.h"

#include "SelectionController.h"

#include "Settings.h"

#include "StringHash.h"

#include "StyleSheetList.h"

#include "SystemTime.h"

#include "TextEvent.h"

#include "TextIterator.h"

#include "TextResourceDecoder.h"

#include "TreeWalker.h"

#include "UIEvent.h"

#include "WheelEvent.h"

#include "XMLTokenizer.h"

#include "kjs_binding.h"

#include "kjs_proxy.h"

#if ENABLE(XPATH)

#include "XPathEvaluator.h"

#include "XPathExpression.h"

#include "XPathNSResolver.h"

#include "XPathResult.h"

#endif

#if ENABLE(XSLT)

#include "XSLTProcessor.h"

#endif

#if ENABLE(XBL)

#include "XBLBindingManager.h"

#endif

#if ENABLE(SVG)

#include "SVGDocumentExtensions.h"

#include "SVGElementFactory.h"

#include "SVGZoomEvent.h"

#include "SVGStyleElement.h"

#include "TimeScheduler.h"

#endif

#if PLATFORM(SYMBIAN)

#include "StaticObjectsContainer.h"

#include "ResourceLoaderDelegate.h"

#endif

using namespace std;

using namespace WTF;

using namespace Unicode;

namespace WebCore {

using namespace EventNames;

using namespace HTMLNames;

// #define INSTRUMENT_LAYOUT_SCHEDULING 1

// This amount of time must have elapsed before we will even consider scheduling a layout without a delay.

// FIXME: For faster machines this value can really be lowered to 200.  250 is adequate, but a little high

// for dual G5s. :)

static const int cLayoutScheduleThreshold = 250;

// Use 1 to represent the document's default form.

static HTMLFormElement* const defaultForm = reinterpret_cast<HTMLFormElement*>(1);

// Golden ratio - arbitrary start value to avoid mapping all 0's to all 0's

static const unsigned PHI = 0x9e3779b9U;

// DOM Level 2 says (letters added):

//

// a) Name start characters must have one of the categories Ll, Lu, Lo, Lt, Nl.

// b) Name characters other than Name-start characters must have one of the categories Mc, Me, Mn, Lm, or Nd.

// c) Characters in the compatibility area (i.e. with character code greater than #xF900 and less than #xFFFE) are not allowed in XML names.

// d) Characters which have a font or compatibility decomposition (i.e. those with a "compatibility formatting tag" in field 5 of the database -- marked by field 5 beginning with a "<") are not allowed.

// e) The following characters are treated as name-start characters rather than name characters, because the property file classifies them as Alphabetic: [#x02BB-#x02C1], #x0559, #x06E5, #x06E6.

// f) Characters #x20DD-#x20E0 are excluded (in accordance with Unicode, section 5.14).

// g) Character #x00B7 is classified as an extender, because the property list so identifies it.

// h) Character #x0387 is added as a name character, because #x00B7 is its canonical equivalent.

// i) Characters ':' and '_' are allowed as name-start characters.

// j) Characters '-' and '.' are allowed as name characters.

//

// It also contains complete tables. If we decide it's better, we could include those instead of the following code.

static inline bool isValidNameStart(UChar32 c)

{

    // rule (e) above

    if ((c >= 0x02BB && c <= 0x02C1) || c == 0x559 || c == 0x6E5 || c == 0x6E6)

        return true;

    // rule (i) above

    if (c == ':' || c == '_')

        return true;

    // rules (a) and (f) above

    const uint32_t nameStartMask = Letter_Lowercase | Letter_Uppercase | Letter_Other | Letter_Titlecase | Number_Letter;

    if (!(Unicode::category(c) & nameStartMask))

        return false;

    // rule (c) above

    if (c >= 0xF900 && c < 0xFFFE)

        return false;

    // rule (d) above

    DecompositionType decompType = decompositionType(c);

    if (decompType == DecompositionFont || decompType == DecompositionCompat)

        return false;

    return true;

}

static inline bool isValidNamePart(UChar32 c)

{

    // rules (a), (e), and (i) above

    if (isValidNameStart(c))

        return true;

    // rules (g) and (h) above

    if (c == 0x00B7 || c == 0x0387)

        return true;

    // rule (j) above

    if (c == '-' || c == '.')

        return true;

    // rules (b) and (f) above

    const uint32_t otherNamePartMask = Mark_NonSpacing | Mark_Enclosing | Mark_SpacingCombining | Letter_Modifier | Number_DecimalDigit;

    if (!(Unicode::category(c) & otherNamePartMask))

        return false;

    // rule (c) above

    if (c >= 0xF900 && c < 0xFFFE)

        return false;

    // rule (d) above

    DecompositionType decompType = decompositionType(c);

    if (decompType == DecompositionFont || decompType == DecompositionCompat)

        return false;

    return true;

}

static Widget* widgetForNode(Node* focusedNode)

  {

    if (!focusedNode)

        return 0;

    RenderObject* renderer = focusedNode->renderer();

    if (!renderer || !renderer->isWidget())

        return 0;

    return static_cast<RenderWidget*>(renderer)->widget();

}

static bool acceptsEditingFocus(Node *node)

{

    ASSERT(node);

    ASSERT(node->isContentEditable());

    Node *root = node->rootEditableElement();

    Frame* frame = node->document()->frame();

    if (!frame || !root)

        return false;

    return frame->editor()->shouldBeginEditing(rangeOfContents(root).get());

}

DeprecatedPtrList<Document>*  Document::changedDocuments = 0;

void cleanupChangedDocuments() {

    	if(Document::changedDocuments)

    		{

    		delete Document::changedDocuments;

    		Document::changedDocuments = NULL;

    		}

}

// FrameView might be 0

Document::Document(DOMImplementation* impl, Frame* frame, bool isXHTML)

    : ContainerNode(0)

    , m_implementation(impl)

    , m_domtree_version(0)

    , m_styleSheets(new StyleSheetList)

    , m_title("")

    , m_titleSetExplicitly(false)

    , m_imageLoadEventTimer(this, &Document::imageLoadEventTimerFired)

    , m_updateFocusAppearanceTimer(this, &Document::updateFocusAppearanceTimerFired)

#if ENABLE(XSLT)

    , m_transformSource(0)

#endif

    , m_xmlVersion("1.0")

    , m_xmlStandalone(false)

#if ENABLE(XBL)

    , m_bindingManager(new XBLBindingManager(this))

#endif

    , m_savedRenderer(0)

    , m_secureForms(0)

    , m_designMode(inherit)

    , m_selfOnlyRefCount(0)

#if ENABLE(SVG)

    , m_svgExtensions(0)

#endif

    , m_hasDashboardRegions(false)

    , m_dashboardRegionsDirty(false)

    , m_accessKeyMapValid(false)

    , m_createRenderers(true)

    , m_inPageCache(false)

    , m_isAllowedToLoadLocalResources(false)

    , m_useSecureKeyboardEntryWhenActive(false)

#if USE(LOW_BANDWIDTH_DISPLAY)

    , m_inLowBandwidthDisplay(false)

#endif

    , m_isXHTML(isXHTML)

    , m_numNodeLists(0)

{

    m_document.resetSkippingRef(this);

    m_printing = false;

    m_frame = frame;

    m_renderArena = 0;

    m_axObjectCache = 0;

    // FIXME: DocLoader probably no longer needs the frame argument

    m_docLoader = new DocLoader(frame, this);

    visuallyOrdered = false;

    m_bParsing = false;

    m_docChanged = false;

    m_tokenizer = 0;

    m_wellFormed = false;

    pMode = Strict;

    hMode = XHtml;

    m_textColor = Color::black;

    m_listenerTypes = 0;

    m_inDocument = true;

    m_inStyleRecalc = false;

    m_closeAfterStyleRecalc = false;

    m_usesDescendantRules = false;

    m_usesSiblingRules = false;

    m_usesFirstLineRules = false;

    m_usesFirstLetterRules = false;

    m_gotoAnchorNeededAfterStylesheetsLoad = false;

    m_styleSelector = new CSSStyleSelector(this, m_usersheet, m_styleSheets.get(), !inCompatMode());

    m_didCalculateStyleSelector = false;

    m_pendingStylesheets = 0;

    m_ignorePendingStylesheets = false;

    m_hasNodesWithPlaceholderStyle = false;

    m_pendingSheetLayout = NoLayoutWithPendingSheets;

    m_cssTarget = 0;

    resetLinkColor();

    resetVisitedLinkColor();

    resetActiveLinkColor();

    m_processingLoadEvent = false;

    m_startTime = currentTime();

    m_overMinimumLayoutThreshold = false;

    m_jsEditor = 0;

    initSecurityOrigin();

    static int docID = 0;

    m_docID = docID++;

}

void Document::removedLastRef()

{

    ASSERT(!m_deletionHasBegun);

    if (m_selfOnlyRefCount) {

        // If removing a child removes the last self-only ref, we don't

        // want the document to be destructed until after

        // removeAllChildren returns, so we guard ourselves with an

        // extra self-only ref.

        DocPtr<Document> guard(this);

        // We must make sure not to be retaining any of our children through

        // these extra pointers or we will create a reference cycle.

        m_docType = 0;

        m_focusedNode = 0;

        m_hoverNode = 0;

        m_activeNode = 0;

        m_titleElement = 0;

        m_documentElement = 0;

        removeAllChildren();

        deleteAllValues(m_markers);

        m_markers.clear();

        delete m_tokenizer;

        m_tokenizer = 0;

#ifndef NDEBUG

        m_inRemovedLastRefFunction = false;

#endif

    } else {

#ifndef NDEBUG

        m_deletionHasBegun = true;

#endif

        delete this;

    }

}

Document::~Document()

{

    ASSERT(!renderer());

    ASSERT(!m_inPageCache);

    ASSERT(!m_savedRenderer);

    removeAllEventListeners();

#if ENABLE(SVG)

    delete m_svgExtensions;

#endif

    XMLHttpRequest::detachRequests(this);

    {

        KJS::JSLock lock;

        KJS::ScriptInterpreter::forgetAllDOMNodesForDocument(this);

    }

    if (m_docChanged && changedDocuments)

        changedDocuments->remove(this);

    delete m_tokenizer;

    m_document.resetSkippingRef(0);

    delete m_styleSelector;

    delete m_docLoader;

    if (m_renderArena) {

        delete m_renderArena;

        m_renderArena = 0;

    }

#if ENABLE(XSLT)

    xmlFreeDoc((xmlDocPtr)m_transformSource);

#endif

#if ENABLE(XBL)

    delete m_bindingManager;

#endif

    deleteAllValues(m_markers);

    if (m_axObjectCache) {

        delete m_axObjectCache;

        m_axObjectCache = 0;

    }

    m_decoder = 0;

    if (m_jsEditor) {

        delete m_jsEditor;

        m_jsEditor = 0;

    }

    unsigned count = sizeof(m_nameCollectionInfo) / sizeof(m_nameCollectionInfo[0]);

    for (unsigned i = 0; i < count; i++)

        deleteAllValues(m_nameCollectionInfo[i]);

}

void Document::resetLinkColor()

{

    m_linkColor = Color(0, 0, 238);

}

void Document::resetVisitedLinkColor()

{

    m_visitedLinkColor = Color(85, 26, 139);    

}

void Document::resetActiveLinkColor()

{

    m_activeLinkColor.setNamedColor("red");

}

void Document::setDocType(PassRefPtr<DocumentType> docType)

{

    m_docType = docType;

}

DocumentType *Document::doctype() const

{

    return m_docType.get();

}

DOMImplementation* Document::implementation() const

{

    return m_implementation.get();

}

void Document::childrenChanged()

{

    // invalidate the document element we have cached in case it was replaced

    m_documentElement = 0;

}

Element* Document::documentElement() const

{

    if (!m_documentElement) {

        Node* n = firstChild();

        while (n && !n->isElementNode())

            n = n->nextSibling();

        m_documentElement = static_cast<Element*>(n);

    }

    return m_documentElement.get();

}

PassRefPtr<Element> Document::createElement(const String &name, ExceptionCode& ec)

{

    if (m_isXHTML) {

        if (!isValidName(name)) {

            ec = INVALID_CHARACTER_ERR;

            return 0;

        }

        return HTMLElementFactory::createHTMLElement(AtomicString(name), this, 0, false);

    } else

        return createElementNS(nullAtom, name, ec);

}

PassRefPtr<DocumentFragment> Document::createDocumentFragment()

{

    return new DocumentFragment(document());

}

PassRefPtr<Text> Document::createTextNode(const String &data)

{

    return new Text(this, data);

}

PassRefPtr<Comment> Document::createComment (const String &data)

{

    return new Comment(this, data);

}