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

**

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

#include "qtextcontrol_p_p.h"

#ifndef QT_NO_TEXTCONTROL

#include <qfont.h>

#include <qpainter.h>

#include <qevent.h>

#include <qdebug.h>

#include <qmime.h>

#include <qdrag.h>

#include <qclipboard.h>

#include <qmenu.h>

#include <qstyle.h>

#include <qtimer.h>

#include "private/qtextdocumentlayout_p.h"

#include "private/qabstracttextdocumentlayout_p.h"

#include "private/qtextedit_p.h"

#include "qtextdocument.h"

#include "private/qtextdocument_p.h"

#include "qtextlist.h"

#include "private/qtextcontrol_p.h"

#include "qgraphicssceneevent.h"

#include "qprinter.h"

#include "qtextdocumentwriter.h"

#include <qtextformat.h>

#include <qdatetime.h>

#include <qbuffer.h>

#include <qapplication.h>

#include <limits.h>

#include <qtexttable.h>

#include <qvariant.h>

#include <qurl.h>

#include <qdesktopservices.h>

#include <qinputcontext.h>

#include <qtooltip.h>

#include <qstyleoption.h>

#include <QtGui/qlineedit.h>

#ifndef QT_NO_SHORTCUT

#include "private/qapplication_p.h"

#include "private/qshortcutmap_p.h"

#include <qkeysequence.h>

#define ACCEL_KEY(k) (!qApp->d_func()->shortcutMap.hasShortcutForKeySequence(k) ? QLatin1Char('\t') + QString(QKeySequence(k)) : QString())

#else

#define ACCEL_KEY(k) QString()

#endif

QT_BEGIN_NAMESPACE

#ifndef QT_NO_CONTEXTMENU

#if defined(Q_WS_WIN) || defined(Q_WS_X11)

extern bool qt_use_rtl_extensions;

#endif

#endif

// could go into QTextCursor...

static QTextLine currentTextLine(const QTextCursor &cursor)

{

    const QTextBlock block = cursor.block();

    if (!block.isValid())

        return QTextLine();

    const QTextLayout *layout = block.layout();

    if (!layout)

        return QTextLine();

    const int relativePos = cursor.position() - block.position();

    return layout->lineForTextPosition(relativePos);

}

QTextControlPrivate::QTextControlPrivate()

    : doc(0), cursorOn(false), cursorIsFocusIndicator(false),

      interactionFlags(Qt::TextEditorInteraction),

#ifndef QT_NO_DRAGANDDROP

      mousePressed(false), mightStartDrag(false),

#endif

      lastSelectionState(false), ignoreAutomaticScrollbarAdjustement(false),

      overwriteMode(false),

      acceptRichText(true),

      preeditCursor(0), hideCursor(false),

      hasFocus(false),

#ifdef QT_KEYPAD_NAVIGATION

      hasEditFocus(false),

#endif

      isEnabled(true),

      hadSelectionOnMousePress(false),

      ignoreUnusedNavigationEvents(false),

      openExternalLinks(false)

{}

bool QTextControlPrivate::cursorMoveKeyEvent(QKeyEvent *e)

