source: trunk/src/qt3support/text/q3textedit.cpp@ 651

/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation ([email protected])
**
** This file is part of the Qt3Support module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial Usage
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** 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.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you have questions regarding the use of this file, please contact
** Nokia at [email protected].
** $QT_END_LICENSE$
**
****************************************************************************/

#include "q3textedit.h"

#ifndef QT_NO_TEXTEDIT

#include <private/q3richtext_p.h>
#include "qpainter.h"
#include "qpen.h"
#include "qbrush.h"
#include "qpixmap.h"
#include "qfont.h"
#include "qcolor.h"
#include "qstyle.h"
#include "qsize.h"
#include "qevent.h"
#include "qtimer.h"
#include "qapplication.h"
#include "q3listbox.h"
#include "qclipboard.h"
#include "qcolordialog.h"
#include "q3stylesheet.h"
#include "q3dragobject.h"
#include "qurl.h"
#include "qcursor.h"
#include "qregexp.h"
#include "q3popupmenu.h"
#include "qstack.h"
#include "qmetaobject.h"
#include "q3textbrowser.h"
#include "private/q3syntaxhighlighter_p.h"
#include "qtextformat.h"
#ifndef QT_NO_IM
#include <qinputcontext.h>
#endif

#ifndef QT_NO_ACCEL
#include <qkeysequence.h>
#define ACCEL_KEY(k) QLatin1Char('\t') + QString(QKeySequence(Qt::CTRL | Qt::Key_ ## k))
#else
#define ACCEL_KEY(k) QLatin1Char('\t' )+ QString::fromLatin1("Ctrl+" #k)
#endif

#ifdef QT_TEXTEDIT_OPTIMIZATION
#define LOGOFFSET(i) d->logOffset + i
#endif

QT_BEGIN_NAMESPACE

struct QUndoRedoInfoPrivate
{
    Q3TextString text;
};

class Q3TextEditPrivate
{
public:
    Q3TextEditPrivate()
        :preeditStart(-1),preeditLength(-1),numPreeditSelections(0),ensureCursorVisibleInShowEvent(false),
         tabChangesFocus(false),
#ifndef QT_NO_CLIPBOARD
         clipboard_mode(QClipboard::Clipboard),
#endif
#ifdef QT_TEXTEDIT_OPTIMIZATION
         od(0), optimMode(false),
         maxLogLines(-1),
         logOffset(0),
#endif
         autoFormatting((uint)Q3TextEdit::AutoAll),
         cursorRepaintMode(false),
         cursorBlinkActive(false)

    {
        for (int i=0; i<7; i++)
            id[i] = 0;
    }
    int id[7];
    int preeditStart;
    int preeditLength;
    int numPreeditSelections;
    uint ensureCursorVisibleInShowEvent : 1;
    uint tabChangesFocus : 1;
    QString scrollToAnchor; // used to deferr scrollToAnchor() until the show event when we are resized
    QString pressedName;
    QString onName;
#ifndef QT_NO_CLIPBOARD
    QClipboard::Mode clipboard_mode;
#endif
    QTimer *trippleClickTimer;
    QPoint trippleClickPoint;
#ifdef QT_TEXTEDIT_OPTIMIZATION
    Q3TextEditOptimPrivate * od;
    bool optimMode : 1;
    int maxLogLines;
    int logOffset;
#endif
    Q3TextEdit::AutoFormatting autoFormatting;
    uint cursorRepaintMode : 1;
    uint cursorBlinkActive : 1;
};

#ifndef QT_NO_MIME
class Q3RichTextDrag : public Q3TextDrag
{
public:
    Q3RichTextDrag(QWidget *dragSource = 0, const char *name = 0);

    void setPlainText(const QString &txt) { setText(txt); }
    void setRichText(const QString &txt) { richTxt = txt; }

    virtual QByteArray encodedData(const char *mime) const;
    virtual const char* format(int i) const;

    static bool decode(QMimeSource *e, QString &str, const QString &mimetype,
                        const QString &subtype);
    static bool canDecode(QMimeSource* e);

private:
    QString richTxt;

};

