/*

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

 * Copyright (C) 2006 Michael Emmel mike.emmel@gmail.com 

 * Copyright (C) 2007 Holger Hans Peter Freyther

 *

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#include "config.h"

#include "ScrollView.h"

#include "FloatRect.h"

#include "Frame.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "IntRect.h"

#include "NotImplemented.h"

#include "PlatformMouseEvent.h"

#include "PlatformWheelEvent.h"

#include "PlatformScrollBar.h"

#include "Page.h"

#include "RenderLayer.h"

#include <gdk/gdk.h>

#include <gtk/gtk.h>

using namespace std;

static const int MagicGtkScrollConstant = 13;

namespace WebCore {

class ScrollViewScrollbar : public PlatformScrollbar {

public:

    ScrollViewScrollbar(ScrollbarClient*, ScrollbarOrientation, ScrollbarControlSize);

protected:

    void geometryChanged();

};

class ScrollView::ScrollViewPrivate : public ScrollbarClient

{

public:

    ScrollViewPrivate(ScrollView* _view)

        : view(_view)

        , hasStaticBackground(false)

        , scrollbarsSuppressed(false)

        , vScrollbarMode(ScrollbarAuto)

        , hScrollbarMode(ScrollbarAuto)

        , inUpdateScrollbars(false)

        , horizontalAdjustment(0)

        , verticalAdjustment(0)

    {}

    ~ScrollViewPrivate()

    {

        setHasHorizontalScrollbar(false);

        setHasVerticalScrollbar(false);

        if (horizontalAdjustment) {

            g_signal_handlers_disconnect_by_func(G_OBJECT(horizontalAdjustment), (gpointer)ScrollViewPrivate::adjustmentChanged, this);

            g_object_unref(horizontalAdjustment);

        }

        if (verticalAdjustment) {

            g_signal_handlers_disconnect_by_func(G_OBJECT(verticalAdjustment), (gpointer)ScrollViewPrivate::adjustmentChanged, this);

            g_object_unref(verticalAdjustment);

        }

    }

    void scrollBackingStore(const IntSize& scrollDelta);

    void setHasHorizontalScrollbar(bool hasBar);

    void setHasVerticalScrollbar(bool hasBar);

    virtual void valueChanged(Scrollbar*);

    virtual IntRect windowClipRect() const;

    static void adjustmentChanged(GtkAdjustment*, gpointer);

    ScrollView* view;

    bool hasStaticBackground;

    bool scrollbarsSuppressed;

    ScrollbarMode vScrollbarMode;

    ScrollbarMode hScrollbarMode;

    RefPtr<ScrollViewScrollbar> vBar;

    RefPtr<ScrollViewScrollbar> hBar;

    IntSize scrollOffset;

    IntSize contentsSize;

    IntSize viewPortSize;

    bool inUpdateScrollbars;

    HashSet<Widget*> children;

    GtkAdjustment* horizontalAdjustment;

    GtkAdjustment* verticalAdjustment;

};

ScrollViewScrollbar::ScrollViewScrollbar(ScrollbarClient* client, ScrollbarOrientation orientation, ScrollbarControlSize size)

    : PlatformScrollbar(client, orientation, size)

{

}

void ScrollViewScrollbar::geometryChanged()

{

    if (!parent())

        return;

    ASSERT(parent()->isFrameView());

    FrameView* frameView = static_cast<FrameView*>(parent());

    IntRect windowRect = IntRect(frameView->convertToContainingWindow(frameGeometry().location()), frameGeometry().size());

    GtkAllocation allocation = { windowRect.x(), windowRect.y(), windowRect.width(), windowRect.height() };

    gtk_widget_size_allocate(gtkWidget(), &allocation);

}

void ScrollView::ScrollViewPrivate::setHasHorizontalScrollbar(bool hasBar)

{

    if (Scrollbar::hasPlatformScrollbars()) {

        if (hasBar && !hBar && !horizontalAdjustment) {

            hBar = new ScrollViewScrollbar(this, HorizontalScrollbar, RegularScrollbar);

            view->addChild(hBar.get());

        } else if (!hasBar && hBar) {

            view->removeChild(hBar.get());

            hBar = 0;

        }

    }

}

void ScrollView::ScrollViewPrivate::setHasVerticalScrollbar(bool hasBar)

{

    if (Scrollbar::hasPlatformScrollbars()) {

        if (hasBar && !vBar && !verticalAdjustment) {

            vBar = new ScrollViewScrollbar(this, VerticalScrollbar, RegularScrollbar);

            view->addChild(vBar.get());

        } else if (!hasBar && vBar) {

            view->removeChild(vBar.get());

            vBar = 0;

        }

    }

}

void ScrollView::ScrollViewPrivate::scrollBackingStore(const IntSize& scrollDelta)

{

    // Since scrolling is double buffered, we will be blitting the scroll view's intersection

    // with the clip rect every time to keep it smooth.

    IntRect clipRect = view->windowClipRect();

    IntRect scrollViewRect = view->convertToContainingWindow(IntRect(0, 0, view->visibleWidth(), view->visibleHeight()));

    IntRect updateRect = clipRect;

    updateRect.intersect(scrollViewRect);

    //FIXME update here?

    if (!hasStaticBackground) // The main frame can just blit the WebView window

       // FIXME: Find a way to blit subframes without blitting overlapping content

       view->scrollBackingStore(-scrollDelta.width(), -scrollDelta.height(), scrollViewRect, clipRect);

    else  {

       // We need to go ahead and repaint the entire backing store.  Do it now before moving the

       // plugins.

       view->addToDirtyRegion(updateRect);

       view->updateBackingStore();

    }

    view->geometryChanged();

    // Now update the window (which should do nothing but a blit of the backing store's updateRect and so should

    // be very fast).

    view->update();

}

void ScrollView::ScrollViewPrivate::adjustmentChanged(GtkAdjustment* adjustment, gpointer _that)

{

    ScrollViewPrivate* that = reinterpret_cast<ScrollViewPrivate*>(_that);

    // Figure out if we really moved.

    IntSize newOffset = that->scrollOffset;

    if (adjustment == that->horizontalAdjustment)

        newOffset.setWidth(static_cast<int>(gtk_adjustment_get_value(adjustment)));

    else if (adjustment == that->verticalAdjustment)

        newOffset.setHeight(static_cast<int>(gtk_adjustment_get_value(adjustment)));

    IntSize scrollDelta = newOffset - that->scrollOffset;

    if (scrollDelta == IntSize())

        return;

    that->scrollOffset = newOffset;

    if (that->scrollbarsSuppressed)

        return;

    that->scrollBackingStore(scrollDelta);

    static_cast<FrameView*>(that->view)->frame()->sendScrollEvent();

}

void ScrollView::ScrollViewPrivate::valueChanged(Scrollbar* bar)

{

    // Figure out if we really moved.

    IntSize newOffset = scrollOffset;

    if (bar) {

        if (bar == hBar)

            newOffset.setWidth(bar->value());

        else if (bar == vBar)

            newOffset.setHeight(bar->value());

    }

    IntSize scrollDelta = newOffset - scrollOffset;

    if (scrollDelta == IntSize())

        return;

    scrollOffset = newOffset;

    if (scrollbarsSuppressed)

        return;

    scrollBackingStore(scrollDelta);

    static_cast<FrameView*>(view)->frame()->sendScrollEvent();

}

IntRect ScrollView::ScrollViewPrivate::windowClipRect() const

{

    return static_cast<const FrameView*>(view)->windowClipRect(false);

}

ScrollView::ScrollView()

    : m_data(new ScrollViewPrivate(this))

{}

ScrollView::~ScrollView()

{

    delete m_data;

}

/*  

 * The following is assumed:

 *   (hadj && vadj) || (!hadj && !vadj)

 */ 

