/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qabstractscrollarea.h"

#ifndef QT_NO_SCROLLAREA

#include "qscrollbar.h"

#include "qapplication.h"

#include "qstyle.h"

#include "qstyleoption.h"

#include "qevent.h"

#include "qdebug.h"

#include "qboxlayout.h"

#include "qpainter.h"

#include "qmargins.h"

#include "qabstractscrollarea_p.h"

#include <qwidget.h>

#include <private/qapplication_p.h>

#ifdef Q_WS_MAC

#include <private/qt_mac_p.h>

#include <private/qt_cocoa_helpers_mac_p.h>

#endif

QT_BEGIN_NAMESPACE

/*!

    \class QAbstractScrollArea

    \brief The QAbstractScrollArea widget provides a scrolling area with

    on-demand scroll bars.

    \ingroup abstractwidgets

    QAbstractScrollArea is a low-level abstraction of a scrolling

    area. The area provides a central widget called the viewport, in

    which the contents of the area is to be scrolled (i.e, the

    visible parts of the contents are rendered in the viewport).

    Next to the viewport is a vertical scroll bar, and below is a

    horizontal scroll bar. When all of the area contents fits in the

    viewport, each scroll bar can be either visible or hidden

    depending on the scroll bar's Qt::ScrollBarPolicy. When a scroll

    bar is hidden, the viewport expands in order to cover all

    available space. When a scroll bar becomes visible again, the

    viewport shrinks in order to make room for the scroll bar.

    It is possible to reserve a margin area around the viewport, see

    setViewportMargins(). The feature is mostly used to place a

    QHeaderView widget above or beside the scrolling area. Subclasses

    of QAbstractScrollArea should implement margins.

    When inheriting QAbstractScrollArea, you need to do the

    following:

    \list

        \o Control the scroll bars by setting their

           range, value, page step, and tracking their

           movements.

        \o Draw the contents of the area in the viewport according

           to the values of the scroll bars.

        \o Handle events received by the viewport in

           viewportEvent() - notably resize events.

        \o Use \c{viewport->update()} to update the contents of the

          viewport instead of \l{QWidget::update()}{update()}

          as all painting operations take place on the viewport.

    \endlist

    With a scroll bar policy of Qt::ScrollBarAsNeeded (the default),

    QAbstractScrollArea shows scroll bars when they provide a non-zero

    scrolling range, and hides them otherwise.

    The scroll bars and viewport should be updated whenever the viewport

    receives a resize event or the size of the contents changes.

    The viewport also needs to be updated when the scroll bars

    values change. The initial values of the scroll bars are often

    set when the area receives new contents.

    We give a simple example, in which we have implemented a scroll area

    that can scroll any QWidget. We make the widget a child of the

    viewport; this way, we do not have to calculate which part of

    the widget to draw but can simply move the widget with

    QWidget::move(). When the area contents or the viewport size

    changes, we do the following:

    \snippet doc/src/snippets/myscrollarea.cpp 1

    When the scroll bars change value, we need to update the widget

    position, i.e., find the part of the widget that is to be drawn in

    the viewport:

    \snippet doc/src/snippets/myscrollarea.cpp 0

    In order to track scroll bar movements, reimplement the virtual

    function scrollContentsBy(). In order to fine-tune scrolling

    behavior, connect to a scroll bar's

    QAbstractSlider::actionTriggered() signal and adjust the \l

    QAbstractSlider::sliderPosition as you wish.

    For convenience, QAbstractScrollArea makes all viewport events

    available in the virtual viewportEvent() handler. QWidget's

    specialized handlers are remapped to viewport events in the cases

    where this makes sense. The remapped specialized handlers are:

    paintEvent(), mousePressEvent(), mouseReleaseEvent(),

    mouseDoubleClickEvent(), mouseMoveEvent(), wheelEvent(),

    dragEnterEvent(), dragMoveEvent(), dragLeaveEvent(), dropEvent(),

    contextMenuEvent(),  and resizeEvent().

    QScrollArea, which inherits QAbstractScrollArea, provides smooth

    scrolling for any QWidget (i.e., the widget is scrolled pixel by

    pixel). You only need to subclass QAbstractScrollArea if you need

    more specialized behavior. This is, for instance, true if the

    entire contents of the area is not suitable for being drawn on a

    QWidget or if you do not want smooth scrolling.

    \sa QScrollArea

*/

