/*

 * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>

 *                     1999 Lars Knoll <knoll@kde.org>

 *                     1999 Antti Koivisto <koivisto@kde.org>

 *                     2000 Dirk Mueller <mueller@kde.org>

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

 *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)

 *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)

 *

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

#include "Settings.h"

#include "AXObjectCache.h"

#include "EventHandler.h"

#include "FloatRect.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "FrameLoaderClient.h"

#include "GraphicsContext.h"

#include "HTMLDocument.h"

#include "HTMLFrameSetElement.h"

#include "HTMLNames.h"

#include "OverflowEvent.h"

#include "RenderPart.h"

#include "RenderPartObject.h"

#include "RenderTheme.h"

#include "RenderView.h"

#if PLATFORM(SYMBIAN)

#include "WebCoreFrameBridge.h"

#include "FrameTree.h"

#include "oom.h"

#endif

namespace WebCore {

using namespace HTMLNames;

struct ScheduledEvent {

    RefPtr<Event> m_event;

    RefPtr<EventTargetNode> m_eventTarget;

    bool m_tempEvent;

};

class FrameViewPrivate {

public:

    FrameViewPrivate(FrameView* view)

        : m_slowRepaintObjectCount(0)

        , layoutTimer(view, &FrameView::layoutTimerFired)

        , m_mediaType("screen")

        , m_enqueueEvents(0)

        , m_overflowStatusDirty(true)

        , m_viewportRenderer(0)

        , m_wasScrolledByUser(false)

        , m_inProgrammaticScroll(false)

    {

        isTransparent = false;

        baseBackgroundColor = Color::white;

        vmode = hmode = ScrollbarAuto;

        needToInitScrollbars = true;

        reset();

    }

    void reset()

    {

        useSlowRepaints = false;

        borderX = 30;

        borderY = 30;

        layoutTimer.stop();

        layoutRoot = 0;

        delayedLayout = false;

        doFullRepaint = true;

        layoutSchedulingEnabled = true;

        midLayout = false;

        layoutCount = 0;

        nestedLayoutCount = 0;

        firstLayout = true;

        repaintRects.clear();

        m_wasScrolledByUser = false;

    }

    bool doFullRepaint;

    ScrollbarMode vmode;

    ScrollbarMode hmode;

    bool useSlowRepaints;

    unsigned m_slowRepaintObjectCount;

    int borderX, borderY;

    Timer<FrameView> layoutTimer;

    bool delayedLayout;

    RefPtr<Node> layoutRoot;

    bool layoutSchedulingEnabled;

    bool midLayout;

    int layoutCount;

    unsigned nestedLayoutCount;

    bool firstLayout;

    bool needToInitScrollbars;

    bool isTransparent;

    Color baseBackgroundColor;

    // Used by objects during layout to communicate repaints that need to take place only

    // after all layout has been completed.

    Vector<RenderObject::RepaintInfo> repaintRects;

    String m_mediaType;

    unsigned m_enqueueEvents;

    Vector<ScheduledEvent*> m_scheduledEvents;

    bool m_overflowStatusDirty;

    bool horizontalOverflow;

    bool m_verticalOverflow;    

    RenderObject* m_viewportRenderer;

    bool m_wasScrolledByUser;

    bool m_inProgrammaticScroll;

};

FrameView::FrameView(Frame* frame)

    : m_refCount(1)

    , m_frame(frame)

    , d(new FrameViewPrivate(this))

{

    init();

    show();

}

FrameView::~FrameView()

{

    resetScrollbars();

    ASSERT(m_refCount == 0);

    ASSERT(d->m_scheduledEvents.isEmpty() && !d->m_enqueueEvents);

    if (m_frame) {

        ASSERT(m_frame->view() != this || !m_frame->document() || !m_frame->document()->renderer());

        RenderPart* renderer = m_frame->ownerRenderer();

        if (renderer && renderer->widget() == this)

            renderer->setWidget(0);

    }

    delete d;

    d = 0;

}

bool FrameView::isFrameView() const 

{ 

    return true; 

}

void FrameView::clearFrame()

{

    m_frame = 0;

}

void FrameView::resetScrollbars()

{

    // Reset the document's scrollbars back to our defaults before we yield the floor.

    d->firstLayout = true;

    suppressScrollbars(true);

    ScrollView::setVScrollbarMode(d->vmode);

    ScrollView::setHScrollbarMode(d->hmode);

    suppressScrollbars(false);

}

void FrameView::init()

{

    m_margins = IntSize(-1, -1); // undefined

    m_size = IntSize();

}

void FrameView::clear()

{

    setStaticBackground(false);

    d->reset();

    if (m_frame)

        if (RenderPart* renderer = m_frame->ownerRenderer())

            renderer->viewCleared();

    suppressScrollbars(true);

}

bool FrameView::didFirstLayout() const

{

    return !d->firstLayout;

}

void FrameView::initScrollbars()

{

    if (!d->needToInitScrollbars)

        return;

    d->needToInitScrollbars = false;

    setScrollbarsMode(hScrollbarMode());

}

void FrameView::setMarginWidth(int w)

{

    // make it update the rendering area when set

    m_margins.setWidth(w);

}

void FrameView::setMarginHeight(int h)

{

    // make it update the rendering area when set

    m_margins.setHeight(h);

}

void FrameView::adjustViewSize()

{

    ASSERT(m_frame->view() == this);

    RenderView* root = static_cast<RenderView*>(m_frame->renderer());

    if (!root)

        return;

    resizeContents(root->overflowWidth(), root->overflowHeight());

}

void FrameView::applyOverflowToViewport(RenderObject* o, ScrollbarMode& hMode, ScrollbarMode& vMode)

{

    // Handle the overflow:hidden/scroll case for the body/html elements.  WinIE treats

    // overflow:hidden and overflow:scroll on <body> as applying to the document's

    // scrollbars.  The CSS2.1 draft states that HTML UAs should use the <html> or <body> element and XML/XHTML UAs should

    // use the root element.

    switch (o->style()->overflowX()) {

        case OHIDDEN:

            hMode = ScrollbarAlwaysOff;

            break;

        case OSCROLL:

            hMode = ScrollbarAlwaysOn;

            break;

        case OAUTO:

            hMode = ScrollbarAuto;

            break;

        default:

            // Don't set it at all.

            ;

    }

     switch (o->style()->overflowY()) {

        case OHIDDEN:

            vMode = ScrollbarAlwaysOff;

            break;

        case OSCROLL:

            vMode = ScrollbarAlwaysOn;

            break;

        case OAUTO:

            vMode = ScrollbarAuto;

            break;

        default:

            // Don't set it at all.

            ;

    }

    d->m_viewportRenderer = o;

}

int FrameView::layoutCount() const

{

    return d->layoutCount;

}

bool FrameView::needsFullRepaint() const

{

    return d->doFullRepaint;

}

void FrameView::addRepaintInfo(RenderObject* o, const IntRect& r)

{

    d->repaintRects.append(RenderObject::RepaintInfo(o, r));

}

Node* FrameView::layoutRoot() const

{

    return layoutPending() ? 0 : d->layoutRoot.get();

}

void FrameView::layout(bool allowSubtree)

{

#if PLATFORM(SYMBIAN)

    OOM_PRE_CHECK(1024*1024*2, 0, "FrameView::layout")

#endif

    if (d->midLayout)

        return;

    d->layoutTimer.stop();

    d->delayedLayout = false;

    // Protect the view from being deleted during layout (in recalcStyle)

    RefPtr<FrameView> protector(this);

    if (!m_frame) {

        // FIXME: Do we need to set m_size.width here?

        // FIXME: Should we set m_size.height here too?

        m_size.setWidth(visibleWidth());

        return;

    }

    // we shouldn't enter layout() while painting

    ASSERT(!m_frame->isPainting());

    if (m_frame->isPainting())

        return;

    if (!allowSubtree && d->layoutRoot) {

        if (d->layoutRoot->renderer())

            d->layoutRoot->renderer()->markContainingBlocksForLayout(false);

        d->layoutRoot = 0;

    }

    ASSERT(m_frame->view() == this);

    Document* document = m_frame->document();

    if (!document) {

        // FIXME: Should we set m_size.height here too?

        m_size.setWidth(visibleWidth());

        return;

    }

    d->layoutSchedulingEnabled = false;

    // Always ensure our style info is up-to-date.  This can happen in situations where

    // the layout beats any sort of style recalc update that needs to occur.

    if (document->hasChangedChild())

        document->recalcStyle();

    bool subtree = d->layoutRoot;

    Node* rootNode = subtree ? d->layoutRoot.get() : document;

    // If there is only one ref to this view left, then its going to be destroyed as soon as we exit, 

    // so there's no point to continuiing to layout

    if (protector->hasOneRef())

        return;

    RenderObject* root = rootNode->renderer();

    if (!root) {

        // FIXME: Do we need to set m_size here?

        d->layoutSchedulingEnabled = true;

        return;

    }

    d->nestedLayoutCount++;

    ScrollbarMode hMode = d->hmode;

    ScrollbarMode vMode = d->vmode;

    if (!subtree) {

        Document* document = static_cast<Document*>(rootNode);

        RenderObject* rootRenderer = document->documentElement() ? document->documentElement()->renderer() : 0;

        if (document->isHTMLDocument()) {

            Node* body = static_cast<HTMLDocument*>(document)->body();

            if (body && body->renderer()) {

                if (body->hasTagName(framesetTag) && !m_frame->settings()->flatFrameSetLayoutEnabled()) {

                    body->renderer()->setChildNeedsLayout(true);

                    vMode = ScrollbarAlwaysOff;

                    hMode = ScrollbarAlwaysOff;

                } else if (body->hasTagName(bodyTag)) {

                    if (!d->firstLayout && m_size.height() != visibleHeight()

                            && static_cast<RenderBox*>(body->renderer())->stretchesToViewHeight())

                        body->renderer()->setChildNeedsLayout(true);

                    // It's sufficient to just check the X overflow,

                    // since it's illegal to have visible in only one direction.

                    RenderObject* o = rootRenderer->style()->overflowX() == OVISIBLE 

                        ? body->renderer() : rootRenderer;

                    applyOverflowToViewport(o, hMode, vMode); // Only applies to HTML UAs, not to XML/XHTML UAs

                }

            }

        } else if (rootRenderer)

            applyOverflowToViewport(rootRenderer, hMode, vMode); // XML/XHTML UAs use the root element.

#ifdef INSTRUMENT_LAYOUT_SCHEDULING

        if (d->firstLayout && !document->ownerElement())

            printf("Elapsed time before first layout: %d\n", document->elapsedTime());

#endif

    }

    d->doFullRepaint = !subtree && (d->firstLayout || static_cast<RenderView*>(root)->printing());

    d->repaintRects.clear();

    bool didFirstLayout = false;

    if (!subtree) {

        // Now set our scrollbar state for the layout.

        ScrollbarMode currentHMode = hScrollbarMode();

        ScrollbarMode currentVMode = vScrollbarMode();

        if (d->firstLayout || (hMode != currentHMode || vMode != currentVMode)) {

            suppressScrollbars(true);

            if (d->firstLayout) {

                d->firstLayout = false;

                didFirstLayout = true;

                // Set the initial vMode to AlwaysOn if we're auto.

                if (vMode == ScrollbarAuto)

                    ScrollView::setVScrollbarMode(ScrollbarAlwaysOn); // This causes a vertical scrollbar to appear.

                // Set the initial hMode to AlwaysOff if we're auto.

                if (hMode == ScrollbarAuto)

                    ScrollView::setHScrollbarMode(ScrollbarAlwaysOff); // This causes a horizontal scrollbar to disappear.

            }

            if (hMode == vMode)

                ScrollView::setScrollbarsMode(hMode);

            else {

                ScrollView::setHScrollbarMode(hMode);

                ScrollView::setVScrollbarMode(vMode);

            }

            suppressScrollbars(false, true);

        }

        IntSize oldSize = m_size;

        m_size = IntSize(visibleWidth(), visibleHeight());

        if (oldSize != m_size)

            d->doFullRepaint = true;

    }

    RenderLayer* layer = root->enclosingLayer();

    pauseScheduledEvents();

    if (subtree)

        root->view()->pushLayoutState(root);

    d->midLayout = true;

    root->layout();

    d->midLayout = false;

    if (subtree)

        root->view()->popLayoutState();

    d->layoutRoot = 0;

    m_frame->invalidateSelection();

    d->layoutSchedulingEnabled=true;

    if (!subtree && !static_cast<RenderView*>(root)->printing())

        adjustViewSize();

    // Now update the positions of all layers.

    layer->updateLayerPositions(d->doFullRepaint);

    // We update our widget positions right after doing a layout.

    if (!subtree)

        static_cast<RenderView*>(root)->updateWidgetPositions();

    // FIXME: Could optimize this and have objects removed from this list

    // if they ever do full repaints.

    Vector<RenderObject::RepaintInfo>::iterator end = d->repaintRects.end();

    for (Vector<RenderObject::RepaintInfo>::iterator it = d->repaintRects.begin(); it != end; ++it)

        it->m_object->repaintRectangle(it->m_repaintRect);

    d->repaintRects.clear();

    d->layoutCount++;

#if PLATFORM(MAC)

    if (AXObjectCache::accessibilityEnabled())

        root->document()->axObjectCache()->postNotificationToElement(root, "AXLayoutComplete");

#endif

    updateDashboardRegions();

#if PLATFORM(SYMBIAN)

    // Update focusable rect lists in main frame

    if (m_frame.get()->bridge()) {

        m_frame.get()->bridge()->updateFocusableRectList();

        m_frame.get()->bridge()->updateThumbnail();

    }

#endif

    if (didFirstLayout)

        m_frame->loader()->didFirstLayout();

    ASSERT(!root->needsLayout());

    setStaticBackground(useSlowRepaints());

    if (document->hasListenerType(Document::OVERFLOWCHANGED_LISTENER))

        updateOverflowStatus(visibleWidth() < contentsWidth(),

                             visibleHeight() < contentsHeight());

    if (m_widgetUpdateSet && d->nestedLayoutCount == 1) {

        Vector<RenderPartObject*> objectVector;

        copyToVector(*m_widgetUpdateSet, objectVector);

        size_t size = objectVector.size();

        for (size_t i = 0; i < size; ++i) {

            RenderPartObject* object = objectVector[i];

            object->updateWidget(false);

            // updateWidget() can destroy the RenderPartObject, so we need to make sure it's

            // alive by checking if it's still in m_widgetUpdateSet.

            if (m_widgetUpdateSet->contains(object))

                object->updateWidgetPosition();

        }

        m_widgetUpdateSet->clear();

    }

    // Allow events scheduled during layout to fire

    resumeScheduledEvents();

    d->nestedLayoutCount--;

#if PLATFORM(SYMBIAN)

    OOM_POST_CHECK_FAILED(unscheduleRelayout(); return;)

#endif

}

void FrameView::addWidgetToUpdate(RenderPartObject* object)

{

    if (!m_widgetUpdateSet)

        m_widgetUpdateSet.set(new HashSet<RenderPartObject*>);

    m_widgetUpdateSet->add(object);

}