void ScrollView::setGtkAdjustments(GtkAdjustment* hadj, GtkAdjustment* vadj)

{

    ASSERT(!hadj == !vadj);

    if (m_data->horizontalAdjustment) {

        g_signal_handlers_disconnect_by_func(G_OBJECT(m_data->horizontalAdjustment), (gpointer)ScrollViewPrivate::adjustmentChanged, m_data);

        g_signal_handlers_disconnect_by_func(G_OBJECT(m_data->verticalAdjustment), (gpointer)ScrollViewPrivate::adjustmentChanged, m_data);

        g_object_unref(m_data->horizontalAdjustment);

        g_object_unref(m_data->verticalAdjustment);

    }

    m_data->horizontalAdjustment = hadj;

    m_data->verticalAdjustment = vadj;

    if (m_data->horizontalAdjustment) {

        g_signal_connect(m_data->horizontalAdjustment, "value-changed", G_CALLBACK(ScrollViewPrivate::adjustmentChanged), m_data);

        g_signal_connect(m_data->verticalAdjustment, "value-changed", G_CALLBACK(ScrollViewPrivate::adjustmentChanged), m_data);

        /*

         * disable the scrollbars (if we have any) as the GtkAdjustment over

         */

        m_data->setHasVerticalScrollbar(false);

        m_data->setHasHorizontalScrollbar(false);

        g_object_ref(m_data->horizontalAdjustment);

        gtk_object_sink(GTK_OBJECT(m_data->horizontalAdjustment));

        g_object_ref(m_data->verticalAdjustment);

        gtk_object_sink(GTK_OBJECT(m_data->verticalAdjustment));

    }

    updateScrollbars(m_data->scrollOffset);

}