{

#ifdef QT_NO_SHORTCUT

    Q_UNUSED(e);

#endif

    Q_Q(QTextControl);

    if (cursor.isNull())

        return false;

    const QTextCursor oldSelection = cursor;

    const int oldCursorPos = cursor.position();

    QTextCursor::MoveMode mode = QTextCursor::MoveAnchor;

    QTextCursor::MoveOperation op = QTextCursor::NoMove;

    if (false) {

    }

#ifndef QT_NO_SHORTCUT

    if (e == QKeySequence::MoveToNextChar) {

            op = QTextCursor::Right;

    }

    else if (e == QKeySequence::MoveToPreviousChar) {

            op = QTextCursor::Left;

    }

    else if (e == QKeySequence::SelectNextChar) {

           op = QTextCursor::Right;

           mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectPreviousChar) {

            op = QTextCursor::Left;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectNextWord) {

            op = QTextCursor::WordRight;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectPreviousWord) {

            op = QTextCursor::WordLeft;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectStartOfLine) {

            op = QTextCursor::StartOfLine;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectEndOfLine) {

            op = QTextCursor::EndOfLine;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectStartOfBlock) {

            op = QTextCursor::StartOfBlock;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectEndOfBlock) {

            op = QTextCursor::EndOfBlock;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectStartOfDocument) {

            op = QTextCursor::Start;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectEndOfDocument) {

            op = QTextCursor::End;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectPreviousLine) {

            op = QTextCursor::Up;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectNextLine) {

            op = QTextCursor::Down;

            mode = QTextCursor::KeepAnchor;

            {

                QTextBlock block = cursor.block();

                QTextLine line = currentTextLine(cursor);

                if (!block.next().isValid()

                    && line.isValid()

                    && line.lineNumber() == block.layout()->lineCount() - 1)

                    op = QTextCursor::End;

            }

    }

    else if (e == QKeySequence::MoveToNextWord) {

            op = QTextCursor::WordRight;

    }

    else if (e == QKeySequence::MoveToPreviousWord) {

            op = QTextCursor::WordLeft;

    }

    else if (e == QKeySequence::MoveToEndOfBlock) {

            op = QTextCursor::EndOfBlock;

    }

    else if (e == QKeySequence::MoveToStartOfBlock) {

            op = QTextCursor::StartOfBlock;

    }

    else if (e == QKeySequence::MoveToNextLine) {

            op = QTextCursor::Down;

    }

    else if (e == QKeySequence::MoveToPreviousLine) {

            op = QTextCursor::Up;

    }

    else if (e == QKeySequence::MoveToPreviousLine) {

            op = QTextCursor::Up;

    }

    else if (e == QKeySequence::MoveToStartOfLine) {

            op = QTextCursor::StartOfLine;

    }

    else if (e == QKeySequence::MoveToEndOfLine) {

            op = QTextCursor::EndOfLine;

    }

    else if (e == QKeySequence::MoveToStartOfDocument) {

            op = QTextCursor::Start;

    }

    else if (e == QKeySequence::MoveToEndOfDocument) {

            op = QTextCursor::End;

    }

#endif // QT_NO_SHORTCUT

    else {

        return false;

    }

// Except for pageup and pagedown, Mac OS X has very different behavior, we don't do it all, but

// here's the breakdown:

// Shift still works as an anchor, but only one of the other keys can be down Ctrl (Command),

// Alt (Option), or Meta (Control).

// Command/Control + Left/Right -- Move to left or right of the line

//                 + Up/Down -- Move to top bottom of the file. (Control doesn't move the cursor)

// Option + Left/Right -- Move one word Left/right.

//        + Up/Down  -- Begin/End of Paragraph.

// Home/End Top/Bottom of file. (usually don't move the cursor, but will select)

    bool visualNavigation = cursor.visualNavigation();

    cursor.setVisualNavigation(true);

    const bool moved = cursor.movePosition(op, mode);

    cursor.setVisualNavigation(visualNavigation);

    q->ensureCursorVisible();

    bool ignoreNavigationEvents = ignoreUnusedNavigationEvents;

    bool isNavigationEvent = e->key() == Qt::Key_Up || e->key() == Qt::Key_Down;

#ifdef QT_KEYPAD_NAVIGATION

    ignoreNavigationEvents = ignoreNavigationEvents || QApplication::keypadNavigationEnabled();

    isNavigationEvent = isNavigationEvent ||

                        (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional

                         && (e->key() == Qt::Key_Left || e->key() == Qt::Key_Right));

#else

    isNavigationEvent = isNavigationEvent || e->key() == Qt::Key_Left || e->key() == Qt::Key_Right;

#endif

    if (moved) {

        if (cursor.position() != oldCursorPos)

            emit q->cursorPositionChanged();

        emit q->microFocusChanged();

    } else if (ignoreNavigationEvents && isNavigationEvent) {

        return false;

    }

    selectionChanged(/*forceEmitSelectionChanged =*/(mode == QTextCursor::KeepAnchor));

    repaintOldAndNewSelection(oldSelection);

    return true;

}