Q3RichTextDrag::Q3RichTextDrag(QWidget *dragSource, const char *name)
    : Q3TextDrag(dragSource, name)
{
}

QByteArray Q3RichTextDrag::encodedData(const char *mime) const
{
    if (qstrcmp("application/x-qrichtext", mime) == 0) {
        return richTxt.toUtf8(); // #### perhaps we should use USC2 instead?
    } else
        return Q3TextDrag::encodedData(mime);
}

bool Q3RichTextDrag::decode(QMimeSource *e, QString &str, const QString &mimetype,
                            const QString &subtype)
{
    if (mimetype == QLatin1String("application/x-qrichtext")) {
        // do richtext decode
        const char *mime;
        int i;
        for (i = 0; (mime = e->format(i)); ++i) {
            if (qstrcmp("application/x-qrichtext", mime) != 0)
                continue;
            str = QString::fromUtf8(e->encodedData(mime));
            return true;
        }
        return false;
    }

    // do a regular text decode
    QString st = subtype;
    return Q3TextDrag::decode(e, str, st);
}

bool Q3RichTextDrag::canDecode(QMimeSource* e)
{
    if (e->provides("application/x-qrichtext"))
        return true;
    return Q3TextDrag::canDecode(e);
}

const char* Q3RichTextDrag::format(int i) const
{
    if (Q3TextDrag::format(i))
        return Q3TextDrag::format(i);
    if (Q3TextDrag::format(i-1))
        return "application/x-qrichtext";
    return 0;
}

#endif

static bool block_set_alignment = false;

