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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

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

**

** This file is part of the tools applications 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 "qtgradientstopswidget.h"

#include "qtgradientstopsmodel.h"

#include <QtCore/QMap>

#include <QtGui/QImage>

#include <QtGui/QPainter>

#include <QtGui/QScrollBar>

#include <QtGui/QMouseEvent>

#include <QtGui/QRubberBand>

#include <QtGui/QMenu>

QT_BEGIN_NAMESPACE

class QtGradientStopsWidgetPrivate

{

    QtGradientStopsWidget *q_ptr;

    Q_DECLARE_PUBLIC(QtGradientStopsWidget)

public:

    typedef QMap<qreal, QColor> PositionColorMap;

    typedef QMap<QtGradientStop *, qreal> StopPositionMap;

    void slotStopAdded(QtGradientStop *stop);

    void slotStopRemoved(QtGradientStop *stop);

    void slotStopMoved(QtGradientStop *stop, qreal newPos);

    void slotStopsSwapped(QtGradientStop *stop1, QtGradientStop *stop2);

    void slotStopChanged(QtGradientStop *stop, const QColor &newColor);

    void slotStopSelected(QtGradientStop *stop, bool selected);

    void slotCurrentStopChanged(QtGradientStop *stop);

    void slotNewStop();

    void slotDelete();

    void slotFlipAll();

    void slotSelectAll();

    void slotZoomIn();

    void slotZoomOut();

    void slotResetZoom();

    double fromViewport(int x) const;

    double toViewport(double x) const;

    QtGradientStop *stopAt(const QPoint &viewportPos) const;

    QList<QtGradientStop *> stopsAt(const QPoint &viewportPos) const;

    void setupMove(QtGradientStop *stop, int x);

    void ensureVisible(double x); // x = stop position

    void ensureVisible(QtGradientStop *stop);

    QtGradientStop *newStop(const QPoint &viewportPos);

    bool m_backgroundCheckered;

    QtGradientStopsModel *m_model;

    double m_handleSize;

    int m_scaleFactor;

    double m_zoom;

#ifndef QT_NO_DRAGANDDROP

    QtGradientStop *m_dragStop;

    QtGradientStop *m_changedStop;

    QtGradientStop *m_clonedStop;

    QtGradientStopsModel *m_dragModel;

    QColor m_dragColor;

    void clearDrag();

    void removeClonedStop();

    void restoreChangedStop();

    void changeStop(qreal pos);

    void cloneStop(qreal pos);

#endif

    QRubberBand *m_rubber;

    QPoint m_clickPos;

    QList<QtGradientStop *> m_stops;

    bool m_moving;

    int m_moveOffset;

    StopPositionMap m_moveStops;

    PositionColorMap m_moveOriginal;

};

double QtGradientStopsWidgetPrivate::fromViewport(int x) const

{

    QSize size = q_ptr->viewport()->size();

    int w = size.width();

    int max = q_ptr->horizontalScrollBar()->maximum();

    int val = q_ptr->horizontalScrollBar()->value();

    return ((double)x * m_scaleFactor + w * val) / (w * (m_scaleFactor + max));

}

double QtGradientStopsWidgetPrivate::toViewport(double x) const

{

    QSize size = q_ptr->viewport()->size();

    int w = size.width();

    int max = q_ptr->horizontalScrollBar()->maximum();

    int val = q_ptr->horizontalScrollBar()->value();

    return w * (x * (m_scaleFactor + max) - val) / m_scaleFactor;

}

QtGradientStop *QtGradientStopsWidgetPrivate::stopAt(const QPoint &viewportPos) const

{

    double posY = m_handleSize / 2;

    QListIterator<QtGradientStop *> itStop(m_stops);

    while (itStop.hasNext()) {

        QtGradientStop *stop = itStop.next();

        double posX = toViewport(stop->position());

        double x = viewportPos.x() - posX;

        double y = viewportPos.y() - posY;

        if ((m_handleSize * m_handleSize / 4) > (x * x + y * y))

            return stop;

    }

    return 0;

}

QList<QtGradientStop *> QtGradientStopsWidgetPrivate::stopsAt(const QPoint &viewportPos) const

{

    QList<QtGradientStop *> stops;

    double posY = m_handleSize / 2;

    QListIterator<QtGradientStop *> itStop(m_stops);

    while (itStop.hasNext()) {

        QtGradientStop *stop = itStop.next();

        double posX = toViewport(stop->position());

        double x = viewportPos.x() - posX;

        double y = viewportPos.y() - posY;

        if ((m_handleSize * m_handleSize / 4) > (x * x + y * y))

            stops.append(stop);

    }

    return stops;

}