void ScrollView::updateContents(const IntRect& updateRect, bool now)

{

    if (updateRect.isEmpty())

        return;

    IntPoint windowPoint = contentsToWindow(updateRect.location());

    IntRect containingWindowRect = updateRect;

    containingWindowRect.setLocation(windowPoint);

    GdkRectangle rect = { containingWindowRect.x(),

                          containingWindowRect.y(),

                          containingWindowRect.width(),

                          containingWindowRect.height() };

    GdkWindow* window = GTK_WIDGET(containingWindow())->window;

    if (window)

        gdk_window_invalidate_rect(window, &rect, true);

    // Cache the dirty spot.

    addToDirtyRegion(containingWindowRect);

    if (now && window)

        gdk_window_process_updates(window, true);

}

void ScrollView::update()

{

    ASSERT(containingWindow());

    GdkRectangle rect = { 0, 0, m_data->contentsSize.width(), m_data->contentsSize.height() };

    gdk_window_invalidate_rect(GTK_WIDGET(containingWindow())->window, &rect, true);

}

int ScrollView::visibleWidth() const

{

    return width() - (m_data->vBar ? m_data->vBar->width() : 0);

}

int ScrollView::visibleHeight() const

{

    return height() - (m_data->hBar ? m_data->hBar->height() : 0);

}

// Region of the content currently visible in the viewport in the content view's coordinate system.

FloatRect ScrollView::visibleContentRect() const

{

    return FloatRect(contentsX(), contentsY(), visibleWidth(), visibleHeight());

}

FloatRect ScrollView::visibleContentRectConsideringExternalScrollers() const

{

    // external scrollers not supported for now

    return visibleContentRect();

}

void ScrollView::setContentsPos(int newX, int newY)

{

    int dx = newX - contentsX();

    int dy = newY - contentsY();

    scrollBy(dx, dy);

}

void ScrollView::resizeContents(int w, int h)

{

    IntSize newSize(w, h);

    if (m_data->contentsSize == newSize)

        return;

    m_data->contentsSize = newSize;

    updateScrollbars(m_data->scrollOffset);

}

int ScrollView::contentsX() const

{

    return scrollOffset().width();

}

int ScrollView::contentsY() const

{

    return scrollOffset().height();

}

int ScrollView::contentsWidth() const

{

    return m_data->contentsSize.width();

}

int ScrollView::contentsHeight() const

{

    return m_data->contentsSize.height();

}

IntSize ScrollView::scrollOffset() const

{

    return m_data->scrollOffset;

}

IntSize ScrollView::maximumScroll() const

{

    IntSize delta = (m_data->contentsSize - IntSize(visibleWidth(), visibleHeight())) - scrollOffset();

    delta.clampNegativeToZero();

    return delta;

}

void ScrollView::scrollBy(int dx, int dy)

{

    IntSize scrollOffset = m_data->scrollOffset;

    IntSize newScrollOffset = scrollOffset + IntSize(dx, dy).shrunkTo(maximumScroll());

    newScrollOffset.clampNegativeToZero();

    if (newScrollOffset == scrollOffset)

        return;

    updateScrollbars(newScrollOffset);

}