/*!
    \class Q3TextEdit
    \brief The Q3TextEdit widget provides a powerful single-page rich text editor.

    \compat

    \tableofcontents

    \section1 Introduction and Concepts

    Q3TextEdit is an advanced WYSIWYG viewer/editor supporting rich
    text formatting using HTML-style tags. It is optimized to handle
    large documents and to respond quickly to user input.

    Q3TextEdit has four modes of operation:
    \table
    \header \i Mode \i Command \i Notes
    \row \i Plain Text Editor \i setTextFormat(Qt::PlainText)
         \i Set text with setText(); text() returns plain text. Text
         attributes (e.g. colors) can be set, but plain text is always
         returned.
    \row \i Rich Text Editor \i setTextFormat(Qt::RichText)
         \i Set text with setText(); text() returns rich text. Rich
         text editing is fairly limited. You can't set margins or
         insert images for example (although you can read and
         correctly display files that have margins set and that
         include images). This mode is mostly useful for editing small
         amounts of rich text.
    \row \i Text Viewer \i setReadOnly(true)
         \i Set text with setText() or append() (which has no undo
         history so is faster and uses less memory); text() returns
         plain or rich text depending on the textFormat(). This mode
         can correctly display a large subset of HTML tags.
    \row \i Log Viewer \i setTextFormat(Qt::LogText)
         \i Append text using append(). The widget is set to be read
         only and rich text support is disabled although a few HTML
         tags (for color, bold, italic and underline) may be used.
         (See \link #logtextmode Qt::LogText mode\endlink for details.)
    \endtable

    Q3TextEdit can be used as a syntax highlighting editor when used in
    conjunction with QSyntaxHighlighter.

    We recommend that you always call setTextFormat() to set the mode
    you want to use. If you use Qt::AutoText then setText() and
    append() will try to determine whether the text they are given is
    plain text or rich text. If you use Qt::RichText then setText() and
    append() will assume that the text they are given is rich text.
    insert() simply inserts the text it is given.

    Q3TextEdit works on paragraphs and characters. A paragraph is a
    formatted string which is word-wrapped to fit into the width of
    the widget. By default when reading plain text, one newline
    signify a paragraph. A document consists of zero or more
    paragraphs, indexed from 0. Characters are indexed on a
    per-paragraph basis, also indexed from 0. The words in the
    paragraph are aligned in accordance with the paragraph's
    alignment(). Paragraphs are separated by hard line breaks. Each
    character within a paragraph has its own attributes, for example,
    font and color.

    The text edit documentation uses the following concepts:
    \list
    \i \e{current format} --
    this is the format at the current cursor position, \e and it
    is the format of the selected text if any.
    \i \e{current paragraph} -- the paragraph which contains the
    cursor.
    \endlist

    Q3TextEdit can display images (using Q3MimeSourceFactory), lists and
    tables. If the text is too large to view within the text edit's
    viewport, scroll bars will appear. The text edit can load both
    plain text and HTML files (a subset of HTML 3.2 and 4). The
    rendering style and the set of valid tags are defined by a
    styleSheet(). Custom tags can be created and placed in a custom
    style sheet. Change the style sheet with \l{setStyleSheet()}; see
    Q3StyleSheet for details. The images identified by image tags are
    displayed if they can be interpreted using the text edit's
    \l{Q3MimeSourceFactory}; see setMimeSourceFactory().

    If you want a text browser with more navigation use QTextBrowser.
    If you just need to display a small piece of rich text use QLabel
    or QSimpleRichText.

    If you create a new Q3TextEdit, and want to allow the user to edit
    rich text, call setTextFormat(Qt::RichText) to ensure that the
    text is treated as rich text. (Rich text uses HTML tags to set
    text formatting attributes. See Q3StyleSheet for information on the
    HTML tags that are supported.). If you don't call setTextFormat()
    explicitly the text edit will guess from the text itself whether
    it is rich text or plain text. This means that if the text looks
    like HTML or XML it will probably be interpreted as rich text, so
    you should call setTextFormat(Qt::PlainText) to preserve such
    text.

    Note that we do not intend to add a full-featured web browser
    widget to Qt (because that would easily double Qt's size and only
    a few applications would benefit from it). The rich
    text support in Qt is designed to provide a fast, portable and
    efficient way to add reasonable online help facilities to
    applications, and to provide a basis for rich text editors.

    \section1 Using Q3TextEdit as a Display Widget

    Q3TextEdit can display a large HTML subset, including tables and
    images.

    The text is set or replaced using setText() which deletes any
    existing text and replaces it with the text passed in the
    setText() call. If you call setText() with legacy HTML (with
    setTextFormat(Qt::RichText) in force), and then call text(), the text
    that is returned may have different markup, but will render the
    same. Text can be inserted with insert(), paste(), pasteSubType()
    and append(). Text that is appended does not go into the undo
    history; this makes append() faster and consumes less memory. Text
    can also be cut(). The entire text is deleted with clear() and the
    selected text is deleted with removeSelectedText(). Selected
    (marked) text can also be deleted with del() (which will delete
    the character to the right of the cursor if no text is selected).

    Loading and saving text is achieved using setText() and text(),
    for example:
    \snippet doc/src/snippets/code/src_qt3support_text_q3textedit.cpp 0

    By default the text edit wraps words at whitespace to fit within
    the text edit widget. The setWordWrap() function is used to
    specify the kind of word wrap you want, or \c NoWrap if you don't
    want any wrapping. Call setWordWrap() to set a fixed pixel width
    \c FixedPixelWidth, or character column (e.g. 80 column) \c
    FixedColumnWidth with the pixels or columns specified with
    setWrapColumnOrWidth(). If you use word wrap to the widget's width
    \c WidgetWidth, you can specify whether to break on whitespace or
    anywhere with setWrapPolicy().

    The background color is set differently than other widgets, using
    setPaper(). You specify a brush style which could be a plain color
    or a complex pixmap.

    Hypertext links are automatically underlined; this can be changed
    with setLinkUnderline(). The tab stop width is set with
    setTabStopWidth().

    The zoomIn() and zoomOut() functions can be used to resize the
    text by increasing (decreasing for zoomOut()) the point size used.
    Images are not affected by the zoom functions.

    The lines() function returns the number of lines in the text and
    paragraphs() returns the number of paragraphs. The number of lines
    within a particular paragraph is returned by linesOfParagraph().
    The length of the entire text in characters is returned by
    length().

    You can scroll to an anchor in the text, e.g.
    \c{<a name="anchor">} with scrollToAnchor(). The find() function
    can be used to find and select a given string within the text.

    A read-only Q3TextEdit provides the same functionality as the
    (obsolete) QTextView. (QTextView is still supplied for
    compatibility with old code.)

    \section2 Read-only key bindings

    When Q3TextEdit is used read-only the key-bindings are limited to
    navigation, and text may only be selected with the mouse:
    \table
    \header \i Keypresses \i Action
    \row \i Up        \i Move one line up
    \row \i Down        \i Move one line down
    \row \i Left        \i Move one character left
    \row \i Right        \i Move one character right
    \row \i PageUp        \i Move one (viewport) page up
    \row \i PageDown        \i Move one (viewport) page down
    \row \i Home        \i Move to the beginning of the text
    \row \i End                \i Move to the end of the text
    \row \i Shift+Wheel
         \i Scroll the page horizontally (the Wheel is the mouse wheel)
    \row \i Ctrl+Wheel        \i Zoom the text
    \endtable

    The text edit may be able to provide some meta-information. For
    example, the documentTitle() function will return the text from
    within HTML \c{<title>} tags.

    The text displayed in a text edit has a \e context. The context is
    a path which the text edit's Q3MimeSourceFactory uses to resolve
    the locations of files and images. It is passed to the
    mimeSourceFactory() when quering data. (See Q3TextEdit() and
    \l{context()}.)

    \target logtextmode
    \section2 Using Q3TextEdit in Qt::LogText Mode

    Setting the text format to Qt::LogText puts the widget in a special
    mode which is optimized for very large texts. In this mode editing
    and rich text support are disabled (the widget is explicitly set
    to read-only mode). This allows the text to be stored in a
    different, more memory efficient manner. However, a certain degree
    of text formatting is supported through the use of formatting
    tags. A tag is delimited by \c < and \c {>}. The characters \c
    {<}, \c > and \c & are escaped by using \c {&lt;}, \c {&gt;} and
    \c {&amp;}. A tag pair consists of a left and a right tag (or
    open/close tags). Left-tags mark the starting point for
    formatting, while right-tags mark the ending point. A right-tag
    always start with a \c / before the tag keyword. For example \c
    <b> and \c </b> are a tag pair. Tags can be nested, but they
    have to be closed in the same order as they are opened. For
    example, \c <b><u></u></b> is valid, while \c
    <b><u></b></u> will output an error message.

    By using tags it is possible to change the color, bold, italic and
    underline settings for a piece of text. A color can be specified
    by using the HTML font tag \c {<font color=colorname>}. The color
    name can be one of the color names from the X11 color database, or
    a RGB hex value (e.g \c {#00ff00}). Example of valid color tags:
    \c {<font color=red>}, \c{<font color="light blue">},\c {<font
    color="#223344">}. Bold, italic and underline settings can be
    specified by the tags \c {<b>}, \c <i> and \c {<u>}. Note that a
    tag does not necessarily have to be closed. A valid example:
    \snippet doc/src/snippets/code/src_qt3support_text_q3textedit.cpp 1

    Stylesheets can also be used in Qt::LogText mode. To create and use a
    custom tag, you could do the following:
    \snippet doc/src/snippets/code/src_qt3support_text_q3textedit.cpp 2
    Note that only the color, bold, underline and italic attributes of
    a Q3StyleSheetItem is used in Qt::LogText mode.

    Note that you can use setMaxLogLines() to limit the number of
    lines the widget can hold in Qt::LogText mode.

    There are a few things that you need to be aware of when the
    widget is in this mode:
    \list
    \i Functions that deal with rich text formatting and cursor
    movement will not work or return anything valid.
    \i Lines are equivalent to paragraphs.
    \endlist

    \section1 Using Q3TextEdit as an Editor

    All the information about using Q3TextEdit as a display widget also
    applies here.

    The current format's attributes are set with setItalic(),
    setBold(), setUnderline(), setFamily() (font family),
    setPointSize(), setColor() and setCurrentFont(). The current
    paragraph's alignment is set with setAlignment().

    Use setSelection() to select text. The setSelectionAttributes()
    function is used to indicate how selected text should be
    displayed. Use hasSelectedText() to find out if any text is
    selected. The currently selected text's position is available
    using getSelection() and the selected text itself is returned by
    selectedText(). The selection can be copied to the clipboard with
    copy(), or cut to the clipboard with cut(). It can be deleted with
    removeSelectedText(). The entire text can be selected (or
    unselected) using selectAll(). Q3TextEdit supports multiple
    selections. Most of the selection functions operate on the default
    selection, selection 0. If the user presses a non-selecting key,
    e.g. a cursor key without also holding down Shift, all selections
    are cleared.

    Set and get the position of the cursor with setCursorPosition()
    and getCursorPosition() respectively. When the cursor is moved,
    the signals currentFontChanged(), currentColorChanged() and
    currentAlignmentChanged() are emitted to reflect the font, color
    and alignment at the new cursor position.

    If the text changes, the textChanged() signal is emitted, and if
    the user inserts a new line by pressing Return or Enter,
    returnPressed() is emitted. The isModified() function will return
    true if the text has been modified.

    Q3TextEdit provides command-based undo and redo. To set the depth
    of the command history use setUndoDepth() which defaults to 100
    steps. To undo or redo the last operation call undo() or redo().
    The signals undoAvailable() and redoAvailable() indicate whether
    the undo and redo operations can be executed.

    \section2 Editing key bindings

    The list of key-bindings which are implemented for editing:
    \table
    \header \i Keypresses \i Action
    \row \i Backspace \i Delete the character to the left of the cursor
    \row \i Delete \i Delete the character to the right of the cursor
    \row \i Ctrl+A \i Move the cursor to the beginning of the line
    \row \i Ctrl+B \i Move the cursor one character left
    \row \i Ctrl+C \i Copy the marked text to the clipboard (also
                      Ctrl+Insert under Windows)
    \row \i Ctrl+D \i Delete the character to the right of the cursor
    \row \i Ctrl+E \i Move the cursor to the end of the line
    \row \i Ctrl+F \i Move the cursor one character right
    \row \i Ctrl+H \i Delete the character to the left of the cursor
    \row \i Ctrl+K \i Delete to end of line
    \row \i Ctrl+N \i Move the cursor one line down
    \row \i Ctrl+P \i Move the cursor one line up
    \row \i Ctrl+V \i Paste the clipboard text into line edit
                      (also Shift+Insert under Windows)
    \row \i Ctrl+X \i Cut the marked text, copy to clipboard
                      (also Shift+Delete under Windows)
    \row \i Ctrl+Z \i Undo the last operation
    \row \i Ctrl+Y \i Redo the last operation
    \row \i Left            \i Move the cursor one character left
    \row \i Ctrl+Left  \i Move the cursor one word left
    \row \i Right            \i Move the cursor one character right
    \row \i Ctrl+Right \i Move the cursor one word right
    \row \i Up            \i Move the cursor one line up
    \row \i Ctrl+Qt::Up    \i Move the cursor one word up
    \row \i DownArrow            \i Move the cursor one line down
    \row \i Ctrl+Down \i Move the cursor one word down
    \row \i PageUp            \i Move the cursor one page up
    \row \i PageDown            \i Move the cursor one page down
    \row \i Home            \i Move the cursor to the beginning of the line
    \row \i Ctrl+Home            \i Move the cursor to the beginning of the text
    \row \i End                    \i Move the cursor to the end of the line
    \row \i Ctrl+End            \i Move the cursor to the end of the text
    \row \i Shift+Wheel            \i Scroll the page horizontally
                            (the Wheel is the mouse wheel)
    \row \i Ctrl+Wheel            \i Zoom the text
    \endtable

    To select (mark) text hold down the Shift key whilst pressing one
    of the movement keystrokes, for example, \e{Shift+Right}
    will select the character to the right, and \e{Shift+Ctrl+Right} will select the word to the right, etc.

    By default the text edit widget operates in insert mode so all
    text that the user enters is inserted into the text edit and any
    text to the right of the cursor is moved out of the way. The mode
    can be changed to overwrite, where new text overwrites any text to
    the right of the cursor, using setOverwriteMode().
*/