QAbstractScrollAreaPrivate::QAbstractScrollAreaPrivate()

    :hbar(0), vbar(0), vbarpolicy(Qt::ScrollBarAsNeeded), hbarpolicy(Qt::ScrollBarAsNeeded),

     viewport(0), cornerWidget(0), left(0), top(0), right(0), bottom(0),

     xoffset(0), yoffset(0), viewportFilter(0)

#ifdef Q_WS_WIN

     , singleFingerPanEnabled(false)

#endif

{

}

QAbstractScrollAreaScrollBarContainer::QAbstractScrollAreaScrollBarContainer(Qt::Orientation orientation, QWidget *parent)

    :QWidget(parent), scrollBar(new QScrollBar(orientation, this)),

     layout(new QBoxLayout(orientation == Qt::Horizontal ? QBoxLayout::LeftToRight : QBoxLayout::TopToBottom)),

     orientation(orientation)

{

    setLayout(layout);

    layout->setMargin(0);

    layout->setSpacing(0);

    layout->addWidget(scrollBar);

}

/*! \internal

    Adds a widget to the scroll bar container.

*/

void QAbstractScrollAreaScrollBarContainer::addWidget(QWidget *widget, LogicalPosition position)

{

    QSizePolicy policy = widget->sizePolicy();

    if (orientation == Qt::Vertical)

        policy.setHorizontalPolicy(QSizePolicy::Ignored);

    else

        policy.setVerticalPolicy(QSizePolicy::Ignored);

    widget->setSizePolicy(policy);

    widget->setParent(this);

    const int insertIndex = (position & LogicalLeft) ? 0 : scrollBarLayoutIndex() + 1;

    layout->insertWidget(insertIndex, widget);

}

/*! \internal

    Retuns a list of scroll bar widgets for the given position. The scroll bar

    itself is not returned.

*/

QWidgetList QAbstractScrollAreaScrollBarContainer::widgets(LogicalPosition position)

{

    QWidgetList list;

    const int scrollBarIndex = scrollBarLayoutIndex();

    if (position == LogicalLeft) {

        for (int i = 0; i < scrollBarIndex; ++i)

            list.append(layout->itemAt(i)->widget());

    } else if (position == LogicalRight) {

        const int layoutItemCount = layout->count();

        for (int i = scrollBarIndex + 1; i < layoutItemCount; ++i)

            list.append(layout->itemAt(i)->widget());

    }

    return list;

}

/*! \internal

    Returns the layout index for the scroll bar. This needs to be

    recalculated by a linear search for each use, since items in

    the layout can be removed at any time (i.e. when a widget is

    deleted or re-parented).

*/

int QAbstractScrollAreaScrollBarContainer::scrollBarLayoutIndex() const

{

    const int layoutItemCount = layout->count();

    for (int i = 0; i < layoutItemCount; ++i) {

        if (qobject_cast<QScrollBar *>(layout->itemAt(i)->widget()))

            return i;

    }

    return -1;

}

/*! \internal

*/

void QAbstractScrollAreaPrivate::replaceScrollBar(QScrollBar *scrollBar,

                                                  Qt::Orientation orientation)

{

    Q_Q(QAbstractScrollArea);

    QAbstractScrollAreaScrollBarContainer *container = scrollBarContainers[orientation];

    bool horizontal = (orientation == Qt::Horizontal);

    QScrollBar *oldBar = horizontal ? hbar : vbar;

    if (horizontal)

        hbar = scrollBar;

    else

        vbar = scrollBar;

    scrollBar->setParent(container);

    container->scrollBar = scrollBar;

    container->layout->removeWidget(oldBar);

    container->layout->insertWidget(0, scrollBar);

    scrollBar->setVisible(oldBar->isVisibleTo(container));

    scrollBar->setInvertedAppearance(oldBar->invertedAppearance());

    scrollBar->setInvertedControls(oldBar->invertedControls());

    scrollBar->setRange(oldBar->minimum(), oldBar->maximum());

    scrollBar->setOrientation(oldBar->orientation());

    scrollBar->setPageStep(oldBar->pageStep());

    scrollBar->setSingleStep(oldBar->singleStep());

    scrollBar->setSliderDown(oldBar->isSliderDown());

    scrollBar->setSliderPosition(oldBar->sliderPosition());

    scrollBar->setTracking(oldBar->hasTracking());

    scrollBar->setValue(oldBar->value());

    delete oldBar;

    QObject::connect(scrollBar, SIGNAL(valueChanged(int)),

                     q, horizontal ? SLOT(_q_hslide(int)) : SLOT(_q_vslide(int)));

    QObject::connect(scrollBar, SIGNAL(rangeChanged(int,int)),

                     q, SLOT(_q_showOrHideScrollBars()), Qt::QueuedConnection);

}