void QTextControlPrivate::updateCurrentCharFormat()

{

    Q_Q(QTextControl);

    QTextCharFormat fmt = cursor.charFormat();

    if (fmt == lastCharFormat)

        return;

    lastCharFormat = fmt;

    emit q->currentCharFormatChanged(fmt);

    emit q->microFocusChanged();

}

void QTextControlPrivate::indent()

{

    QTextBlockFormat blockFmt = cursor.blockFormat();

    QTextList *list = cursor.currentList();

    if (!list) {

        QTextBlockFormat modifier;

        modifier.setIndent(blockFmt.indent() + 1);

        cursor.mergeBlockFormat(modifier);

    } else {

        QTextListFormat format = list->format();

        format.setIndent(format.indent() + 1);

        if (list->itemNumber(cursor.block()) == 1)

            list->setFormat(format);

        else

            cursor.createList(format);

    }

}

void QTextControlPrivate::outdent()

{

    QTextBlockFormat blockFmt = cursor.blockFormat();

    QTextList *list = cursor.currentList();

    if (!list) {

        QTextBlockFormat modifier;

        modifier.setIndent(blockFmt.indent() - 1);

        cursor.mergeBlockFormat(modifier);

    } else {

        QTextListFormat listFmt = list->format();

        listFmt.setIndent(listFmt.indent() - 1);

        list->setFormat(listFmt);

    }

}

void QTextControlPrivate::gotoNextTableCell()

{

    QTextTable *table = cursor.currentTable();

    QTextTableCell cell = table->cellAt(cursor);

    int newColumn = cell.column() + cell.columnSpan();

    int newRow = cell.row();

    if (newColumn >= table->columns()) {

        newColumn = 0;

        ++newRow;

        if (newRow >= table->rows())

            table->insertRows(table->rows(), 1);

    }

    cell = table->cellAt(newRow, newColumn);

    cursor = cell.firstCursorPosition();

}

void QTextControlPrivate::gotoPreviousTableCell()

{

    QTextTable *table = cursor.currentTable();

    QTextTableCell cell = table->cellAt(cursor);

    int newColumn = cell.column() - 1;

    int newRow = cell.row();

    if (newColumn < 0) {

        newColumn = table->columns() - 1;

        --newRow;

        if (newRow < 0)

            return;

    }

    cell = table->cellAt(newRow, newColumn);

    cursor = cell.firstCursorPosition();

}

void QTextControlPrivate::createAutoBulletList()

{

    cursor.beginEditBlock();

    QTextBlockFormat blockFmt = cursor.blockFormat();

    QTextListFormat listFmt;

    listFmt.setStyle(QTextListFormat::ListDisc);

    listFmt.setIndent(blockFmt.indent() + 1);

    blockFmt.setIndent(0);

    cursor.setBlockFormat(blockFmt);

    cursor.createList(listFmt);

    cursor.endEditBlock();

}

void QTextControlPrivate::init(Qt::TextFormat format, const QString &text, QTextDocument *document)

{

    Q_Q(QTextControl);

    setContent(format, text, document);

    QWidget *parentWidget = qobject_cast<QWidget*>(parent);

    if (parentWidget) {

        QTextOption opt = doc->defaultTextOption();

        opt.setTextDirection(parentWidget->layoutDirection());

        doc->setDefaultTextOption(opt);

    }

    doc->setUndoRedoEnabled(interactionFlags & Qt::TextEditable);

    q->setCursorWidth(-1);

}

void QTextControlPrivate::setContent(Qt::TextFormat format, const QString &text, QTextDocument *document)