/*!
    \enum Q3TextEdit::AutoFormattingFlag

    \value AutoNone Do not perform any automatic formatting
    \value AutoBulletList Only automatically format bulletted lists
    \value AutoAll Apply all available autoformatting
*/


/*!
    \enum Q3TextEdit::KeyboardAction

    This enum is used by doKeyboardAction() to specify which action
    should be executed:

    \value ActionBackspace  Delete the character to the left of the
    cursor.

    \value ActionDelete  Delete the character to the right of the
    cursor.

    \value ActionReturn  Split the paragraph at the cursor position.

    \value ActionKill If the cursor is not at the end of the
    paragraph, delete the text from the cursor position until the end
    of the paragraph. If the cursor is at the end of the paragraph,
    delete the hard line break at the end of the paragraph: this will
    cause this paragraph to be joined with the following paragraph.

    \value ActionWordBackspace Delete the word to the left of the
    cursor position.

    \value ActionWordDelete Delete the word to the right of the
    cursor position

*/

/*!
    \enum Q3TextEdit::VerticalAlignment

    This enum is used to set the vertical alignment of the text.

    \value AlignNormal Normal alignment
    \value AlignSuperScript Superscript
    \value AlignSubScript Subscript
*/

/*!
    \enum Q3TextEdit::TextInsertionFlags

    \internal

    \value RedoIndentation
    \value CheckNewLines
    \value RemoveSelected
*/