void QtGradientStopsWidgetPrivate::setupMove(QtGradientStop *stop, int x)

{

    m_model->setCurrentStop(stop);

    int viewportX = qRound(toViewport(stop->position()));

    m_moveOffset = x - viewportX;

    QList<QtGradientStop *> stops = m_stops;

    m_stops.clear();

    QListIterator<QtGradientStop *> itStop(stops);

    while (itStop.hasNext()) {

        QtGradientStop *s = itStop.next();

        if (m_model->isSelected(s) || s == stop) {

            m_moveStops[s] = s->position() - stop->position();

            m_stops.append(s);

        } else {

            m_moveOriginal[s->position()] = s->color();

        }

    }

    itStop.toFront();

    while (itStop.hasNext()) {

        QtGradientStop *s = itStop.next();

        if (!m_model->isSelected(s))

            m_stops.append(s);

    }

    m_stops.removeAll(stop);

    m_stops.prepend(stop);

}

void QtGradientStopsWidgetPrivate::ensureVisible(double x)

{

    double viewX = toViewport(x);

    if (viewX < 0 || viewX > q_ptr->viewport()->size().width()) {

        int max = q_ptr->horizontalScrollBar()->maximum();

        int newVal = qRound(x * (max + m_scaleFactor) - m_scaleFactor / 2);

        q_ptr->horizontalScrollBar()->setValue(newVal);

    }

}

void QtGradientStopsWidgetPrivate::ensureVisible(QtGradientStop *stop)

{

    if (!stop)

        return;

    ensureVisible(stop->position());

}

QtGradientStop *QtGradientStopsWidgetPrivate::newStop(const QPoint &viewportPos)

{

    QtGradientStop *copyStop = stopAt(viewportPos);

    double posX = fromViewport(viewportPos.x());

    QtGradientStop *stop = m_model->at(posX);

    if (!stop) {

        QColor newColor;

        if (copyStop)

            newColor = copyStop->color();

        else

            newColor = m_model->color(posX);

        if (!newColor.isValid())

            newColor = Qt::white;

        stop = m_model->addStop(posX, newColor);

    }

    return stop;

}

void QtGradientStopsWidgetPrivate::slotStopAdded(QtGradientStop *stop)

{

    m_stops.append(stop);

    q_ptr->viewport()->update();

}

void QtGradientStopsWidgetPrivate::slotStopRemoved(QtGradientStop *stop)

{

    m_stops.removeAll(stop);

    q_ptr->viewport()->update();

}

void QtGradientStopsWidgetPrivate::slotStopMoved(QtGradientStop *stop, qreal newPos)

{

    Q_UNUSED(stop)

    Q_UNUSED(newPos)

    q_ptr->viewport()->update();

}

void QtGradientStopsWidgetPrivate::slotStopsSwapped(QtGradientStop *stop1, QtGradientStop *stop2)

{

    Q_UNUSED(stop1)

    Q_UNUSED(stop2)

    q_ptr->viewport()->update();

}

void QtGradientStopsWidgetPrivate::slotStopChanged(QtGradientStop *stop, const QColor &newColor)

{

    Q_UNUSED(stop)

    Q_UNUSED(newColor)

    q_ptr->viewport()->update();

}

void QtGradientStopsWidgetPrivate::slotStopSelected(QtGradientStop *stop, bool selected)

{

    Q_UNUSED(stop)

    Q_UNUSED(selected)

    q_ptr->viewport()->update();

}

void QtGradientStopsWidgetPrivate::slotCurrentStopChanged(QtGradientStop *stop)

{

    Q_UNUSED(stop)

    if (!m_model)

        return;

    q_ptr->viewport()->update();

    if (stop) {

        m_stops.removeAll(stop);

        m_stops.prepend(stop);

    }

}

void QtGradientStopsWidgetPrivate::slotNewStop()

{

    if (!m_model)

        return;

    QtGradientStop *stop = newStop(m_clickPos);

    if (!stop)

        return;

    m_model->clearSelection();

    m_model->selectStop(stop, true);

    m_model->setCurrentStop(stop);

}

void QtGradientStopsWidgetPrivate::slotDelete()

{

    if (!m_model)

        return;

    m_model->deleteStops();

}

