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

**

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

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbWidgets module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** 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 developer.feedback@nokia.com.

**

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

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Hb API.  It exists purely as an

// implementation detail.  This file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include "hbselectioncontrol_p.h"

#include "hbstyleoption.h"

#include "hbeffect.h"

#include "hbdialog_p.h"

#include "hbabstractedit.h"

#include "hbabstractedit_p.h"

#include "hbtoucharea.h"

#include <QTextCursor>

#include <QGraphicsItem>

#include <QAbstractTextDocumentLayout>

#include <QGraphicsSceneMouseEvent>

#include <QBasicTimer>

#include <QSizeF>

#include <QPointF>

#include <hbwidgetfeedback.h>

namespace {

    static const int SNAP_DELAY = 300;

}

class HbSelectionControlPrivate :public HbDialogPrivate

{

    Q_DECLARE_PUBLIC(HbSelectionControl)

public:

    HbSelectionControlPrivate(HbAbstractEdit *edit);

    void init();

    void createPrimitives();

    void updateHandle(int newHandlePos,

                      Qt::AlignmentFlag handleAlignment,

                      QGraphicsItem *handle,

                      QGraphicsItem *handleTouchArea,

                      HbStyle::Primitive handlePrimitive);

    QGraphicsItem * reparent(QGraphicsItem *item);

    void reparent(QGraphicsItem *item, QGraphicsItem *newParent);

    void reparentHandles(QGraphicsItem *newParent);

public:

    HbAbstractEdit *mEdit;

    QPointF mMouseOffset;

    QGraphicsItem *mSelectionStartHandle;

    QGraphicsItem *mSelectionEndHandle;

    HbTouchArea* mSelectionStartTouchArea;

    HbTouchArea* mSelectionEndTouchArea;

    HbSelectionControl::HandleType mPressed;

    bool mHandlesDisabled;

    bool mPanInProgress;

    bool mHandlesMoved;

    QBasicTimer mWordSnapTimer;

};

HbSelectionControlPrivate::HbSelectionControlPrivate(HbAbstractEdit *edit):

    mEdit(edit),

    mSelectionStartHandle(0),

    mSelectionEndHandle(0),

    mSelectionStartTouchArea(0),

    mSelectionEndTouchArea(0),

    mPressed(HbSelectionControl::HandleType(0)),

    mHandlesDisabled(true),

    mPanInProgress(false),

    mHandlesMoved(false)

{

}

void HbSelectionControlPrivate::init()

{

    Q_Q(HbSelectionControl);

    createPrimitives();

    q->setBackgroundItem(HbStyle::P_None);

    q->setFocusPolicy(Qt::NoFocus);

    q->setTimeout(HbPopup::NoTimeout);

    q->setBackgroundFaded(false);

    q->setVisible(false);

    q->setDismissPolicy(HbPopup::NoDismiss);

    q->setModal(false);

    #ifdef HB_EFFECTS

    HbEffect::disable(q);

    #endif    

    q->setParent(mEdit);

    // Control will handle all events going to different handlers.

    q->setHandlesChildEvents(true);

    QObject::connect(mEdit, SIGNAL(cursorPositionChanged(int, int)), q, SLOT(updatePrimitives()));

    QObject::connect(mEdit, SIGNAL(selectionChanged(const QTextCursor&, const QTextCursor&)), q, SLOT(updatePrimitives()));

    QObject::connect(mEdit, SIGNAL(contentsChanged()), q, SLOT(updatePrimitives()));

    q->updatePrimitives();

}

void HbSelectionControlPrivate::createPrimitives()

{

    Q_Q(HbSelectionControl);

    if (!mSelectionStartHandle) {

        mSelectionStartHandle = mEdit->style()->createPrimitive(HbStyle::P_SelectionControl_selectionstart, q);

        mSelectionStartHandle->hide();

    }

    if (!mSelectionEndHandle) {

        mSelectionEndHandle = mEdit->style()->createPrimitive(HbStyle::P_SelectionControl_selectionend, q);

        mSelectionEndHandle->hide();

    }

    if (!mSelectionStartTouchArea) {

        mSelectionStartTouchArea = new HbTouchArea(q);

        mSelectionStartTouchArea->hide();

        HbStyle::setItemName(mSelectionStartTouchArea, "handle-toucharea");

    }

    if (!mSelectionEndTouchArea) {

        mSelectionEndTouchArea = new HbTouchArea(q);

        mSelectionEndTouchArea->hide();

        HbStyle::setItemName(mSelectionEndTouchArea, "handle-toucharea");

    }

}