/*!
    \fn void Q3TextEdit::copyAvailable(bool yes)

    This signal is emitted when text is selected or de-selected in the
    text edit.

    When text is selected this signal will be emitted with \a yes set
    to true. If no text has been selected or if the selected text is
    de-selected this signal is emitted with \a yes set to false.

    If \a yes is true then copy() can be used to copy the selection to
    the clipboard. If \a yes is false then copy() does nothing.

    \sa selectionChanged()
*/


/*!
    \fn void Q3TextEdit::textChanged()

    This signal is emitted whenever the text in the text edit changes.

    \sa setText() append()
*/

/*!
    \fn void Q3TextEdit::selectionChanged()

    This signal is emitted whenever the selection changes.

    \sa setSelection() copyAvailable()
*/

/*!  \fn Q3TextDocument *Q3TextEdit::document() const

    \internal

  This function returns the Q3TextDocument which is used by the text
  edit.
*/

/*!  \fn void Q3TextEdit::setDocument(Q3TextDocument *doc)

    \internal

  This function sets the Q3TextDocument which should be used by the text
  edit to \a doc. This can be used, for example, if you want to
  display a document using multiple views. You would create a
  Q3TextDocument and set it to the text edits which should display it.
  You would need to connect to the textChanged() and
  selectionChanged() signals of all the text edits and update them all
  accordingly (preferably with a slight delay for efficiency reasons).
*/