ScrollbarMode ScrollView::hScrollbarMode() const

{

    return m_data->hScrollbarMode;

}

ScrollbarMode ScrollView::vScrollbarMode() const

{

    return m_data->vScrollbarMode;

}

void ScrollView::suppressScrollbars(bool suppressed, bool repaintOnSuppress)

{

    m_data->scrollbarsSuppressed = suppressed;

    if (repaintOnSuppress)

        updateScrollbars(m_data->scrollOffset);

}

void ScrollView::setHScrollbarMode(ScrollbarMode newMode)

{

    if (m_data->hScrollbarMode != newMode) {

        m_data->hScrollbarMode = newMode;

        updateScrollbars(m_data->scrollOffset);

    }

}

void ScrollView::setVScrollbarMode(ScrollbarMode newMode)

{

    if (m_data->vScrollbarMode != newMode) {

        m_data->vScrollbarMode = newMode;

        updateScrollbars(m_data->scrollOffset);

    }

}

void ScrollView::setScrollbarsMode(ScrollbarMode newMode)

{

    m_data->hScrollbarMode = m_data->vScrollbarMode = newMode;

    updateScrollbars(m_data->scrollOffset);

}

void ScrollView::setStaticBackground(bool flag)

{

    m_data->hasStaticBackground = flag;

}

void ScrollView::setFrameGeometry(const IntRect& newGeometry)

{

    ASSERT(isFrameView());

    IntRect oldGeometry = frameGeometry();

    Widget::setFrameGeometry(newGeometry);

    if (newGeometry == oldGeometry)

        return;

    if (newGeometry.width() != oldGeometry.width() || newGeometry.height() != oldGeometry.height()) {

        updateScrollbars(m_data->scrollOffset);

        static_cast<FrameView*>(this)->setNeedsLayout();

    }

    geometryChanged();

}

void ScrollView::addChild(Widget* child)

{ 

    child->setParent(this);

    child->setContainingWindow(containingWindow());

    m_data->children.add(child);

    if (child->gtkWidget())

        gtk_container_add(GTK_CONTAINER(containingWindow()), child->gtkWidget());

}

void ScrollView::removeChild(Widget* child)

{

    child->setParent(0);

    m_data->children.remove(child);

    if (child->gtkWidget() && GTK_WIDGET(containingWindow()) == GTK_WIDGET(child->gtkWidget())->parent)

        gtk_container_remove(GTK_CONTAINER(containingWindow()), child->gtkWidget());

}

void ScrollView::scrollRectIntoViewRecursively(const IntRect& r)

{

    IntPoint p(max(0, r.x()), max(0, r.y()));

    ScrollView* view = this;

    while (view) {

        view->setContentsPos(p.x(), p.y());

        p.move(view->x() - view->scrollOffset().width(), view->y() - view->scrollOffset().height());

        view = static_cast<ScrollView*>(view->parent());

    }

}

bool ScrollView::inWindow() const

{

    notImplemented();

    return true;

}

void ScrollView::wheelEvent(PlatformWheelEvent& e)

{

    // Determine how much we want to scroll.  If we can move at all, we will accept the event.

    IntSize maxScrollDelta = maximumScroll();

    if ((e.deltaX() < 0 && maxScrollDelta.width() > 0) ||

        (e.deltaX() > 0 && scrollOffset().width() > 0) ||

        (e.deltaY() < 0 && maxScrollDelta.height() > 0) ||

        (e.deltaY() > 0 && scrollOffset().height() > 0))

        e.accept();

    scrollBy(e.deltaX() * LINE_STEP, e.deltaY() * LINE_STEP);

}

void ScrollView::updateScrollbars(const IntSize& desiredOffset)

{

    // Don't allow re-entrancy into this function.

    if (m_data->inUpdateScrollbars)

        return;

    // FIXME: This code is here so we don't have to fork FrameView.h/.cpp.

    // In the end, FrameView should just merge with ScrollView.

    if (static_cast<const FrameView*>(this)->frame()->prohibitsScrolling())

        return;

    m_data->inUpdateScrollbars = true;

    bool hasVerticalScrollbar = m_data->vBar;

    bool hasHorizontalScrollbar = m_data->hBar;

    bool oldHasVertical = hasVerticalScrollbar;