/*

   Updates given handle associated with handleTouchArea to place it

   newHandlePos in the selected text.

   handlePrimitive identifies handle graphics.

*/

void HbSelectionControlPrivate::updateHandle(int newHandlePos,

                  Qt::AlignmentFlag handleAlignment,

                  QGraphicsItem *handle,

                  QGraphicsItem *handleTouchArea,

                  HbStyle::Primitive handlePrimitive)

{    

    Q_Q(HbSelectionControl);

    HbStyleOption option;

    q->initStyleOption(&option);

    mEdit->style()->updatePrimitive(handle, handlePrimitive, &option);

    QRectF rect = mEdit->rectForPosition(newHandlePos,Qt::AlignTop?QTextLine::Leading:QTextLine::Trailing);

    // Convert rect to handle's parent coordinate system

    rect = handle->parentItem()->mapRectFromItem(mEdit,rect);

    // Center handle around center point of rect

    QRectF boundingRect = handle->boundingRect();

    boundingRect.moveCenter(rect.center());

    if (handleAlignment == Qt::AlignTop) {

       boundingRect.moveBottom(rect.top());

    } else {

       boundingRect.moveTop(rect.bottom());

    }

    handle->setPos(boundingRect.topLeft());

    // Center handle touch area around center pos of handle

    QPointF centerPos = boundingRect.center();

    boundingRect = handleTouchArea->boundingRect();

    boundingRect.moveCenter(centerPos);

    handleTouchArea->setPos(boundingRect.topLeft());

    if (!mPanInProgress) {

        QGraphicsItem * newParent = reparent(handle);

        reparent(handleTouchArea, newParent);

    }

    handle->show();

    handleTouchArea->show() ;

}

/*

   Reparents item to q if item's bounding rect intersects mEdit bounding rectangle or otherwise to

   HbAbstractEditPrivate::d_ptr(d->mEdit)->canvas.

   Returns new parent.

*/

QGraphicsItem * HbSelectionControlPrivate::reparent(QGraphicsItem *item)

{

    Q_Q(HbSelectionControl);

    QGraphicsItem *newParent = HbAbstractEditPrivate::d_ptr(mEdit)->canvas;

    // Convert bounding rect to mEdit's coordinate system

    QRectF rect = item->boundingRect();

    rect = item->mapRectToItem(mEdit,rect);

    if (mEdit->contains(rect.topLeft()) || mEdit->contains(rect.bottomRight())) {

        newParent = q;

    }

    reparent(item, newParent);

    return newParent;

}

void HbSelectionControlPrivate::reparent(QGraphicsItem *item, QGraphicsItem *newParent)

{

    if (item && newParent && newParent != item->parentItem()) {

        // Reparent handle items to newParent

        QPointF pos = newParent->mapFromItem(item->parentItem(),item->pos());

        // TODO: This is a workaround for a Qt bug when reparenting from a clipping parent to a

        //       non-clipping parent

        item->setParentItem(0);

        item->setParentItem(newParent);

        item->setPos(pos);

    }

}

void HbSelectionControlPrivate::reparentHandles(QGraphicsItem *newParent)

{

    // Reparent handle items to newParent

    reparent(mSelectionStartHandle, newParent);

    reparent(mSelectionStartTouchArea, newParent);

    reparent(mSelectionEndHandle, newParent);

    reparent(mSelectionEndTouchArea, newParent);

}

HbSelectionControl::HbSelectionControl(HbAbstractEdit *edit) :

    HbPopup(*new HbSelectionControlPrivate(edit),0)

{

    Q_D(HbSelectionControl);

    d->q_ptr = this;

    d->init();

    //TODO: selection control could be singleton per main window

    //      since only one selection control is used at a time

}

void HbSelectionControl::updatePrimitives()