/*!
    \enum Q3TextEdit::CursorAction

    This enum is used by moveCursor() to specify in which direction
    the cursor should be moved:

    \value MoveBackward  Moves the cursor one character backward

    \value MoveWordBackward Moves the cursor one word backward

    \value MoveForward  Moves the cursor one character forward

    \value MoveWordForward Moves the cursor one word forward

    \value MoveUp  Moves the cursor up one line

    \value MoveDown  Moves the cursor down one line

    \value MoveLineStart  Moves the cursor to the beginning of the line

    \value MoveLineEnd Moves the cursor to the end of the line

    \value MoveHome  Moves the cursor to the beginning of the document

    \value MoveEnd Moves the cursor to the end of the document

    \value MovePgUp  Moves the cursor one viewport page up

    \value MovePgDown  Moves the cursor one viewport page down
*/

/*!
    \property Q3TextEdit::overwriteMode
    \brief the text edit's overwrite mode

    If false (the default) characters entered by the user are inserted
    with any characters to the right being moved out of the way. If
    true, the editor is in overwrite mode, i.e. characters entered by
    the user overwrite any characters to the right of the cursor
    position.
*/

/*!
    \fn void Q3TextEdit::setCurrentFont(const QFont &f)

    Sets the font of the current format to \a f.

    If the widget is in Qt::LogText mode this function will do
    nothing. Use setFont() instead.

    \sa currentFont() setPointSize() setFamily()
*/