{

    Q_Q(QTextControl);

    // for use when called from setPlainText. we may want to re-use the currently

    // set char format then.

    const QTextCharFormat charFormatForInsertion = cursor.charFormat();

    bool clearDocument = true;

    if (!doc) {

        if (document) {

            doc = document;

            clearDocument = false;

        } else {

            palette = QApplication::palette("QTextControl");

            doc = new QTextDocument(q);

        }

        _q_documentLayoutChanged();

        cursor = QTextCursor(doc);

// ####        doc->documentLayout()->setPaintDevice(viewport);

        QObject::connect(doc, SIGNAL(contentsChanged()), q, SLOT(_q_updateCurrentCharFormatAndSelection()));

        QObject::connect(doc, SIGNAL(cursorPositionChanged(QTextCursor)), q, SLOT(_q_emitCursorPosChanged(QTextCursor)));

        QObject::connect(doc, SIGNAL(documentLayoutChanged()), q, SLOT(_q_documentLayoutChanged()));

        // convenience signal forwards

        QObject::connect(doc, SIGNAL(undoAvailable(bool)), q, SIGNAL(undoAvailable(bool)));

        QObject::connect(doc, SIGNAL(redoAvailable(bool)), q, SIGNAL(redoAvailable(bool)));

        QObject::connect(doc, SIGNAL(modificationChanged(bool)), q, SIGNAL(modificationChanged(bool)));

        QObject::connect(doc, SIGNAL(blockCountChanged(int)), q, SIGNAL(blockCountChanged(int)));

    }

    bool previousUndoRedoState = doc->isUndoRedoEnabled();

    if (!document)

        doc->setUndoRedoEnabled(false);

    //Saving the index save some time.

    static int contentsChangedIndex = QTextDocument::staticMetaObject.indexOfSignal("contentsChanged()");

    static int textChangedIndex = QTextControl::staticMetaObject.indexOfSignal("textChanged()");

    // avoid multiple textChanged() signals being emitted

    QMetaObject::disconnect(doc, contentsChangedIndex, q, textChangedIndex);

    if (!text.isEmpty()) {

        // clear 'our' cursor for insertion to prevent

        // the emission of the cursorPositionChanged() signal.

        // instead we emit it only once at the end instead of

        // at the end of the document after loading and when

        // positioning the cursor again to the start of the

        // document.

        cursor = QTextCursor();

        if (format == Qt::PlainText) {

            QTextCursor formatCursor(doc);

            // put the setPlainText and the setCharFormat into one edit block,

            // so that the syntax highlight triggers only /once/ for the entire

            // document, not twice.

            formatCursor.beginEditBlock();

            doc->setPlainText(text);

            doc->setUndoRedoEnabled(false);

            formatCursor.select(QTextCursor::Document);

            formatCursor.setCharFormat(charFormatForInsertion);

            formatCursor.endEditBlock();

        } else {

#ifndef QT_NO_TEXTHTMLPARSER

            doc->setHtml(text);

#else

            doc->setPlainText(text);

#endif

            doc->setUndoRedoEnabled(false);

        }

        cursor = QTextCursor(doc);

    } else if (clearDocument) {

        doc->clear();

    }

    cursor.setCharFormat(charFormatForInsertion);

    QMetaObject::connect(doc, contentsChangedIndex, q, textChangedIndex);

    emit q->textChanged();

    if (!document)

        doc->setUndoRedoEnabled(previousUndoRedoState);

    _q_updateCurrentCharFormatAndSelection();

    if (!document)

        doc->setModified(false);

    q->ensureCursorVisible();

    emit q->cursorPositionChanged();

}

void QTextControlPrivate::startDrag()

{

#ifndef QT_NO_DRAGANDDROP

    Q_Q(QTextControl);

    mousePressed = false;

    if (!contextWidget)

        return;

    QMimeData *data = q->createMimeDataFromSelection();

    QDrag *drag = new QDrag(contextWidget);

    drag->setMimeData(data);

    Qt::DropActions actions = Qt::CopyAction;

    Qt::DropAction action;

    if (interactionFlags & Qt::TextEditable) {

        actions |= Qt::MoveAction;

        action = drag->exec(actions, Qt::MoveAction);

    } else {

        action = drag->exec(actions, Qt::CopyAction);

    }

    if (action == Qt::MoveAction && drag->target() != contextWidget)