{

    Q_D(HbSelectionControl);

    if (!d->mHandlesDisabled && d->polished) {

        if (d->mEdit->textCursor().hasSelection() ||

            (!d->mEdit->textCursor().hasSelection() && (d->mPressed == SelectionStartHandle || d->mPressed == SelectionEndHandle))) {

            int selStartPos = qMin(d->mEdit->textCursor().anchor(),d->mEdit->textCursor().position());

            int selEndPos = qMax(d->mEdit->textCursor().anchor(),d->mEdit->textCursor().position());

            d->updateHandle(selStartPos,Qt::AlignTop,d->mSelectionStartHandle,d->mSelectionStartTouchArea,HbStyle::P_SelectionControl_selectionstart);

            d->updateHandle(selEndPos,Qt::AlignBottom,d->mSelectionEndHandle,d->mSelectionEndTouchArea,HbStyle::P_SelectionControl_selectionend);

        }

        else {

            d->mSelectionStartHandle->hide();

            d->mSelectionStartTouchArea->hide() ;

            d->mSelectionEndHandle->hide();

            d->mSelectionEndTouchArea->hide() ;

        }

    }

}

void HbSelectionControl::hideHandles()

{

    Q_D(HbSelectionControl);

    if (!d->mHandlesDisabled) {

        d->mHandlesDisabled = true;

        hide();

        d->reparentHandles(this);

    }

}

void HbSelectionControl::showHandles()

{

    Q_D(HbSelectionControl);

    if (d->mHandlesDisabled) {

        d->mHandlesDisabled = false;

        show();

    }

}

void HbSelectionControl::mouseMoveEvent(QGraphicsSceneMouseEvent *event)

{

    Q_D(HbSelectionControl);

    QPointF editPos = d->mEdit->mapFromScene(event->scenePos());

    QRectF handleRect = d->mSelectionStartHandle->boundingRect();

    handleRect.moveTopLeft(editPos + d->mMouseOffset);

    QPointF hitTestPos = handleRect.center();

    if (d->mPressed == SelectionStartHandle) {

        hitTestPos.setY(handleRect.bottom()+1);

    } else {

        hitTestPos.setY(handleRect.top()-1);

    }

    // Hit test for the center of current selection touch area

    int hitPos = HbAbstractEditPrivate::d_ptr(d->mEdit)->hitTest(hitTestPos,Qt::FuzzyHit);

    if (hitPos == -1) {

        return;

    }

    QTextCursor cursor = d->mEdit->textCursor();

    if (hitPos != cursor.position()) {

        d->mHandlesMoved = true;

    }

    cursor.setPosition(hitPos, QTextCursor::KeepAnchor);

    if (d->mHandlesMoved) {

        if (d->mEdit) {

            HbWidgetFeedback::triggered(d->mEdit, Hb::InstantDraggedOver);

        }

        // Restart timer every time when a selection handle moved

        d->mWordSnapTimer.start(SNAP_DELAY, this);

        d->mEdit->setTextCursor(cursor);

    }

    // Ensure that the hitPos is visible

    HbAbstractEditPrivate::d_ptr(d->mEdit)->ensurePositionVisible(hitPos);

    updatePrimitives();

}

void HbSelectionControl::mousePressEvent (QGraphicsSceneMouseEvent *event)