/*!
    \property Q3TextEdit::undoDepth
    \brief the depth of the undo history

    The maximum number of steps in the undo/redo history. The default
    is 100.

    \sa undo() redo()
*/

/*!
    \fn void Q3TextEdit::undoAvailable(bool yes)

    This signal is emitted when the availability of undo changes. If
    \a yes is true, then undo() will work until undoAvailable(false)
    is next emitted.

    \sa undo() undoDepth()
*/

/*!
    \fn void Q3TextEdit::modificationChanged(bool m)

    This signal is emitted when the modification status of the
    document has changed. If \a m is true, the document was modified,
    otherwise the modification state has been reset to unmodified.

    \sa modified
*/

/*!
    \fn void Q3TextEdit::redoAvailable(bool yes)

    This signal is emitted when the availability of redo changes. If
    \a yes is true, then redo() will work until redoAvailable(false)
    is next emitted.

    \sa redo() undoDepth()
*/

/*!
    \fn void Q3TextEdit::currentFontChanged(const QFont &f)

    This signal is emitted if the font of the current format has
    changed.

    The new font is \a f.

    \sa setCurrentFont()
*/

/*!
    \fn void Q3TextEdit::currentColorChanged(const QColor &c)

    This signal is emitted if the color of the current format has
    changed.

    The new color is \a c.

    \sa setColor()
*/

/*!
    \fn void Q3TextEdit::currentVerticalAlignmentChanged(Q3TextEdit::VerticalAlignment a)

    This signal is emitted if the vertical alignment of the current
    format has changed.

    The new vertical alignment is \a a.
*/

/*!
    \fn void Q3TextEdit::currentAlignmentChanged(int a)

    This signal is emitted if the alignment of the current paragraph
    has changed.

    The new alignment is \a a.

    \sa setAlignment()
*/

/*!
    \fn void Q3TextEdit::cursorPositionChanged(Q3TextCursor *c)

    \internal
*/

/*!
    \fn void Q3TextEdit::cursorPositionChanged(int para, int pos)

    \overload

    This signal is emitted if the position of the cursor has changed.
    \a para contains the paragraph index and \a pos contains the
    character position within the paragraph.

    \sa setCursorPosition()
*/

/*!
    \fn void Q3TextEdit::clicked(int para, int pos)

    This signal is emitted when the mouse is clicked on the paragraph
    \a para at character position \a pos.

    \sa doubleClicked()
*/

/*! \fn void Q3TextEdit::doubleClicked(int para, int pos)

  This signal is emitted when the mouse is double-clicked on the
  paragraph \a para at character position \a pos.

  \sa clicked()
*/


/*!
    \fn void Q3TextEdit::returnPressed()

    This signal is emitted if the user pressed the Return or the Enter
    key.
*/

/*!
    \fn Q3TextCursor *Q3TextEdit::textCursor() const

    Returns the text edit's text cursor.

    \warning Q3TextCursor is not in the public API, but in special
    circumstances you might wish to use it.
*/

/*!
    Constructs an empty Q3TextEdit called \a name, with parent \a
    parent.
*/

Q3TextEdit::Q3TextEdit(QWidget *parent, const char *name)
    : Q3ScrollView(parent, name, Qt::WStaticContents | Qt::WNoAutoErase),
      doc(new Q3TextDocument(0)), undoRedoInfo(doc)
{
    init();
}

