1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qtextedit_p.h"

    43 #include "qlineedit.h"

    44 #include "qtextbrowser.h"

    45 

    46 #ifndef QT_NO_TEXTEDIT

    47 #include <qfont.h>

    48 #include <qpainter.h>

    49 #include <qevent.h>

    50 #include <qdebug.h>

    51 #include <qmime.h>

    52 #include <qdrag.h>

    53 #include <qclipboard.h>

    54 #include <qmenu.h>

    55 #include <qstyle.h>

    56 #include <qtimer.h>

    57 #include "private/qtextdocumentlayout_p.h"

    58 #include "qtextdocument.h"

    59 #include "private/qtextdocument_p.h"

    60 #include "qtextlist.h"

    61 #include "private/qtextcontrol_p.h"

    62 

    63 #include <qtextformat.h>

    64 #include <qdatetime.h>

    65 #include <qapplication.h>

    66 #include <limits.h>

    67 #include <qtexttable.h>

    68 #include <qvariant.h>

    69 

    70 #include <qinputcontext.h>

    71 #endif

    72 

    73 QT_BEGIN_NAMESPACE

    74 

    75 

    76 #ifndef QT_NO_TEXTEDIT

    77 static inline bool shouldEnableInputMethod(QTextEdit *textedit)

    78 {

    79     return !textedit->isReadOnly();

    80 }

    81 

    82 class QTextEditControl : public QTextControl

    83 {

    84 public:

    85     inline QTextEditControl(QObject *parent) : QTextControl(parent) {}

    86 

    87     virtual QMimeData *createMimeDataFromSelection() const {

    88         QTextEdit *ed = qobject_cast<QTextEdit *>(parent());

    89         if (!ed)

    90             return QTextControl::createMimeDataFromSelection();

    91         return ed->createMimeDataFromSelection();

    92     }

    93     virtual bool canInsertFromMimeData(const QMimeData *source) const {

    94         QTextEdit *ed = qobject_cast<QTextEdit *>(parent());

    95         if (!ed)

    96             return QTextControl::canInsertFromMimeData(source);

    97         return ed->canInsertFromMimeData(source);

    98     }

    99     virtual void insertFromMimeData(const QMimeData *source) {

   100         QTextEdit *ed = qobject_cast<QTextEdit *>(parent());

   101         if (!ed)

   102             QTextControl::insertFromMimeData(source);

   103         else

   104             ed->insertFromMimeData(source);

   105     }

   106 };

   107 

   108 QTextEditPrivate::QTextEditPrivate()

   109     : control(0),

   110       autoFormatting(QTextEdit::AutoNone), tabChangesFocus(false),

   111       lineWrap(QTextEdit::WidgetWidth), lineWrapColumnOrWidth(0),

   112       wordWrap(QTextOption::WrapAtWordBoundaryOrAnywhere), clickCausedFocus(0),

   113       textFormat(Qt::AutoText)

   114 {

   115     ignoreAutomaticScrollbarAdjustment = false;

   116     preferRichText = false;

   117     showCursorOnInitialShow = true;

   118     inDrag = false;

   119 }

   120 

   121 void QTextEditPrivate::createAutoBulletList()

   122 {

   123     QTextCursor cursor = control->textCursor();

   124     cursor.beginEditBlock();

   125 

   126     QTextBlockFormat blockFmt = cursor.blockFormat();

   127 

   128     QTextListFormat listFmt;

   129     listFmt.setStyle(QTextListFormat::ListDisc);

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

   131 

   132     blockFmt.setIndent(0);

   133     cursor.setBlockFormat(blockFmt);

   134 

   135     cursor.createList(listFmt);

   136 

   137     cursor.endEditBlock();

   138     control->setTextCursor(cursor);

   139 }

   140 

   141 void QTextEditPrivate::init(const QString &html)

   142 {

   143     Q_Q(QTextEdit);

   144     control = new QTextEditControl(q);

   145     control->setPalette(q->palette());

   146 

   147     QObject::connect(control, SIGNAL(microFocusChanged()), q, SLOT(updateMicroFocus()));

   148     QObject::connect(control, SIGNAL(documentSizeChanged(QSizeF)), q, SLOT(_q_adjustScrollbars()));

   149     QObject::connect(control, SIGNAL(updateRequest(QRectF)), q, SLOT(_q_repaintContents(QRectF)));

   150     QObject::connect(control, SIGNAL(visibilityRequest(QRectF)), q, SLOT(_q_ensureVisible(QRectF)));

   151     QObject::connect(control, SIGNAL(currentCharFormatChanged(QTextCharFormat)),

   152                      q, SLOT(_q_currentCharFormatChanged(QTextCharFormat)));

   153 

   154     QObject::connect(control, SIGNAL(textChanged()), q, SIGNAL(textChanged()));

   155     QObject::connect(control, SIGNAL(undoAvailable(bool)), q, SIGNAL(undoAvailable(bool)));

   156     QObject::connect(control, SIGNAL(redoAvailable(bool)), q, SIGNAL(redoAvailable(bool)));

   157     QObject::connect(control, SIGNAL(copyAvailable(bool)), q, SIGNAL(copyAvailable(bool)));

   158     QObject::connect(control, SIGNAL(selectionChanged()), q, SIGNAL(selectionChanged()));

   159     QObject::connect(control, SIGNAL(cursorPositionChanged()), q, SIGNAL(cursorPositionChanged()));

   160 

   161     QObject::connect(control, SIGNAL(textChanged()), q, SLOT(updateMicroFocus()));

   162 

   163     QTextDocument *doc = control->document();

   164     // set a null page size initially to avoid any relayouting until the textedit

   165     // is shown. relayoutDocument() will take care of setting the page size to the

   166     // viewport dimensions later.

   167     doc->setPageSize(QSize(0, 0));

   168     doc->documentLayout()->setPaintDevice(viewport);

   169     doc->setDefaultFont(q->font());

   170     doc->setUndoRedoEnabled(false); // flush undo buffer.

   171     doc->setUndoRedoEnabled(true);

   172 

   173     if (!html.isEmpty())

   174         control->setHtml(html);

   175 

   176     hbar->setSingleStep(20);

   177     vbar->setSingleStep(20);

   178 

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

   180     q->setAcceptDrops(true);

   181     q->setFocusPolicy(Qt::WheelFocus);

   182     q->setAttribute(Qt::WA_KeyCompression);

   183     q->setAttribute(Qt::WA_InputMethodEnabled);

   184 

   185 #ifndef QT_NO_CURSOR

   186     viewport->setCursor(Qt::IBeamCursor);

   187 #endif

   188 #ifdef Q_WS_WIN

   189     setSingleFingerPanEnabled(true);

   190 #endif

   191 }

   192 

   193 void QTextEditPrivate::_q_repaintContents(const QRectF &contentsRect)

   194 {

   195     if (!contentsRect.isValid()) {

   196         viewport->update();

   197         return;

   198     }

   199     const int xOffset = horizontalOffset();

   200     const int yOffset = verticalOffset();

   201     const QRectF visibleRect(xOffset, yOffset, viewport->width(), viewport->height());

   202 

   203     QRect r = contentsRect.intersected(visibleRect).toAlignedRect();

   204     if (r.isEmpty())

   205         return;

   206 

   207     r.translate(-xOffset, -yOffset);

   208     viewport->update(r);

   209 }

   210 

   211 void QTextEditPrivate::pageUpDown(QTextCursor::MoveOperation op, QTextCursor::MoveMode moveMode)

   212 {

   213     QTextCursor cursor = control->textCursor();

   214     bool moved = false;

   215     qreal lastY = control->cursorRect(cursor).top();

   216     qreal distance = 0;

   217     // move using movePosition to keep the cursor's x

   218     do {

   219         qreal y = control->cursorRect(cursor).top();

   220         distance += qAbs(y - lastY);

   221         lastY = y;

   222         moved = cursor.movePosition(op, moveMode);

   223     } while (moved && distance < viewport->height());

   224 

   225     if (moved) {

   226         if (op == QTextCursor::Up) {

   227             cursor.movePosition(QTextCursor::Down, moveMode);

   228             vbar->triggerAction(QAbstractSlider::SliderPageStepSub);

   229         } else {

   230             cursor.movePosition(QTextCursor::Up, moveMode);

   231             vbar->triggerAction(QAbstractSlider::SliderPageStepAdd);

   232         }

   233     }

   234     control->setTextCursor(cursor);

   235 }

   236 

   237 #ifndef QT_NO_SCROLLBAR

   238 static QSize documentSize(QTextControl *control)

   239 {

   240     QTextDocument *doc = control->document();

   241     QAbstractTextDocumentLayout *layout = doc->documentLayout();

   242 

   243     QSize docSize;

   244 

   245     if (QTextDocumentLayout *tlayout = qobject_cast<QTextDocumentLayout *>(layout)) {

   246         docSize = tlayout->dynamicDocumentSize().toSize();

   247         int percentageDone = tlayout->layoutStatus();

   248         // extrapolate height

   249         if (percentageDone > 0)

   250             docSize.setHeight(docSize.height() * 100 / percentageDone);

   251     } else {

   252         docSize = layout->documentSize().toSize();

   253     }

   254 

   255     return docSize;

   256 }

   257 

   258 void QTextEditPrivate::_q_adjustScrollbars()

   259 {

   260     if (ignoreAutomaticScrollbarAdjustment)

   261         return;

   262     ignoreAutomaticScrollbarAdjustment = true; // avoid recursion, #106108

   263 

   264     QSize viewportSize = viewport->size();

   265     QSize docSize = documentSize(control);

   266 

   267     // due to the recursion guard we have to repeat this step a few times,

   268     // as adding/removing a scroll bar will cause the document or viewport

   269     // size to change

   270     // ideally we should loop until the viewport size and doc size stabilize,

   271     // but in corner cases they might fluctuate, so we need to limit the

   272     // number of iterations

   273     for (int i = 0; i < 4; ++i) {

   274         hbar->setRange(0, docSize.width() - viewportSize.width());

   275         hbar->setPageStep(viewportSize.width());

   276 

   277         vbar->setRange(0, docSize.height() - viewportSize.height());

   278         vbar->setPageStep(viewportSize.height());

   279 

   280         // if we are in left-to-right mode widening the document due to

   281         // lazy layouting does not require a repaint. If in right-to-left

   282         // the scroll bar has the value zero and it visually has the maximum

   283         // value (it is visually at the right), then widening the document

   284         // keeps it at value zero but visually adjusts it to the new maximum

   285         // on the right, hence we need an update.

   286         if (q_func()->isRightToLeft())

   287             viewport->update();

   288 

   289         _q_showOrHideScrollBars();

   290 

   291         const QSize oldViewportSize = viewportSize;

   292         const QSize oldDocSize = docSize;

   293 

   294         // make sure the document is layouted if the viewport width changes

   295         viewportSize = viewport->size();

   296         if (viewportSize.width() != oldViewportSize.width())

   297             relayoutDocument();

   298 

   299         docSize = documentSize(control);

   300         if (viewportSize == oldViewportSize && docSize == oldDocSize)

   301             break;

   302     }

   303     ignoreAutomaticScrollbarAdjustment = false;

   304 }

   305 #endif

   306 

   307 // rect is in content coordinates

   308 void QTextEditPrivate::_q_ensureVisible(const QRectF &_rect)

   309 {

   310     const QRect rect = _rect.toRect();

   311     if ((vbar->isVisible() && vbar->maximum() < rect.bottom())

   312         || (hbar->isVisible() && hbar->maximum() < rect.right()))

   313         _q_adjustScrollbars();

   314     const int visibleWidth = viewport->width();

   315     const int visibleHeight = viewport->height();

   316     const bool rtl = q_func()->isRightToLeft();

   317 

   318     if (rect.x() < horizontalOffset()) {

   319         if (rtl)

   320             hbar->setValue(hbar->maximum() - rect.x());

   321         else

   322             hbar->setValue(rect.x());

   323     } else if (rect.x() + rect.width() > horizontalOffset() + visibleWidth) {

   324         if (rtl)

   325             hbar->setValue(hbar->maximum() - (rect.x() + rect.width() - visibleWidth));

   326         else

   327             hbar->setValue(rect.x() + rect.width() - visibleWidth);

   328     }

   329 

   330     if (rect.y() < verticalOffset())

   331         vbar->setValue(rect.y());

   332     else if (rect.y() + rect.height() > verticalOffset() + visibleHeight)

   333         vbar->setValue(rect.y() + rect.height() - visibleHeight);

   334 }

   335 

   336 /*!

   337     \class QTextEdit

   338     \brief The QTextEdit class provides a widget that is used to edit and display

   339     both plain and rich text.

   340 

   341     \ingroup richtext-processing

   342 

   343 

   344     \tableofcontents

   345 

   346     \section1 Introduction and Concepts

   347 

   348     QTextEdit is an advanced WYSIWYG viewer/editor supporting rich

   349     text formatting using HTML-style tags. It is optimized to handle

   350     large documents and to respond quickly to user input.

   351 

   352     QTextEdit works on paragraphs and characters. A paragraph is a

   353     formatted string which is word-wrapped to fit into the width of

   354     the widget. By default when reading plain text, one newline

   355     signifies a paragraph. A document consists of zero or more

   356     paragraphs. The words in the paragraph are aligned in accordance

   357     with the paragraph's alignment. Paragraphs are separated by hard

   358     line breaks. Each character within a paragraph has its own

   359     attributes, for example, font and color.

   360 

   361     QTextEdit can display images, lists and tables. If the text is

   362     too large to view within the text edit's viewport, scroll bars will

   363     appear. The text edit can load both plain text and HTML files (a

   364     subset of HTML 3.2 and 4).

   365 

   366     If you just need to display a small piece of rich text use QLabel.

   367 

   368     The rich text support in Qt is designed to provide a fast, portable and

   369     efficient way to add reasonable online help facilities to

   370     applications, and to provide a basis for rich text editors. If

   371     you find the HTML support insufficient for your needs you may consider

   372     the use of QtWebKit, which provides a full-featured web browser

   373     widget.

   374 

   375     The shape of the mouse cursor on a QTextEdit is Qt::IBeamCursor by default.

   376     It can be changed through the viewport()'s cursor property.

   377 

   378     \section1 Using QTextEdit as a Display Widget

   379 

   380     QTextEdit can display a large HTML subset, including tables and

   381     images.

   382 

   383     The text is set or replaced using setHtml() which deletes any

   384     existing text and replaces it with the text passed in the

   385     setHtml() call. If you call setHtml() with legacy HTML, and then

   386     call toHtml(), the text that is returned may have different markup,

   387     but will render the same. The entire text can be deleted with clear().

   388 

   389     Text itself can be inserted using the QTextCursor class or using the

   390     convenience functions insertHtml(), insertPlainText(), append() or

   391     paste(). QTextCursor is also able to insert complex objects like tables

   392     or lists into the document, and it deals with creating selections

   393     and applying changes to selected text.

   394 

   395     By default the text edit wraps words at whitespace to fit within

   396     the text edit widget. The setLineWrapMode() function is used to

   397     specify the kind of line wrap you want, or \l NoWrap if you don't

   398     want any wrapping. Call setLineWrapMode() to set a fixed pixel width

   399     \l FixedPixelWidth, or character column (e.g. 80 column) \l

   400     FixedColumnWidth with the pixels or columns specified with

   401     setLineWrapColumnOrWidth(). If you use word wrap to the widget's width

   402     \l WidgetWidth, you can specify whether to break on whitespace or

   403     anywhere with setWordWrapMode().

   404 

   405     The find() function can be used to find and select a given string

   406     within the text.

   407 

   408     If you want to limit the total number of paragraphs in a QTextEdit,

   409     as it is for example open useful in a log viewer, then you can use

   410     QTextDocument's maximumBlockCount property for that.

   411 

   412     \section2 Read-only Key Bindings

   413 

   414     When QTextEdit is used read-only the key bindings are limited to

   415     navigation, and text may only be selected with the mouse:

   416     \table

   417     \header \i Keypresses \i Action

   418     \row \i Up        \i Moves one line up.

   419     \row \i Down        \i Moves one line down.

   420     \row \i Left        \i Moves one character to the left.

   421     \row \i Right        \i Moves one character to the right.

   422     \row \i PageUp        \i Moves one (viewport) page up.

   423     \row \i PageDown        \i Moves one (viewport) page down.

   424     \row \i Home        \i Moves to the beginning of the text.

   425     \row \i End                \i Moves to the end of the text.

   426     \row \i Alt+Wheel

   427          \i Scrolls the page horizontally (the Wheel is the mouse wheel).

   428     \row \i Ctrl+Wheel        \i Zooms the text.

   429     \row \i Ctrl+A            \i Selects all text.

   430     \endtable

   431 

   432     The text edit may be able to provide some meta-information. For

   433     example, the documentTitle() function will return the text from

   434     within HTML \c{<title>} tags.

   435 

   436     \section1 Using QTextEdit as an Editor

   437 

   438     All the information about using QTextEdit as a display widget also

   439     applies here.

   440 

   441     The current char format's attributes are set with setFontItalic(),

   442     setFontWeight(), setFontUnderline(), setFontFamily(),

   443     setFontPointSize(), setTextColor() and setCurrentFont(). The current

   444     paragraph's alignment is set with setAlignment().

   445 

   446     Selection of text is handled by the QTextCursor class, which provides

   447     functionality for creating selections, retrieving the text contents or

   448     deleting selections. You can retrieve the object that corresponds with

   449     the user-visible cursor using the textCursor() method. If you want to set

   450     a selection in QTextEdit just create one on a QTextCursor object and

   451     then make that cursor the visible cursor using setTextCursor(). The selection

   452     can be copied to the clipboard with copy(), or cut to the clipboard with

   453     cut(). The entire text can be selected using selectAll().

   454 

   455     When the cursor is moved and the underlying formatting attributes change,

   456     the currentCharFormatChanged() signal is emitted to reflect the new attributes

   457     at the new cursor position.

   458 

   459     QTextEdit holds a QTextDocument object which can be retrieved using the

   460     document() method. You can also set your own document object using setDocument().

   461     QTextDocument emits a textChanged() signal if the text changes and it also

   462     provides a isModified() function which will return true if the text has been

   463     modified since it was either loaded or since the last call to setModified

   464     with false as argument. In addition it provides methods for undo and redo.

   465 

   466     \section2 Drag and Drop

   467 

   468     QTextEdit also supports custom drag and drop behavior. By default,

   469     QTextEdit will insert plain text, HTML and rich text when the user drops

   470     data of these MIME types onto a document. Reimplement

   471     canInsertFromMimeData() and insertFromMimeData() to add support for

   472     additional MIME types.

   473 

   474     For example, to allow the user to drag and drop an image onto a QTextEdit,

   475     you could the implement these functions in the following way:

   476 

   477     \snippet doc/src/snippets/textdocument-imagedrop/textedit.cpp 0

   478 

   479     We add support for image MIME types by returning true. For all other

   480     MIME types, we use the default implementation.

   481 

   482     \snippet doc/src/snippets/textdocument-imagedrop/textedit.cpp 1

   483 

   484     We unpack the image from the QVariant held by the MIME source and insert

   485     it into the document as a resource.

   486 

   487     \section2 Editing Key Bindings

   488 

   489     The list of key bindings which are implemented for editing:

   490     \table

   491     \header \i Keypresses \i Action

   492     \row \i Backspace \i Deletes the character to the left of the cursor.

   493     \row \i Delete \i Deletes the character to the right of the cursor.

   494     \row \i Ctrl+C \i Copy the selected text to the clipboard.

   495     \row \i Ctrl+Insert \i Copy the selected text to the clipboard.

   496     \row \i Ctrl+K \i Deletes to the end of the line.

   497     \row \i Ctrl+V \i Pastes the clipboard text into text edit.

   498     \row \i Shift+Insert \i Pastes the clipboard text into text edit.

   499     \row \i Ctrl+X \i Deletes the selected text and copies it to the clipboard.

   500     \row \i Shift+Delete \i Deletes the selected text and copies it to the clipboard.

   501     \row \i Ctrl+Z \i Undoes the last operation.

   502     \row \i Ctrl+Y \i Redoes the last operation.

   503     \row \i Left \i Moves the cursor one character to the left.

   504     \row \i Ctrl+Left \i Moves the cursor one word to the left.

   505     \row \i Right \i Moves the cursor one character to the right.

   506     \row \i Ctrl+Right \i Moves the cursor one word to the right.

   507     \row \i Up \i Moves the cursor one line up.

   508     \row \i Down \i Moves the cursor one line down.

   509     \row \i PageUp \i Moves the cursor one page up.

   510     \row \i PageDown \i Moves the cursor one page down.

   511     \row \i Home \i Moves the cursor to the beginning of the line.

   512     \row \i Ctrl+Home \i Moves the cursor to the beginning of the text.

   513     \row \i End \i Moves the cursor to the end of the line.

   514     \row \i Ctrl+End \i Moves the cursor to the end of the text.

   515     \row \i Alt+Wheel \i Scrolls the page horizontally (the Wheel is the mouse wheel).

   516     \endtable

   517 

   518     To select (mark) text hold down the Shift key whilst pressing one

   519     of the movement keystrokes, for example, \e{Shift+Right}

   520     will select the character to the right, and \e{Shift+Ctrl+Right} will select the word to the right, etc.

   521 

   522     \sa QTextDocument, QTextCursor, {Application Example},

   523         {Syntax Highlighter Example}, {Rich Text Processing}

   524 */

   525 

   526 /*!

   527     \property QTextEdit::plainText

   528     \since 4.3

   529 

   530     This property gets and sets the text editor's contents as plain

   531     text. Previous contents are removed and undo/redo history is reset

   532     when the property is set.

   533 

   534     If the text edit has another content type, it will not be replaced

   535     by plain text if you call toPlainText(). The only exception to this

   536     is the non-break space, \e{nbsp;}, that will be converted into

   537     standard space.

   538 

   539     By default, for an editor with no contents, this property contains

   540     an empty string.

   541 

   542     \sa html

   543 */

   544 

   545 /*!

   546     \property QTextEdit::undoRedoEnabled

   547     \brief whether undo and redo are enabled

   548 

   549     Users are only able to undo or redo actions if this property is

   550     true, and if there is an action that can be undone (or redone).

   551 */

   552 

   553 /*!

   554     \enum QTextEdit::LineWrapMode

   555 

   556     \value NoWrap

   557     \value WidgetWidth

   558     \value FixedPixelWidth

   559     \value FixedColumnWidth

   560 */

   561 

   562 /*!

   563     \enum QTextEdit::AutoFormattingFlag

   564 

   565     \value AutoNone Don't do any automatic formatting.

   566     \value AutoBulletList Automatically create bullet lists (e.g. when

   567     the user enters an asterisk ('*') in the left most column, or

   568     presses Enter in an existing list item.

   569     \value AutoAll Apply all automatic formatting. Currently only

   570     automatic bullet lists are supported.

   571 */

   572 

   573 #ifdef QT3_SUPPORT

   574 /*!

   575     \enum QTextEdit::CursorAction

   576     \compat

   577 

   578     \value MoveBackward

   579     \value MoveForward

   580     \value MoveWordBackward

   581     \value MoveWordForward

   582     \value MoveUp

   583     \value MoveDown

   584     \value MoveLineStart

   585     \value MoveLineEnd

   586     \value MoveHome

   587     \value MoveEnd

   588     \value MovePageUp

   589     \value MovePageDown

   590 

   591     \omitvalue MovePgUp

   592     \omitvalue MovePgDown

   593 */

   594 #endif

   595 

   596 /*!

   597     Constructs an empty QTextEdit with parent \a

   598     parent.

   599 */

   600 QTextEdit::QTextEdit(QWidget *parent)

   601     : QAbstractScrollArea(*new QTextEditPrivate, parent)

   602 {

   603     Q_D(QTextEdit);

   604     d->init();

   605 }

   606 

   607 /*!

   608     \internal

   609 */

   610 QTextEdit::QTextEdit(QTextEditPrivate &dd, QWidget *parent)

   611     : QAbstractScrollArea(dd, parent)

   612 {

   613     Q_D(QTextEdit);

   614     d->init();

   615 }

   616 

   617 /*!

   618     Constructs a QTextEdit with parent \a parent. The text edit will display

   619     the text \a text. The text is interpreted as html.

   620 */

   621 QTextEdit::QTextEdit(const QString &text, QWidget *parent)

   622     : QAbstractScrollArea(*new QTextEditPrivate, parent)

   623 {

   624     Q_D(QTextEdit);

   625     d->init(text);

   626 }

   627 

   628 #ifdef QT3_SUPPORT

   629 /*!

   630     Use one of the constructors that doesn't take the \a name

   631     argument and then use setObjectName() instead.

   632 */

   633 QTextEdit::QTextEdit(QWidget *parent, const char *name)

   634     : QAbstractScrollArea(*new QTextEditPrivate, parent)

   635 {

   636     Q_D(QTextEdit);

   637     d->init();

   638     setObjectName(QString::fromAscii(name));

   639 }

   640 #endif

   641 

   642 

   643 /*!

   644     Destructor.

   645 */

   646 QTextEdit::~QTextEdit()

   647 {

   648 }

   649 

   650 /*!

   651     Returns the point size of the font of the current format.

   652 

   653     \sa setFontFamily() setCurrentFont() setFontPointSize()

   654 */

   655 qreal QTextEdit::fontPointSize() const

   656 {

   657     Q_D(const QTextEdit);

   658     return d->control->textCursor().charFormat().fontPointSize();

   659 }

   660 

   661 /*!

   662     Returns the font family of the current format.

   663 

   664     \sa setFontFamily() setCurrentFont() setFontPointSize()

   665 */

   666 QString QTextEdit::fontFamily() const

   667 {

   668     Q_D(const QTextEdit);

   669     return d->control->textCursor().charFormat().fontFamily();

   670 }

   671 

   672 /*!

   673     Returns the font weight of the current format.

   674 

   675     \sa setFontWeight() setCurrentFont() setFontPointSize() QFont::Weight

   676 */

   677 int QTextEdit::fontWeight() const

   678 {

   679     Q_D(const QTextEdit);

   680     return d->control->textCursor().charFormat().fontWeight();

   681 }

   682 

   683 /*!

   684     Returns true if the font of the current format is underlined; otherwise returns

   685     false.

   686 

   687     \sa setFontUnderline()

   688 */

   689 bool QTextEdit::fontUnderline() const

   690 {

   691     Q_D(const QTextEdit);

   692     return d->control->textCursor().charFormat().fontUnderline();

   693 }

   694 

   695 /*!

   696     Returns true if the font of the current format is italic; otherwise returns

   697     false.

   698 

   699     \sa setFontItalic()

   700 */

   701 bool QTextEdit::fontItalic() const

   702 {

   703     Q_D(const QTextEdit);

   704     return d->control->textCursor().charFormat().fontItalic();

   705 }

   706 

   707 /*!

   708     Returns the text color of the current format.

   709 

   710     \sa setTextColor()

   711 */

   712 QColor QTextEdit::textColor() const

   713 {

   714     Q_D(const QTextEdit);

   715     return d->control->textCursor().charFormat().foreground().color();

   716 }

   717 

   718 /*!

   719     \since 4.4

   720 

   721     Returns the text background color of the current format.

   722 

   723     \sa setTextBackgroundColor()

   724 */

   725 QColor QTextEdit::textBackgroundColor() const

   726 {

   727     Q_D(const QTextEdit);

   728     return d->control->textCursor().charFormat().background().color();

   729 }

   730 

   731 /*!

   732     Returns the font of the current format.

   733 

   734     \sa setCurrentFont() setFontFamily() setFontPointSize()

   735 */

   736 QFont QTextEdit::currentFont() const

   737 {

   738     Q_D(const QTextEdit);

   739     return d->control->textCursor().charFormat().font();

   740 }

   741 

   742 /*!

   743     Sets the alignment of the current paragraph to \a a. Valid

   744     alignments are Qt::AlignLeft, Qt::AlignRight,

   745     Qt::AlignJustify and Qt::AlignCenter (which centers

   746     horizontally).

   747 */

   748 void QTextEdit::setAlignment(Qt::Alignment a)

   749 {

   750     Q_D(QTextEdit);

   751     QTextBlockFormat fmt;

   752     fmt.setAlignment(a);

   753     QTextCursor cursor = d->control->textCursor();

   754     cursor.mergeBlockFormat(fmt);

   755     d->control->setTextCursor(cursor);

   756 }

   757 

   758 /*!

   759     Returns the alignment of the current paragraph.

   760 

   761     \sa setAlignment()

   762 */

   763 Qt::Alignment QTextEdit::alignment() const

   764 {

   765     Q_D(const QTextEdit);

   766     return d->control->textCursor().blockFormat().alignment();

   767 }

   768 

   769 /*!

   770     Makes \a document the new document of the text editor.

   771 

   772     \note The editor \e{does not take ownership of the document} unless it

   773     is the document's parent object. The parent object of the provided document

   774     remains the owner of the object.

   775 

   776     If the current document is a child of the text editor, then it is deleted.

   777 

   778     \sa document()

   779 */

   780 void QTextEdit::setDocument(QTextDocument *document)

   781 {

   782     Q_D(QTextEdit);

   783     d->control->setDocument(document);

   784     d->updateDefaultTextOption();

   785     d->relayoutDocument();

   786 }

   787 

   788 /*!

   789     Returns a pointer to the underlying document.

   790 

   791     \sa setDocument()

   792 */

   793 QTextDocument *QTextEdit::document() const

   794 {

   795     Q_D(const QTextEdit);

   796     return d->control->document();

   797 }

   798 

   799 /*!

   800     Sets the visible \a cursor.

   801 */

   802 void QTextEdit::setTextCursor(const QTextCursor &cursor)

   803 {

   804     Q_D(QTextEdit);

   805     d->control->setTextCursor(cursor);

   806 }

   807 

   808 /*!

   809     Returns a copy of the QTextCursor that represents the currently visible cursor.

   810     Note that changes on the returned cursor do not affect QTextEdit's cursor; use

   811     setTextCursor() to update the visible cursor.

   812  */

   813 QTextCursor QTextEdit::textCursor() const

   814 {

   815     Q_D(const QTextEdit);

   816     return d->control->textCursor();

   817 }

   818 

   819 /*!

   820     Sets the font family of the current format to \a fontFamily.

   821 

   822     \sa fontFamily() setCurrentFont()

   823 */

   824 void QTextEdit::setFontFamily(const QString &fontFamily)

   825 {

   826     QTextCharFormat fmt;

   827     fmt.setFontFamily(fontFamily);

   828     mergeCurrentCharFormat(fmt);

   829 }

   830 

   831 /*!

   832     Sets the point size of the current format to \a s.

   833 

   834     Note that if \a s is zero or negative, the behavior of this

   835     function is not defined.

   836 

   837     \sa fontPointSize() setCurrentFont() setFontFamily()

   838 */

   839 void QTextEdit::setFontPointSize(qreal s)

   840 {

   841     QTextCharFormat fmt;

   842     fmt.setFontPointSize(s);

   843     mergeCurrentCharFormat(fmt);

   844 }

   845 

   846 /*!

   847     \fn void QTextEdit::setFontWeight(int weight)

   848 

   849     Sets the font weight of the current format to the given \a weight,

   850     where the value used is in the range defined by the QFont::Weight

   851     enum.

   852 

   853     \sa fontWeight(), setCurrentFont(), setFontFamily()

   854 */

   855 void QTextEdit::setFontWeight(int w)

   856 {

   857     QTextCharFormat fmt;

   858     fmt.setFontWeight(w);

   859     mergeCurrentCharFormat(fmt);

   860 }

   861 

   862 /*!

   863     If \a underline is true, sets the current format to underline;

   864     otherwise sets the current format to non-underline.

   865 

   866     \sa fontUnderline()

   867 */

   868 void QTextEdit::setFontUnderline(bool underline)

   869 {

   870     QTextCharFormat fmt;

   871     fmt.setFontUnderline(underline);

   872     mergeCurrentCharFormat(fmt);

   873 }

   874 

   875 /*!

   876     If \a italic is true, sets the current format to italic;

   877     otherwise sets the current format to non-italic.

   878 

   879     \sa fontItalic()

   880 */

   881 void QTextEdit::setFontItalic(bool italic)

   882 {

   883     QTextCharFormat fmt;

   884     fmt.setFontItalic(italic);

   885     mergeCurrentCharFormat(fmt);

   886 }

   887 

   888 /*!

   889     Sets the text color of the current format to \a c.

   890 

   891     \sa textColor()

   892 */

   893 void QTextEdit::setTextColor(const QColor &c)

   894 {

   895     QTextCharFormat fmt;

   896     fmt.setForeground(QBrush(c));

   897     mergeCurrentCharFormat(fmt);

   898 }

   899 

   900 /*!

   901     \since 4.4

   902 

   903     Sets the text background color of the current format to \a c.

   904 

   905     \sa textBackgroundColor()

   906 */

   907 void QTextEdit::setTextBackgroundColor(const QColor &c)

   908 {

   909     QTextCharFormat fmt;

   910     fmt.setBackground(QBrush(c));

   911     mergeCurrentCharFormat(fmt);

   912 }

   913 

   914 /*!

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

   916 

   917     \sa currentFont() setFontPointSize() setFontFamily()

   918 */

   919 void QTextEdit::setCurrentFont(const QFont &f)

   920 {

   921     QTextCharFormat fmt;

   922     fmt.setFont(f);

   923     mergeCurrentCharFormat(fmt);

   924 }

   925 

   926 /*!

   927     \since 4.2

   928 

   929     Undoes the last operation.

   930 

   931     If there is no operation to undo, i.e. there is no undo step in

   932     the undo/redo history, nothing happens.

   933 

   934     \sa redo()

   935 */

   936 void QTextEdit::undo()

   937 {

   938     Q_D(QTextEdit);

   939     d->control->undo();

   940 }

   941 

   942 void QTextEdit::redo()

   943 {

   944     Q_D(QTextEdit);

   945     d->control->redo();

   946 }

   947 

   948 /*!

   949     \fn void QTextEdit::undo() const

   950     \fn void QTextEdit::redo() const

   951     \overload

   952 

   953     Use the non-const overload instead.

   954 */

   955 

   956 /*!

   957     \fn void QTextEdit::redo()

   958     \since 4.2

   959 

   960     Redoes the last operation.

   961 

   962     If there is no operation to redo, i.e. there is no redo step in

   963     the undo/redo history, nothing happens.

   964 

   965     \sa undo()

   966 */

   967 

   968 #ifndef QT_NO_CLIPBOARD

   969 /*!

   970     Copies the selected text to the clipboard and deletes it from

   971     the text edit.

   972 

   973     If there is no selected text nothing happens.

   974 

   975     \sa copy() paste()

   976 */

   977 

   978 void QTextEdit::cut()

   979 {

   980     Q_D(QTextEdit);

   981     d->control->cut();

   982 }

   983 

   984 /*!

   985     Copies any selected text to the clipboard.

   986 

   987     \sa copyAvailable()

   988 */

   989 

   990 void QTextEdit::copy()

   991 {

   992     Q_D(QTextEdit);

   993     d->control->copy();

   994 }

   995 

   996 /*!

   997     Pastes the text from the clipboard into the text edit at the

   998     current cursor position.

   999 

  1000     If there is no text in the clipboard nothing happens.

  1001 

  1002     To change the behavior of this function, i.e. to modify what

  1003     QTextEdit can paste and how it is being pasted, reimplement the

  1004     virtual canInsertFromMimeData() and insertFromMimeData()

  1005     functions.

  1006 

  1007     \sa cut() copy()

  1008 */

  1009 

  1010 void QTextEdit::paste()

  1011 {

  1012     Q_D(QTextEdit);

  1013     d->control->paste();

  1014 }

  1015 #endif

  1016 

  1017 /*!

  1018     Deletes all the text in the text edit.

  1019 

  1020     Note that the undo/redo history is cleared by this function.

  1021 

  1022     \sa cut() setPlainText() setHtml()

  1023 */

  1024 void QTextEdit::clear()

  1025 {

  1026     Q_D(QTextEdit);

  1027     // clears and sets empty content

  1028     d->control->clear();

  1029 }

  1030 

  1031 

  1032 /*!

  1033     Selects all text.

  1034 

  1035     \sa copy() cut() textCursor()

  1036  */

  1037 void QTextEdit::selectAll()

  1038 {

  1039     Q_D(QTextEdit);

  1040     d->control->selectAll();

  1041 }

  1042 

  1043 /*! \internal

  1044 */

  1045 bool QTextEdit::event(QEvent *e)

  1046 {

  1047     Q_D(QTextEdit);

  1048 #ifndef QT_NO_CONTEXTMENU

  1049     if (e->type() == QEvent::ContextMenu

  1050         && static_cast<QContextMenuEvent *>(e)->reason() == QContextMenuEvent::Keyboard) {

  1051         Q_D(QTextEdit);

  1052         ensureCursorVisible();

  1053         const QPoint cursorPos = cursorRect().center();

  1054         QContextMenuEvent ce(QContextMenuEvent::Keyboard, cursorPos, d->viewport->mapToGlobal(cursorPos));

  1055         ce.setAccepted(e->isAccepted());

  1056         const bool result = QAbstractScrollArea::event(&ce);

  1057         e->setAccepted(ce.isAccepted());

  1058         return result;

  1059     } else if (e->type() == QEvent::ShortcutOverride

  1060                || e->type() == QEvent::ToolTip) {

  1061         d->sendControlEvent(e);

  1062     }

  1063 #endif // QT_NO_CONTEXTMENU

  1064 #ifdef QT_KEYPAD_NAVIGATION

  1065     if (e->type() == QEvent::EnterEditFocus || e->type() == QEvent::LeaveEditFocus) {

  1066         if (QApplication::keypadNavigationEnabled())

  1067             d->sendControlEvent(e);

  1068     }

  1069 #endif

  1070     return QAbstractScrollArea::event(e);

  1071 }

  1072 

  1073 /*! \internal

  1074 */

  1075 

  1076 void QTextEdit::timerEvent(QTimerEvent *e)

  1077 {

  1078     Q_D(QTextEdit);

  1079     if (e->timerId() == d->autoScrollTimer.timerId()) {

  1080         QRect visible = d->viewport->rect();

  1081         QPoint pos;

  1082         if (d->inDrag) {

  1083             pos = d->autoScrollDragPos;

  1084             visible.adjust(qMin(visible.width()/3,20), qMin(visible.height()/3,20),

  1085                            -qMin(visible.width()/3,20), -qMin(visible.height()/3,20));

  1086         } else {

  1087             const QPoint globalPos = QCursor::pos();

  1088             pos = d->viewport->mapFromGlobal(globalPos);

  1089             QMouseEvent ev(QEvent::MouseMove, pos, globalPos, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);

  1090             mouseMoveEvent(&ev);

  1091         }

  1092         int deltaY = qMax(pos.y() - visible.top(), visible.bottom() - pos.y()) - visible.height();

  1093         int deltaX = qMax(pos.x() - visible.left(), visible.right() - pos.x()) - visible.width();

  1094         int delta = qMax(deltaX, deltaY);

  1095         if (delta >= 0) {

  1096             if (delta < 7)

  1097                 delta = 7;

  1098             int timeout = 4900 / (delta * delta);

  1099             d->autoScrollTimer.start(timeout, this);

  1100 

  1101             if (deltaY > 0)

  1102                 d->vbar->triggerAction(pos.y() < visible.center().y() ?

  1103                                        QAbstractSlider::SliderSingleStepSub

  1104                                        : QAbstractSlider::SliderSingleStepAdd);

  1105             if (deltaX > 0)

  1106                 d->hbar->triggerAction(pos.x() < visible.center().x() ?

  1107                                        QAbstractSlider::SliderSingleStepSub

  1108                                        : QAbstractSlider::SliderSingleStepAdd);

  1109         }

  1110     }

  1111 #ifdef QT_KEYPAD_NAVIGATION

  1112     else if (e->timerId() == d->deleteAllTimer.timerId()) {

  1113         d->deleteAllTimer.stop();

  1114         clear();

  1115     }

  1116 #endif

  1117 }

  1118 

  1119 /*!

  1120     Changes the text of the text edit to the string \a text.

  1121     Any previous text is removed.

  1122 

  1123     \a text is interpreted as plain text.

  1124 

  1125     Note that the undo/redo history is cleared by this function.

  1126 

  1127     \sa toPlainText()

  1128 */

  1129 

  1130 void QTextEdit::setPlainText(const QString &text)

  1131 {

  1132     Q_D(QTextEdit);

  1133     d->control->setPlainText(text);

  1134     d->preferRichText = false;

  1135 }