void QAbstractScrollAreaPrivate::init()

{

    Q_Q(QAbstractScrollArea);

    viewport = new QWidget(q);

    viewport->setObjectName(QLatin1String("qt_scrollarea_viewport"));

    viewport->setBackgroundRole(QPalette::Base);

    viewport->setAutoFillBackground(true);

    scrollBarContainers[Qt::Horizontal] = new QAbstractScrollAreaScrollBarContainer(Qt::Horizontal, q);

    scrollBarContainers[Qt::Horizontal]->setObjectName(QLatin1String("qt_scrollarea_hcontainer"));

    hbar = scrollBarContainers[Qt::Horizontal]->scrollBar;

    hbar->setRange(0,0);

    scrollBarContainers[Qt::Horizontal]->setVisible(false);

    QObject::connect(hbar, SIGNAL(valueChanged(int)), q, SLOT(_q_hslide(int)));

    QObject::connect(hbar, SIGNAL(rangeChanged(int,int)), q, SLOT(_q_showOrHideScrollBars()), Qt::QueuedConnection);

    scrollBarContainers[Qt::Vertical] = new QAbstractScrollAreaScrollBarContainer(Qt::Vertical, q);

    scrollBarContainers[Qt::Vertical]->setObjectName(QLatin1String("qt_scrollarea_vcontainer"));

    vbar = scrollBarContainers[Qt::Vertical]->scrollBar;

    vbar->setRange(0,0);

    scrollBarContainers[Qt::Vertical]->setVisible(false);

    QObject::connect(vbar, SIGNAL(valueChanged(int)), q, SLOT(_q_vslide(int)));

    QObject::connect(vbar, SIGNAL(rangeChanged(int,int)), q, SLOT(_q_showOrHideScrollBars()), Qt::QueuedConnection);

    viewportFilter.reset(new QAbstractScrollAreaFilter(this));

    viewport->installEventFilter(viewportFilter.data());

    viewport->setFocusProxy(q);

    q->setFocusPolicy(Qt::WheelFocus);

    q->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);

    q->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

    layoutChildren();

#ifndef Q_WS_MAC

    viewport->grabGesture(Qt::PanGesture);

#endif

}

#ifdef Q_WS_WIN

void QAbstractScrollAreaPrivate::setSingleFingerPanEnabled(bool on)

{

    singleFingerPanEnabled = on;

    QWidgetPrivate *dd = static_cast<QWidgetPrivate *>(QObjectPrivate::get(viewport));

    if (dd)

        dd->winSetupGestures();

}

#endif // Q_WS_WIN

void QAbstractScrollAreaPrivate::layoutChildren()