/*!
    Constructs a Q3TextEdit called \a name, with parent \a parent. The
    text edit will display the text \a text using context \a context.

    The \a context is a path which the text edit's Q3MimeSourceFactory
    uses to resolve the locations of files and images. It is passed to
    the mimeSourceFactory() when quering data.

    For example if the text contains an image tag,
    \c{<img src="image.png">}, and the context is "path/to/look/in", the
    Q3MimeSourceFactory will try to load the image from
    "path/to/look/in/image.png". If the tag was
    \c{<img src="/image.png">}, the context will not be used (because
    Q3MimeSourceFactory recognizes that we have used an absolute path)
    and will try to load "/image.png". The context is applied in exactly
    the same way to \e hrefs, for example,
    \c{<a href="target.html">Target</a>}, would resolve to
    "path/to/look/in/target.html".
*/

Q3TextEdit::Q3TextEdit(const QString& text, const QString& context,
                      QWidget *parent, const char *name)
    : Q3ScrollView(parent, name, Qt::WStaticContents | Qt::WNoAutoErase),
      doc(new Q3TextDocument(0)), undoRedoInfo(doc)
{
    init();
    setText(text, context);
}

/*!
    Destructor.
*/

Q3TextEdit::~Q3TextEdit()
{
    delete undoRedoInfo.d;
    undoRedoInfo.d = 0;
    delete cursor;
    delete doc;
#ifdef QT_TEXTEDIT_OPTIMIZATION
    delete d->od;
#endif
    delete d;
}

void Q3TextEdit::init()
{
    d = new Q3TextEditPrivate;
    doc->formatCollection()->setPaintDevice(this);
    undoEnabled = true;
    readonly = true;
    setReadOnly(false);
    setFrameStyle(LineEditPanel | Sunken);
    connect(doc, SIGNAL(minimumWidthChanged(int)),
             this, SLOT(documentWidthChanged(int)));

    mousePressed = false;
    inDoubleClick = false;
    modified = false;
    mightStartDrag = false;
    onLink.clear();
    d->onName.clear();
    overWrite = false;
    wrapMode = WidgetWidth;
    wrapWidth = -1;
    wPolicy = AtWhiteSpace;
    inDnD = false;
    doc->setFormatter(new Q3TextFormatterBreakWords);
    QFont f = Q3ScrollView::font();
    if (f.kerning())
        f.setKerning(false);
    doc->formatCollection()->defaultFormat()->setFont(f);
    doc->formatCollection()->defaultFormat()->setColor(palette().color(QPalette::Text));
    currentFormat = doc->formatCollection()->defaultFormat();
    currentAlignment = Qt::AlignAuto;

    setBackgroundRole(QPalette::Base);
    viewport()->setBackgroundRole(QPalette::Base);

    viewport()->setAcceptDrops(true);
    resizeContents(0, doc->lastParagraph() ?
                    (doc->lastParagraph()->paragId() + 1) * doc->formatCollection()->defaultFormat()->height() : 0);

    setAttribute(Qt::WA_KeyCompression, true);
    viewport()->setMouseTracking(true);
#ifndef QT_NO_CURSOR
    viewport()->setCursor(isReadOnly() ? Qt::ArrowCursor : Qt::IBeamCursor);
#endif
    cursor = new Q3TextCursor(doc);

    formatTimer = new QTimer(this);
    connect(formatTimer, SIGNAL(timeout()),
             this, SLOT(formatMore()));
    lastFormatted = doc->firstParagraph();

    scrollTimer = new QTimer(this);
    connect(scrollTimer, SIGNAL(timeout()),
             this, SLOT(autoScrollTimerDone()));

    interval = 0;
    changeIntervalTimer = new QTimer(this);
    connect(changeIntervalTimer, SIGNAL(timeout()),
             this, SLOT(doChangeInterval()));

    cursorVisible = true;
    blinkTimer = new QTimer(this);
    connect(blinkTimer, SIGNAL(timeout()),
             this, SLOT(blinkCursor()));

#ifndef QT_NO_DRAGANDDROP
    dragStartTimer = new QTimer(this);
    connect(dragStartTimer, SIGNAL(timeout()),
             this, SLOT(startDrag()));
#endif