{

    Q_D(HbSelectionControl);

    if (d->mEdit) {

        HbWidgetFeedback::triggered(d->mEdit, Hb::InstantPressed);

    }

    d->mPressed = DummyHandle;

    // Find out which handle is being moved

    if (d->mSelectionStartTouchArea->contains(mapToItem(d->mSelectionStartTouchArea, event->pos()))) {

        d->mPressed = SelectionStartHandle;

        d->mMouseOffset = d->mSelectionStartHandle->pos() - event->pos();

    }

    if (d->mSelectionEndTouchArea->contains(mapToItem(d->mSelectionEndTouchArea, event->pos()))) {

        bool useArea = true;

        if(d->mPressed != DummyHandle) {

            // The press point was inside in both of the touch areas

            // choose the touch area whose center is closer to the press point

            QRectF rect = d->mSelectionStartTouchArea->boundingRect();

            rect.moveTopLeft(d->mSelectionStartTouchArea->pos());

            QLineF  lineEventPosSelStartCenter(event->pos(),rect.center());

            rect = d->mSelectionEndTouchArea->boundingRect();

            rect.moveTopLeft(d->mSelectionEndTouchArea->pos());

            QLineF  lineEventPosSelEndCenter(event->pos(),rect.center());

            if (lineEventPosSelStartCenter.length() < lineEventPosSelEndCenter.length()) {

                useArea = false;

            }

        }

        if (useArea) {

            d->mPressed = SelectionEndHandle;

            d->mMouseOffset = d->mSelectionEndHandle->pos() - event->pos();

        }

    }

    if (d->mPressed == DummyHandle) {

        // Hit is outside touch areas, ignore

        event->ignore();

        return;

    }

    // Position cursor at the pressed selection handle

    QTextCursor cursor = d->mEdit->textCursor();

    int selStartPos = qMin(d->mEdit->textCursor().anchor(),d->mEdit->textCursor().position());

    int selEndPos = qMax(d->mEdit->textCursor().anchor(),d->mEdit->textCursor().position());

    if (d->mPressed == SelectionStartHandle) {

        cursor.setPosition(selEndPos);

        cursor.setPosition(selStartPos, QTextCursor::KeepAnchor);

    } else {

        cursor.setPosition(selStartPos);

        cursor.setPosition(selEndPos, QTextCursor::KeepAnchor);

    }

    d->mEdit->setTextCursor(cursor);

}

void HbSelectionControl::mouseReleaseEvent (QGraphicsSceneMouseEvent *event)

{

    Q_D(HbSelectionControl);

    Q_UNUSED(event);

    if (d->mEdit) {

        HbWidgetFeedback::triggered(d->mEdit, Hb::InstantReleased);

    }

    if (d->mWordSnapTimer.isActive()) {

        // Snap selection to word beginning or end

        QTextCursor cursor = d->mEdit->textCursor();

        int curPos = d->mEdit->textCursor().position();

        int anchPos = d->mEdit->textCursor().anchor();

        cursor.select(QTextCursor::WordUnderCursor);

        // Snap direction depends on cursor position

        curPos = ((curPos > anchPos)?cursor.position():cursor.anchor());

        cursor.setPosition(anchPos);

        cursor.setPosition(curPos, QTextCursor::KeepAnchor);

        d->mEdit->setTextCursor(cursor);

    }

    d->mPressed = DummyHandle;

    updatePrimitives();

    if (!d->mHandlesMoved) {

        if (d->mEdit->contextMenuFlags().testFlag(Hb::ShowTextContextMenuOnSelectionClicked)) {

            d->mEdit->showContextMenu(event->scenePos());

        }

    }

    d->mHandlesMoved = false;

}

void HbSelectionControl::panStarted()

{

    Q_D(HbSelectionControl);

    if (!d->mHandlesDisabled) {

        d->mPanInProgress = true;

        // Reparent handle items to editor canvas on pan start

        d->reparentHandles(HbAbstractEditPrivate::d_ptr(d->mEdit)->canvas);

    }

}

void HbSelectionControl::panFinished()

{

    Q_D(HbSelectionControl);

    if (!d->mHandlesDisabled) {

        d->mPanInProgress = false;

        updatePrimitives();

    }

}

void HbSelectionControl::timerEvent(QTimerEvent *event)

{

    Q_D(HbSelectionControl);

    if (event->timerId() == d->mWordSnapTimer.timerId()) {

        d->mWordSnapTimer.stop();

    }

}

void HbSelectionControl::polish( HbStyleParameters& params )

{

    Q_D(HbSelectionControl);

    HbPopup::polish(params);

    QSizeF size = d->mSelectionStartTouchArea->preferredSize();

    d->mSelectionStartTouchArea->resize(size);

    d->mSelectionEndTouchArea->resize(size);

}

QVariant HbSelectionControl::itemChange(GraphicsItemChange change, const QVariant &value)

{

    if (change == QGraphicsItem::ItemPositionChange) {

        return qVariantFromValue(QPointF(0,0));

    } else if (change == QGraphicsItem::ItemVisibleChange) {        

        updatePrimitives();

    }

    return HbPopup::itemChange(change, value);

}