void QtGradientStopsWidgetPrivate::slotFlipAll()

{

    if (!m_model)

        return;

    m_model->flipAll();

}

void QtGradientStopsWidgetPrivate::slotSelectAll()

{

    if (!m_model)

        return;

    m_model->selectAll();

}

void QtGradientStopsWidgetPrivate::slotZoomIn()

{

    double newZoom = q_ptr->zoom() * 2;

    if (newZoom > 100)

        newZoom = 100;

    if (newZoom == q_ptr->zoom())

        return;

    q_ptr->setZoom(newZoom);

    emit q_ptr->zoomChanged(q_ptr->zoom());

}

void QtGradientStopsWidgetPrivate::slotZoomOut()

{

    double newZoom = q_ptr->zoom() / 2;

    if (newZoom < 1)

        newZoom = 1;

    if (newZoom == q_ptr->zoom())

        return;

    q_ptr->setZoom(newZoom);

    emit q_ptr->zoomChanged(q_ptr->zoom());

}

void QtGradientStopsWidgetPrivate::slotResetZoom()

{

    if (1 == q_ptr->zoom())

        return;

    q_ptr->setZoom(1);

    emit q_ptr->zoomChanged(1);

}

QtGradientStopsWidget::QtGradientStopsWidget(QWidget *parent)

    : QAbstractScrollArea(parent), d_ptr(new QtGradientStopsWidgetPrivate)

{

    d_ptr->q_ptr = this;

    d_ptr->m_backgroundCheckered = true;

    d_ptr->m_model = 0;

    d_ptr->m_handleSize = 25.0;

    d_ptr->m_scaleFactor = 1000;

    d_ptr->m_moving = false;

    d_ptr->m_zoom = 1;

    d_ptr->m_rubber = new QRubberBand(QRubberBand::Rectangle, this);

#ifndef QT_NO_DRAGANDDROP

    d_ptr->m_dragStop = 0;

    d_ptr->m_changedStop = 0;

    d_ptr->m_clonedStop = 0;

    d_ptr->m_dragModel = 0;

#endif

    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

    setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);

    horizontalScrollBar()->setRange(0, (int)(d_ptr->m_scaleFactor * (d_ptr->m_zoom - 1) + 0.5));

    horizontalScrollBar()->setPageStep(d_ptr->m_scaleFactor);

    horizontalScrollBar()->setSingleStep(4);

    viewport()->setAutoFillBackground(false);

    setAcceptDrops(true);

    setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred));

}

QtGradientStopsWidget::~QtGradientStopsWidget()

{

}

QSize QtGradientStopsWidget::sizeHint() const

{

    return QSize(qRound(2 * d_ptr->m_handleSize), qRound(3 * d_ptr->m_handleSize) + horizontalScrollBar()->sizeHint().height());

}

QSize QtGradientStopsWidget::minimumSizeHint() const

{

    return QSize(qRound(2 * d_ptr->m_handleSize), qRound(3 * d_ptr->m_handleSize) + horizontalScrollBar()->minimumSizeHint().height());

}

void QtGradientStopsWidget::setBackgroundCheckered(bool checkered)

{

    if (d_ptr->m_backgroundCheckered == checkered)

        return;

    d_ptr->m_backgroundCheckered = checkered;

    update();

}

bool QtGradientStopsWidget::isBackgroundCheckered() const

{

    return d_ptr->m_backgroundCheckered;

}

void QtGradientStopsWidget::setGradientStopsModel(QtGradientStopsModel *model)