{

    Q_Q(QAbstractScrollArea);

    bool needh = (hbarpolicy == Qt::ScrollBarAlwaysOn

                  || (hbarpolicy == Qt::ScrollBarAsNeeded && hbar->minimum() < hbar->maximum()));

    bool needv = (vbarpolicy == Qt::ScrollBarAlwaysOn

                  || (vbarpolicy == Qt::ScrollBarAsNeeded && vbar->minimum() < vbar->maximum()));

#ifdef Q_WS_MAC

    QWidget * const window = q->window();

    // Use small scroll bars for tool windows, to match the native size grip.

    bool hbarIsSmall = hbar->testAttribute(Qt::WA_MacSmallSize);

    bool vbarIsSmall = vbar->testAttribute(Qt::WA_MacSmallSize);

    const Qt::WindowType windowType = window->windowType();

    if (windowType == Qt::Tool) {

        if (!hbarIsSmall) {

            hbar->setAttribute(Qt::WA_MacMiniSize, false);

            hbar->setAttribute(Qt::WA_MacNormalSize, false);

            hbar->setAttribute(Qt::WA_MacSmallSize, true);

        }

        if (!vbarIsSmall) {

            vbar->setAttribute(Qt::WA_MacMiniSize, false);

            vbar->setAttribute(Qt::WA_MacNormalSize, false);

            vbar->setAttribute(Qt::WA_MacSmallSize, true);

        }

    } else {

        if (hbarIsSmall) {

            hbar->setAttribute(Qt::WA_MacMiniSize, false);

            hbar->setAttribute(Qt::WA_MacNormalSize, false);

            hbar->setAttribute(Qt::WA_MacSmallSize, false);

        }

        if (vbarIsSmall) {

            vbar->setAttribute(Qt::WA_MacMiniSize, false);

            vbar->setAttribute(Qt::WA_MacNormalSize, false);

            vbar->setAttribute(Qt::WA_MacSmallSize, false);

        }

     }

#endif

    const int hsbExt = hbar->sizeHint().height();

    const int vsbExt = vbar->sizeHint().width();

    const QPoint extPoint(vsbExt, hsbExt);

    const QSize extSize(vsbExt, hsbExt);

    const QRect widgetRect = q->rect();

    QStyleOption opt(0);

    opt.init(q);

    const bool hasCornerWidget = (cornerWidget != 0);

// If the scroll bars are at the very right and bottom of the window we

// move their positions to be aligned with the size grip.

#ifdef Q_WS_MAC

    // Check if a native sizegrip is present.

    bool hasMacReverseSizeGrip = false;

    bool hasMacSizeGrip = false;

    bool nativeGripPresent = false;

    if (q->testAttribute(Qt::WA_WState_Created))

        nativeGripPresent = qt_mac_checkForNativeSizeGrip(q);

    if (nativeGripPresent) {

        // Look for a native size grip at the visual window bottom right and at the

        // absolute window bottom right. In reverse mode, the native size grip does not

        // swich side, so we need to check if it is on the "wrong side".

        const QPoint scrollAreaBottomRight = q->mapTo(window, widgetRect.bottomRight() - QPoint(frameWidth, frameWidth));

        const QPoint windowBottomRight = window->rect().bottomRight();

        const QPoint visualWindowBottomRight = QStyle::visualPos(opt.direction, opt.rect, windowBottomRight);

        const QPoint offset = windowBottomRight - scrollAreaBottomRight;

        const QPoint visualOffset = visualWindowBottomRight - scrollAreaBottomRight;

        hasMacSizeGrip = (visualOffset.manhattanLength() < vsbExt);

        hasMacReverseSizeGrip = (hasMacSizeGrip == false && (offset.manhattanLength() < hsbExt));

    }

#endif

    QPoint cornerOffset(needv ? vsbExt : 0, needh ? hsbExt : 0);

    QRect controlsRect;

    QRect viewportRect;

    // In FrameOnlyAroundContents mode the frame is drawn between the controls and

    // the viewport, else the frame rect is equal to the widget rect.

    if ((frameStyle != QFrame::NoFrame) &&

        q->style()->styleHint(QStyle::SH_ScrollView_FrameOnlyAroundContents, &opt, q)) {

        controlsRect = widgetRect;

        const int extra = q->style()->pixelMetric(QStyle::PM_ScrollView_ScrollBarSpacing);

        const QPoint cornerExtra(needv ? extra : 0, needh ? extra : 0);

        QRect frameRect = widgetRect;

        frameRect.adjust(0, 0, -cornerOffset.x() - cornerExtra.x(), -cornerOffset.y() - cornerExtra.y());

        q->setFrameRect(QStyle::visualRect(opt.direction, opt.rect, frameRect));

        // The frame rect needs to be in logical coords, however we need to flip

        // the contentsRect back before passing it on to the viewportRect

        // since the viewportRect has its logical coords calculated later.

        viewportRect = QStyle::visualRect(opt.direction, opt.rect, q->contentsRect());

    } else {

        q->setFrameRect(QStyle::visualRect(opt.direction, opt.rect, widgetRect));

        controlsRect = q->contentsRect();

        viewportRect = QRect(controlsRect.topLeft(), controlsRect.bottomRight() - cornerOffset);

    }

    // If we have a corner widget and are only showing one scroll bar, we need to move it

    // to make room for the corner widget.

    if (hasCornerWidget && (needv || needh))

        cornerOffset =  extPoint;

#ifdef Q_WS_MAC

    // Also move the scroll bars if they are covered by the native Mac size grip.

    if (hasMacSizeGrip)

        cornerOffset =  extPoint;

#endif

    // The corner point is where the scroll bar rects, the corner widget rect and the

    // viewport rect meets.

    const QPoint cornerPoint(controlsRect.bottomRight() + QPoint(1, 1) - cornerOffset);

    // Some styles paints the corner if both scorllbars are showing and there is

    // no corner widget. Also, on the Mac we paint if there is a native

    // (transparent) sizegrip in the area where a corner widget would be.

    if ((needv && needh && hasCornerWidget == false)

        || ((needv || needh) 

#ifdef Q_WS_MAC

        && hasMacSizeGrip

#endif

        )

    ) {

        cornerPaintingRect = QStyle::visualRect(opt.direction, opt.rect, QRect(cornerPoint, extSize));

    } else {

        cornerPaintingRect = QRect();

    }

#ifdef Q_WS_MAC

    if (hasMacReverseSizeGrip)

        reverseCornerPaintingRect = QRect(controlsRect.bottomRight() + QPoint(1, 1) - extPoint, extSize);

    else

        reverseCornerPaintingRect = QRect();

#endif

    if (needh) {

        QRect horizontalScrollBarRect(QPoint(controlsRect.left(), cornerPoint.y()), QPoint(cornerPoint.x() - 1, controlsRect.bottom()));

#ifdef Q_WS_MAC

        if (hasMacReverseSizeGrip)

            horizontalScrollBarRect.adjust(vsbExt, 0, 0, 0);

#endif

        scrollBarContainers[Qt::Horizontal]->setGeometry(QStyle::visualRect(opt.direction, opt.rect, horizontalScrollBarRect));

        scrollBarContainers[Qt::Horizontal]->raise();

    }

    if (needv) {

        const QRect verticalScrollBarRect  (QPoint(cornerPoint.x(), controlsRect.top()),  QPoint(controlsRect.right(), cornerPoint.y() - 1));

        scrollBarContainers[Qt::Vertical]->setGeometry(QStyle::visualRect(opt.direction, opt.rect, verticalScrollBarRect));

        scrollBarContainers[Qt::Vertical]->raise();

    }

    if (cornerWidget) {

        const QRect cornerWidgetRect(cornerPoint, controlsRect.bottomRight());

        cornerWidget->setGeometry(QStyle::visualRect(opt.direction, opt.rect, cornerWidgetRect));

    }

    scrollBarContainers[Qt::Horizontal]->setVisible(needh);

    scrollBarContainers[Qt::Vertical]->setVisible(needv);

    if (q->isRightToLeft())

        viewportRect.adjust(right, top, -left, -bottom);

    else

        viewportRect.adjust(left, top, -right, -bottom);

    viewport->setGeometry(QStyle::visualRect(opt.direction, opt.rect, viewportRect)); // resize the viewport last

}

/*!

    \internal

    Creates a new QAbstractScrollAreaPrivate, \a dd with the given \a parent.

*/

QAbstractScrollArea::QAbstractScrollArea(QAbstractScrollAreaPrivate &dd, QWidget *parent)

    :QFrame(dd, parent)

{

    Q_D(QAbstractScrollArea);

    QT_TRY {

        d->init();

    } QT_CATCH(...) {

        d->viewportFilter.reset();

        QT_RETHROW;

    }

}

/*!

    Constructs a viewport.

    The \a parent arguments is sent to the QWidget constructor.

*/

QAbstractScrollArea::QAbstractScrollArea(QWidget *parent)

    :QFrame(*new QAbstractScrollAreaPrivate, parent)

{

    Q_D(QAbstractScrollArea);

    QT_TRY {

        d->init();

    } QT_CATCH(...) {

        d->viewportFilter.reset();

        QT_RETHROW;

    }

}

/*!

  Destroys the viewport.

 */

QAbstractScrollArea::~QAbstractScrollArea()

{

    Q_D(QAbstractScrollArea);

    // reset it here, otherwise we'll have a dangling pointer in ~QWidget

    d->viewportFilter.reset();

}

/*!