{

    if (d_ptr->m_model == model)

        return;

    if (d_ptr->m_model) {

        disconnect(d_ptr->m_model, SIGNAL(stopAdded(QtGradientStop*)),

                    this, SLOT(slotStopAdded(QtGradientStop*)));

        disconnect(d_ptr->m_model, SIGNAL(stopRemoved(QtGradientStop*)),

                    this, SLOT(slotStopRemoved(QtGradientStop*)));

        disconnect(d_ptr->m_model, SIGNAL(stopMoved(QtGradientStop*,qreal)),

                    this, SLOT(slotStopMoved(QtGradientStop*,qreal)));

        disconnect(d_ptr->m_model, SIGNAL(stopsSwapped(QtGradientStop*,QtGradientStop*)),

                    this, SLOT(slotStopsSwapped(QtGradientStop*,QtGradientStop*)));

        disconnect(d_ptr->m_model, SIGNAL(stopChanged(QtGradientStop*,QColor)),

                    this, SLOT(slotStopChanged(QtGradientStop*,QColor)));

        disconnect(d_ptr->m_model, SIGNAL(stopSelected(QtGradientStop*,bool)),

                    this, SLOT(slotStopSelected(QtGradientStop*,bool)));

        disconnect(d_ptr->m_model, SIGNAL(currentStopChanged(QtGradientStop*)),

                    this, SLOT(slotCurrentStopChanged(QtGradientStop*)));

        d_ptr->m_stops.clear();

    }

    d_ptr->m_model = model;

    if (d_ptr->m_model) {

        connect(d_ptr->m_model, SIGNAL(stopAdded(QtGradientStop*)),

                    this, SLOT(slotStopAdded(QtGradientStop*)));

        connect(d_ptr->m_model, SIGNAL(stopRemoved(QtGradientStop*)),

                    this, SLOT(slotStopRemoved(QtGradientStop*)));

        connect(d_ptr->m_model, SIGNAL(stopMoved(QtGradientStop*,qreal)),

                    this, SLOT(slotStopMoved(QtGradientStop*,qreal)));

        connect(d_ptr->m_model, SIGNAL(stopsSwapped(QtGradientStop*,QtGradientStop*)),

                    this, SLOT(slotStopsSwapped(QtGradientStop*,QtGradientStop*)));

        connect(d_ptr->m_model, SIGNAL(stopChanged(QtGradientStop*,QColor)),

                    this, SLOT(slotStopChanged(QtGradientStop*,QColor)));

        connect(d_ptr->m_model, SIGNAL(stopSelected(QtGradientStop*,bool)),

                    this, SLOT(slotStopSelected(QtGradientStop*,bool)));

        connect(d_ptr->m_model, SIGNAL(currentStopChanged(QtGradientStop*)),

                    this, SLOT(slotCurrentStopChanged(QtGradientStop*)));

        QList<QtGradientStop *> stops = d_ptr->m_model->stops().values();

        QListIterator<QtGradientStop *> itStop(stops);

        while (itStop.hasNext())

            d_ptr->slotStopAdded(itStop.next());

        QList<QtGradientStop *> selected = d_ptr->m_model->selectedStops();

        QListIterator<QtGradientStop *> itSelect(selected);

        while (itSelect.hasNext())

            d_ptr->slotStopSelected(itSelect.next(), true);

        d_ptr->slotCurrentStopChanged(d_ptr->m_model->currentStop());

    }

}

void QtGradientStopsWidget::mousePressEvent(QMouseEvent *e)

{

    typedef QtGradientStopsModel::PositionStopMap PositionStopMap;

    if (!d_ptr->m_model)

        return;

    if (e->button() != Qt::LeftButton)

        return;

    d_ptr->m_moving = true;

    d_ptr->m_moveStops.clear();

    d_ptr->m_moveOriginal.clear();

    d_ptr->m_clickPos = e->pos();

    QtGradientStop *stop = d_ptr->stopAt(e->pos());

    if (stop) {

        if (e->modifiers() & Qt::ControlModifier) {

            d_ptr->m_model->selectStop(stop, !d_ptr->m_model->isSelected(stop));

        } else if (e->modifiers() & Qt::ShiftModifier) {

            QtGradientStop *oldCurrent = d_ptr->m_model->currentStop();

            if (oldCurrent) {

                PositionStopMap stops = d_ptr->m_model->stops();

                PositionStopMap::ConstIterator itSt = stops.constFind(oldCurrent->position());

                if (itSt != stops.constEnd()) {

                    while (itSt != stops.constFind(stop->position())) {

                        d_ptr->m_model->selectStop(itSt.value(), true);

                        if (oldCurrent->position() < stop->position())

                            ++itSt;

                        else

                            --itSt;

                    }

                }

            }

            d_ptr->m_model->selectStop(stop, true);

        } else {

            if (!d_ptr->m_model->isSelected(stop)) {

                d_ptr->m_model->clearSelection();

                d_ptr->m_model->selectStop(stop, true);

            }

        }

        d_ptr->setupMove(stop, e->pos().x());

    } else {

        d_ptr->m_model->clearSelection();

        d_ptr->m_rubber->setGeometry(QRect(d_ptr->m_clickPos, QSize()));

        d_ptr->m_rubber->show();

    }

    viewport()->update();

}

void QtGradientStopsWidget::mouseReleaseEvent(QMouseEvent *e)

{

    if (!d_ptr->m_model)

        return;