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 "qlineedit.h"

    43 #include "qlineedit_p.h"

    44 

    45 #ifndef QT_NO_LINEEDIT

    46 #include "qaction.h"

    47 #include "qapplication.h"

    48 #include "qclipboard.h"

    49 #include "qdrag.h"

    50 #include "qdrawutil.h"

    51 #include "qevent.h"

    52 #include "qfontmetrics.h"

    53 #include "qmenu.h"

    54 #include "qpainter.h"

    55 #include "qpixmap.h"

    56 #include "qpointer.h"

    57 #include "qstringlist.h"

    58 #include "qstyle.h"

    59 #include "qstyleoption.h"

    60 #include "qtimer.h"

    61 #include "qvalidator.h"

    62 #include "qvariant.h"

    63 #include "qvector.h"

    64 #include "qwhatsthis.h"

    65 #include "qdebug.h"

    66 #include "qtextedit.h"

    67 #include <private/qtextedit_p.h>

    68 #ifndef QT_NO_ACCESSIBILITY

    69 #include "qaccessible.h"

    70 #endif

    71 #ifndef QT_NO_IM

    72 #include "qinputcontext.h"

    73 #include "qlist.h"

    74 #endif

    75 #include "qabstractitemview.h"

    76 #include "private/qstylesheetstyle_p.h"

    77 

    78 #ifndef QT_NO_SHORTCUT

    79 #include "private/qapplication_p.h"

    80 #include "private/qshortcutmap_p.h"

    81 #include "qkeysequence.h"

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

    83 #else

    84 #define ACCEL_KEY(k) QString()

    85 #endif

    86 

    87 #include <limits.h>

    88 

    89 QT_BEGIN_NAMESPACE

    90 

    91 #ifdef Q_WS_MAC

    92 extern void qt_mac_secure_keyboard(bool); //qapplication_mac.cpp

    93 #endif

    94 

    95 /*!

    96     Initialize \a option with the values from this QLineEdit. This method

    97     is useful for subclasses when they need a QStyleOptionFrame or QStyleOptionFrameV2, but don't want

    98     to fill in all the information themselves. This function will check the version

    99     of the QStyleOptionFrame and fill in the additional values for a

   100     QStyleOptionFrameV2.

   101 

   102     \sa QStyleOption::initFrom()

   103 */

   104 void QLineEdit::initStyleOption(QStyleOptionFrame *option) const

   105 {

   106     if (!option)

   107         return;

   108 

   109     Q_D(const QLineEdit);

   110     option->initFrom(this);

   111     option->rect = contentsRect();

   112     option->lineWidth = d->frame ? style()->pixelMetric(QStyle::PM_DefaultFrameWidth, option, this)

   113                                  : 0;

   114     option->midLineWidth = 0;

   115     option->state |= QStyle::State_Sunken;

   116     if (d->control->isReadOnly())

   117         option->state |= QStyle::State_ReadOnly;

   118 #ifdef QT_KEYPAD_NAVIGATION

   119     if (hasEditFocus())

   120         option->state |= QStyle::State_HasEditFocus;

   121 #endif

   122     if (QStyleOptionFrameV2 *optionV2 = qstyleoption_cast<QStyleOptionFrameV2 *>(option))

   123         optionV2->features = QStyleOptionFrameV2::None;

   124 }

   125 

   126 /*!

   127     \class QLineEdit

   128     \brief The QLineEdit widget is a one-line text editor.

   129 

   130     \ingroup basicwidgets

   131 

   132 

   133     A line edit allows the user to enter and edit a single line of

   134     plain text with a useful collection of editing functions,

   135     including undo and redo, cut and paste, and drag and drop.

   136 

   137     By changing the echoMode() of a line edit, it can also be used as

   138     a "write-only" field, for inputs such as passwords.

   139 

   140     The length of the text can be constrained to maxLength(). The text

   141     can be arbitrarily constrained using a validator() or an

   142     inputMask(), or both.

   143 

   144     A related class is QTextEdit which allows multi-line, rich text

   145     editing.

   146 

   147     You can change the text with setText() or insert(). The text is

   148     retrieved with text(); the displayed text (which may be different,

   149     see \l{EchoMode}) is retrieved with displayText(). Text can be

   150     selected with setSelection() or selectAll(), and the selection can

   151     be cut(), copy()ied and paste()d. The text can be aligned with

   152     setAlignment().

   153 

   154     When the text changes the textChanged() signal is emitted; when

   155     the text changes other than by calling setText() the textEdited()

   156     signal is emitted; when the cursor is moved the

   157     cursorPositionChanged() signal is emitted; and when the Return or

   158     Enter key is pressed the returnPressed() signal is emitted.

   159 

   160     When editing is finished, either because the line edit lost focus

   161     or Return/Enter is pressed the editingFinished() signal is

   162     emitted.

   163 

   164     Note that if there is a validator set on the line edit, the

   165     returnPressed()/editingFinished() signals will only be emitted if

   166     the validator returns QValidator::Acceptable.

   167 

   168     By default, QLineEdits have a frame as specified by the Windows

   169     and Motif style guides; you can turn it off by calling

   170     setFrame(false).

   171 

   172     The default key bindings are described below. The line edit also

   173     provides a context menu (usually invoked by a right mouse click)

   174     that presents some of these editing options.

   175     \target desc

   176     \table

   177     \header \i Keypress \i Action

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

   179     \row \i Shift+Left Arrow \i Moves and selects text one character to the left.

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

   181     \row \i Shift+Right Arrow \i Moves and selects text one character to the right.

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

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

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

   185     \row \i Ctrl+Backspace \i Deletes the word to the left of the cursor.

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

   187     \row \i Ctrl+Delete \i Deletes the word to the right of the cursor.

   188     \row \i Ctrl+A \i Select all.

   189     \row \i Ctrl+C \i Copies the selected text to the clipboard.

   190     \row \i Ctrl+Insert \i Copies the selected text to the clipboard.

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

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

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

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

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

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

   197     \row \i Ctrl+Y \i Redoes the last undone operation.

   198     \endtable

   199 

   200     Any other key sequence that represents a valid character, will

   201     cause the character to be inserted into the line edit.

   202 

   203     \table 100%

   204     \row \o \inlineimage macintosh-lineedit.png Screenshot of a Macintosh style line edit

   205          \o A line edit shown in the \l{Macintosh Style Widget Gallery}{Macintosh widget style}.

   206     \row \o \inlineimage windows-lineedit.png Screenshot of a Windows XP style line edit

   207          \o A line edit shown in the \l{Windows XP Style Widget Gallery}{Windows XP widget style}.

   208     \row \o \inlineimage plastique-lineedit.png Screenshot of a Plastique style line edit

   209          \o A line edit shown in the \l{Plastique Style Widget Gallery}{Plastique widget style}.

   210     \endtable

   211 

   212     \sa QTextEdit, QLabel, QComboBox, {fowler}{GUI Design Handbook: Field, Entry}, {Line Edits Example}

   213 */

   214 

   215 

   216 /*!

   217     \fn void QLineEdit::textChanged(const QString &text)

   218 

   219     This signal is emitted whenever the text changes. The \a text

   220     argument is the new text.

   221 

   222     Unlike textEdited(), this signal is also emitted when the text is

   223     changed programmatically, for example, by calling setText().

   224 */

   225 

   226 /*!

   227     \fn void QLineEdit::textEdited(const QString &text)

   228 

   229     This signal is emitted whenever the text is edited. The \a text

   230     argument is the next text.

   231 

   232     Unlike textChanged(), this signal is not emitted when the text is

   233     changed programmatically, for example, by calling setText().

   234 */

   235 

   236 /*!

   237     \fn void QLineEdit::cursorPositionChanged(int old, int new)

   238 

   239     This signal is emitted whenever the cursor moves. The previous

   240     position is given by \a old, and the new position by \a new.

   241 

   242     \sa setCursorPosition(), cursorPosition()

   243 */

   244 

   245 /*!

   246     \fn void QLineEdit::selectionChanged()

   247 

   248     This signal is emitted whenever the selection changes.

   249 

   250     \sa hasSelectedText(), selectedText()

   251 */

   252 

   253 /*!

   254     Constructs a line edit with no text.

   255 

   256     The maximum text length is set to 32767 characters.

   257 

   258     The \a parent argument is sent to the QWidget constructor.

   259 

   260     \sa setText(), setMaxLength()

   261 */

   262 QLineEdit::QLineEdit(QWidget* parent)

   263     : QWidget(*new QLineEditPrivate, parent,0)

   264 {

   265     Q_D(QLineEdit);

   266     d->init(QString());

   267 }

   268 

   269 /*!

   270     Constructs a line edit containing the text \a contents.

   271 

   272     The cursor position is set to the end of the line and the maximum

   273     text length to 32767 characters.

   274 

   275     The \a parent and argument is sent to the QWidget

   276     constructor.

   277 

   278     \sa text(), setMaxLength()

   279 */

   280 QLineEdit::QLineEdit(const QString& contents, QWidget* parent)

   281     : QWidget(*new QLineEditPrivate, parent, 0)

   282 {

   283     Q_D(QLineEdit);

   284     d->init(contents);

   285 }

   286 

   287 

   288 #ifdef QT3_SUPPORT

   289 /*!

   290     Constructs a line edit with no text.

   291 

   292     The maximum text length is set to 32767 characters.

   293 

   294     The \a parent and \a name arguments are sent to the QWidget constructor.

   295 

   296     \sa setText(), setMaxLength()

   297 */

   298 QLineEdit::QLineEdit(QWidget* parent, const char* name)

   299     : QWidget(*new QLineEditPrivate, parent,0)

   300 {

   301     Q_D(QLineEdit);

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

   303     d->init(QString());

   304 }

   305 

   306 /*!

   307     Constructs a line edit containing the text \a contents.

   308 

   309     The cursor position is set to the end of the line and the maximum

   310     text length to 32767 characters.

   311 

   312     The \a parent and \a name arguments are sent to the QWidget

   313     constructor.

   314 

   315     \sa text(), setMaxLength()

   316 */

   317 

   318 QLineEdit::QLineEdit(const QString& contents, QWidget* parent, const char* name)

   319     : QWidget(*new QLineEditPrivate, parent, 0)

   320 {

   321     Q_D(QLineEdit);

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

   323     d->init(contents);

   324 }

   325 

   326 /*!

   327     Constructs a line edit with an input \a inputMask and the text \a

   328     contents.

   329 

   330     The cursor position is set to the end of the line and the maximum

   331     text length is set to the length of the mask (the number of mask

   332     characters and separators).

   333 

   334     The \a parent and \a name arguments are sent to the QWidget

   335     constructor.

   336 

   337     \sa setMask() text()

   338 */

   339 QLineEdit::QLineEdit(const QString& contents, const QString &inputMask, QWidget* parent, const char* name)

   340     : QWidget(*new QLineEditPrivate, parent, 0)

   341 {

   342     Q_D(QLineEdit);

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

   344     d->init(contents);

   345     d->control->setInputMask(inputMask);

   346     d->control->moveCursor(d->control->nextMaskBlank(contents.length()));

   347 }

   348 #endif

   349 

   350 /*!

   351     Destroys the line edit.

   352 */

   353 

   354 QLineEdit::~QLineEdit()

   355 {

   356 }

   357 

   358 

   359 /*!

   360     \property QLineEdit::text

   361     \brief the line edit's text

   362 

   363     Setting this property clears the selection, clears the undo/redo

   364     history, moves the cursor to the end of the line and resets the

   365     \l modified property to false. The text is not validated when

   366     inserted with setText().

   367 

   368     The text is truncated to maxLength() length.

   369 

   370     By default, this property contains an empty string.

   371 

   372     \sa insert(), clear()

   373 */

   374 QString QLineEdit::text() const

   375 {

   376     Q_D(const QLineEdit);

   377     return d->control->text();

   378 }

   379 

   380 void QLineEdit::setText(const QString& text)

   381 {

   382     Q_D(QLineEdit);

   383     d->control->setText(text);

   384 }

   385 

   386 // ### Qt 4.7: remove this #if guard

   387 #if (QT_VERSION >= 0x407000) || defined(Q_WS_MAEMO_5)

   388 /*!

   389     \since 4.7

   390 

   391     \property QLineEdit::placeholderText

   392     \brief the line edit's placeholder text

   393 

   394     Setting this property makes the line edit display a grayed-out

   395     placeholder text as long as the text() is empty and the widget doesn't

   396     have focus.

   397 

   398     By default, this property contains an empty string.

   399 

   400     \sa text()

   401 */

   402 QString QLineEdit::placeholderText() const

   403 {

   404     Q_D(const QLineEdit);

   405     return d->placeholderText;

   406 }

   407 

   408 void QLineEdit::setPlaceholderText(const QString& placeholderText)

   409 {

   410     Q_D(QLineEdit);

   411     if (d->placeholderText != placeholderText) {

   412         d->placeholderText = placeholderText;

   413         if (!hasFocus())

   414             update();

   415     }

   416 }

   417 #endif

   418 

   419 /*!

   420     \property QLineEdit::displayText

   421     \brief the displayed text

   422 

   423     If \l echoMode is \l Normal this returns the same as text(); if

   424     \l EchoMode is \l Password or \l PasswordEchoOnEdit it returns a string of asterisks

   425     text().length() characters long, e.g. "******"; if \l EchoMode is

   426     \l NoEcho returns an empty string, "".

   427 

   428     By default, this property contains an empty string.

   429 

   430     \sa setEchoMode() text() EchoMode

   431 */

   432 

   433 QString QLineEdit::displayText() const

   434 {

   435     Q_D(const QLineEdit);

   436     return d->control->displayText();

   437 }

   438 

   439 

   440 /*!

   441     \property QLineEdit::maxLength

   442     \brief the maximum permitted length of the text

   443 

   444     If the text is too long, it is truncated at the limit.

   445 

   446     If truncation occurs any selected text will be unselected, the

   447     cursor position is set to 0 and the first part of the string is

   448     shown.

   449 

   450     If the line edit has an input mask, the mask defines the maximum

   451     string length.

   452 

   453     By default, this property contains a value of 32767.

   454 

   455     \sa inputMask

   456 */

   457 

   458 int QLineEdit::maxLength() const

   459 {

   460     Q_D(const QLineEdit);

   461     return d->control->maxLength();

   462 }

   463 

   464 void QLineEdit::setMaxLength(int maxLength)

   465 {

   466     Q_D(QLineEdit);

   467     d->control->setMaxLength(maxLength);

   468 }

   469 

   470 /*!

   471     \property QLineEdit::frame

   472     \brief whether the line edit draws itself with a frame

   473 

   474     If enabled (the default) the line edit draws itself inside a

   475     frame, otherwise the line edit draws itself without any frame.

   476 */

   477 bool QLineEdit::hasFrame() const

   478 {

   479     Q_D(const QLineEdit);

   480     return d->frame;

   481 }

   482 

   483 

   484 void QLineEdit::setFrame(bool enable)

   485 {

   486     Q_D(QLineEdit);

   487     d->frame = enable;

   488     update();

   489     updateGeometry();

   490 }

   491 

   492 

   493 /*!

   494     \enum QLineEdit::EchoMode

   495 

   496     This enum type describes how a line edit should display its

   497     contents.

   498 

   499     \value Normal   Display characters as they are entered. This is the

   500                     default.

   501     \value NoEcho   Do not display anything. This may be appropriate

   502                     for passwords where even the length of the

   503                     password should be kept secret.

   504     \value Password  Display asterisks instead of the characters

   505                     actually entered.

   506     \value PasswordEchoOnEdit Display characters as they are entered

   507                     while editing otherwise display asterisks.

   508 

   509     \sa setEchoMode() echoMode()

   510 */

   511 

   512 

   513 /*!

   514     \property QLineEdit::echoMode

   515     \brief the line edit's echo mode

   516 

   517     The echo mode determines how the text entered in the line edit is

   518     displayed (or echoed) to the user.

   519 

   520     The most common setting is \l Normal, in which the text entered by the

   521     user is displayed verbatim, but QLineEdit also supports modes that allow

   522     the entered text to be suppressed or obscured: these include \l NoEcho,

   523     \l Password and \l PasswordEchoOnEdit.

   524 

   525     The widget's display and the ability to copy or drag the text is

   526     affected by this setting.

   527 

   528     By default, this property is set to \l Normal.

   529 

   530     \sa EchoMode displayText()

   531 */

   532 

   533 QLineEdit::EchoMode QLineEdit::echoMode() const

   534 {

   535     Q_D(const QLineEdit);

   536     return (EchoMode) d->control->echoMode();

   537 }

   538 

   539 void QLineEdit::setEchoMode(EchoMode mode)

   540 {

   541     Q_D(QLineEdit);

   542     if (mode == (EchoMode)d->control->echoMode())

   543         return;

   544     Qt::InputMethodHints imHints = inputMethodHints();

   545     if (mode == Password) {

   546         imHints |= Qt::ImhHiddenText;

   547     } else {

   548         imHints &= ~Qt::ImhHiddenText;

   549     }

   550     setInputMethodHints(imHints);

   551     d->control->setEchoMode(mode);

   552     update();

   553 #ifdef Q_WS_MAC

   554     if (hasFocus())

   555         qt_mac_secure_keyboard(mode == Password || mode == NoEcho);

   556 #endif

   557 }

   558 

   559 

   560 #ifndef QT_NO_VALIDATOR

   561 /*!

   562     Returns a pointer to the current input validator, or 0 if no

   563     validator has been set.

   564 

   565     \sa setValidator()

   566 */

   567 

   568 const QValidator * QLineEdit::validator() const

   569 {

   570     Q_D(const QLineEdit);

   571     return d->control->validator();

   572 }

   573 

   574 /*!

   575     Sets this line edit to only accept input that the validator, \a v,

   576     will accept. This allows you to place any arbitrary constraints on

   577     the text which may be entered.

   578 

   579     If \a v == 0, setValidator() removes the current input validator.

   580     The initial setting is to have no input validator (i.e. any input

   581     is accepted up to maxLength()).

   582 

   583     \sa validator() QIntValidator QDoubleValidator QRegExpValidator

   584 */

   585 

   586 void QLineEdit::setValidator(const QValidator *v)

   587 {

   588     Q_D(QLineEdit);

   589     d->control->setValidator(v);

   590 }

   591 #endif // QT_NO_VALIDATOR

   592 

   593 #ifndef QT_NO_COMPLETER

   594 /*!

   595     \since 4.2

   596 

   597     Sets this line edit to provide auto completions from the completer, \a c.

   598     The completion mode is set using QCompleter::setCompletionMode().

   599 

   600     To use a QCompleter with a QValidator or QLineEdit::inputMask, you need to

   601     ensure that the model provided to QCompleter contains valid entries. You can

   602     use the QSortFilterProxyModel to ensure that the QCompleter's model contains

   603     only valid entries.

   604 

   605     If \a c == 0, setCompleter() removes the current completer, effectively

   606     disabling auto completion.

   607 

   608     \sa QCompleter

   609 */

   610 void QLineEdit::setCompleter(QCompleter *c)

   611 {

   612     Q_D(QLineEdit);

   613     if (c == d->control->completer())

   614         return;

   615     if (d->control->completer()) {

   616         disconnect(d->control->completer(), 0, this, 0);

   617         d->control->completer()->setWidget(0);

   618         if (d->control->completer()->parent() == this)

   619             delete d->control->completer();

   620     }

   621     d->control->setCompleter(c);

   622     if (!c)

   623         return;

   624     if (c->widget() == 0)

   625         c->setWidget(this);

   626     if (hasFocus()) {

   627         QObject::connect(d->control->completer(), SIGNAL(activated(QString)),

   628                          this, SLOT(setText(QString)));

   629         QObject::connect(d->control->completer(), SIGNAL(highlighted(QString)),

   630                          this, SLOT(_q_completionHighlighted(QString)));

   631     }

   632 }

   633 

   634 /*!

   635     \since 4.2

   636 

   637     Returns the current QCompleter that provides completions.

   638 */

   639 QCompleter *QLineEdit::completer() const

   640 {

   641     Q_D(const QLineEdit);

   642     return d->control->completer();

   643 }

   644 

   645 #endif // QT_NO_COMPLETER

   646 

   647 /*!

   648     Returns a recommended size for the widget.

   649 

   650     The width returned, in pixels, is usually enough for about 15 to

   651     20 characters.

   652 */

   653 

   654 QSize QLineEdit::sizeHint() const

   655 {

   656     Q_D(const QLineEdit);

   657     ensurePolished();

   658     QFontMetrics fm(font());

   659     int h = qMax(fm.height(), 14) + 2*d->verticalMargin

   660             + d->topTextMargin + d->bottomTextMargin

   661             + d->topmargin + d->bottommargin;

   662     int w = fm.width(QLatin1Char('x')) * 17 + 2*d->horizontalMargin

   663             + d->leftTextMargin + d->rightTextMargin

   664             + d->leftmargin + d->rightmargin; // "some"

   665     QStyleOptionFrameV2 opt;

   666     initStyleOption(&opt);

   667     return (style()->sizeFromContents(QStyle::CT_LineEdit, &opt, QSize(w, h).

   668                                       expandedTo(QApplication::globalStrut()), this));

   669 }

   670 

   671 

   672 /*!

   673     Returns a minimum size for the line edit.

   674 

   675     The width returned is enough for at least one character.

   676 */

   677 

   678 QSize QLineEdit::minimumSizeHint() const

   679 {

   680     Q_D(const QLineEdit);

   681     ensurePolished();

   682     QFontMetrics fm = fontMetrics();

   683     int h = fm.height() + qMax(2*d->verticalMargin, fm.leading())

   684             + d->topmargin + d->bottommargin;

   685     int w = fm.maxWidth() + d->leftmargin + d->rightmargin;

   686     QStyleOptionFrameV2 opt;

   687     initStyleOption(&opt);

   688     return (style()->sizeFromContents(QStyle::CT_LineEdit, &opt, QSize(w, h).

   689                                       expandedTo(QApplication::globalStrut()), this));

   690 }

   691 

   692 

   693 /*!

   694     \property QLineEdit::cursorPosition

   695     \brief the current cursor position for this line edit

   696 

   697     Setting the cursor position causes a repaint when appropriate.

   698 

   699     By default, this property contains a value of 0.

   700 */

   701 

   702 int QLineEdit::cursorPosition() const

   703 {

   704     Q_D(const QLineEdit);

   705     return d->control->cursorPosition();

   706 }

   707 

   708 void QLineEdit::setCursorPosition(int pos)

   709 {

   710     Q_D(QLineEdit);

   711     d->control->setCursorPosition(pos);

   712 }

   713 

   714 /*!

   715     Returns the cursor position under the point \a pos.

   716 */

   717 // ### What should this do if the point is outside of contentsRect? Currently returns 0.

   718 int QLineEdit::cursorPositionAt(const QPoint &pos)

   719 {

   720     Q_D(QLineEdit);

   721     return d->xToPos(pos.x());

   722 }

   723 

   724 

   725 #ifdef QT3_SUPPORT

   726 /*! \obsolete

   727 

   728     Use setText(), setCursorPosition() and setSelection() instead.

   729 */

   730 bool QLineEdit::validateAndSet(const QString &newText, int newPos,

   731                                  int newMarkAnchor, int newMarkDrag)

   732 {

   733     // The suggested functions above in the docs don't seem to validate,

   734     // below code tries to mimic previous behaviour.

   735     QString oldText = text();

   736     setText(newText);

   737     if(!hasAcceptableInput()){

   738         setText(oldText);

   739         return false;

   740     }

   741     setCursorPosition(newPos);

   742     setSelection(qMin(newMarkAnchor, newMarkDrag), qAbs(newMarkAnchor - newMarkDrag));

   743     return true;

   744 }

   745 #endif //QT3_SUPPORT

   746 

   747 /*!

   748     \property QLineEdit::alignment

   749     \brief the alignment of the line edit

   750 

   751     Both horizontal and vertical alignment is allowed here, Qt::AlignJustify

   752     will map to Qt::AlignLeft.

   753 

   754     By default, this property contains a combination of Qt::AlignLeft and Qt::AlignVCenter.

   755 

   756     \sa Qt::Alignment

   757 */

   758 

   759 Qt::Alignment QLineEdit::alignment() const

   760 {

   761     Q_D(const QLineEdit);

   762     return QFlag(d->alignment);

   763 }

   764 

   765 void QLineEdit::setAlignment(Qt::Alignment alignment)

   766 {

   767     Q_D(QLineEdit);

   768     d->alignment = alignment;

   769     update();

   770 }

   771 

   772 

   773 /*!

   774     Moves the cursor forward \a steps characters. If \a mark is true

   775     each character moved over is added to the selection; if \a mark is

   776     false the selection is cleared.

   777 

   778     \sa cursorBackward()

   779 */

   780 

   781 void QLineEdit::cursorForward(bool mark, int steps)

   782 {

   783     Q_D(QLineEdit);

   784     d->control->cursorForward(mark, steps);

   785 }

   786 

   787 

   788 /*!

   789     Moves the cursor back \a steps characters. If \a mark is true each

   790     character moved over is added to the selection; if \a mark is

   791     false the selection is cleared.

   792 

   793     \sa cursorForward()

   794 */

   795 void QLineEdit::cursorBackward(bool mark, int steps)

   796 {

   797     cursorForward(mark, -steps);

   798 }

   799 

   800 /*!

   801     Moves the cursor one word forward. If \a mark is true, the word is

   802     also selected.

   803 

   804     \sa cursorWordBackward()

   805 */

   806 void QLineEdit::cursorWordForward(bool mark)

   807 {

   808     Q_D(QLineEdit);

   809     d->control->cursorWordForward(mark);

   810 }

   811 

   812 /*!

   813     Moves the cursor one word backward. If \a mark is true, the word

   814     is also selected.

   815 

   816     \sa cursorWordForward()

   817 */

   818 

   819 void QLineEdit::cursorWordBackward(bool mark)

   820 {

   821     Q_D(QLineEdit);

   822     d->control->cursorWordBackward(mark);

   823 }

   824 

   825 

   826 /*!

   827     If no text is selected, deletes the character to the left of the

   828     text cursor and moves the cursor one position to the left. If any

   829     text is selected, the cursor is moved to the beginning of the

   830     selected text and the selected text is deleted.

   831 

   832     \sa del()

   833 */

   834 void QLineEdit::backspace()

   835 {

   836     Q_D(QLineEdit);

   837     d->control->backspace();

   838 }

   839 

   840 /*!

   841     If no text is selected, deletes the character to the right of the

   842     text cursor. If any text is selected, the cursor is moved to the

   843     beginning of the selected text and the selected text is deleted.

   844 

   845     \sa backspace()

   846 */

   847 

   848 void QLineEdit::del()

   849 {

   850     Q_D(QLineEdit);

   851     d->control->del();

   852 }

   853 

   854 /*!

   855     Moves the text cursor to the beginning of the line unless it is

   856     already there. If \a mark is true, text is selected towards the

   857     first position; otherwise, any selected text is unselected if the

   858     cursor is moved.

   859 

   860     \sa end()

   861 */

   862 

   863 void QLineEdit::home(bool mark)

   864 {

   865     Q_D(QLineEdit);

   866     d->control->home(mark);

   867 }

   868 

   869 /*!

   870     Moves the text cursor to the end of the line unless it is already

   871     there. If \a mark is true, text is selected towards the last

   872     position; otherwise, any selected text is unselected if the cursor

   873     is moved.

   874 

   875     \sa home()

   876 */

   877 

   878 void QLineEdit::end(bool mark)

   879 {

   880     Q_D(QLineEdit);

   881     d->control->end(mark);

   882 }

   883 

   884 

   885 /*!

   886     \property QLineEdit::modified

   887     \brief whether the line edit's contents has been modified by the user

   888 

   889     The modified flag is never read by QLineEdit; it has a default value

   890     of false and is changed to true whenever the user changes the line

   891     edit's contents.

   892 

   893     This is useful for things that need to provide a default value but

   894     do not start out knowing what the default should be (perhaps it

   895     depends on other fields on the form). Start the line edit without

   896     the best default, and when the default is known, if modified()

   897     returns false (the user hasn't entered any text), insert the

   898     default value.

   899 

   900     Calling setText() resets the modified flag to false.

   901 */

   902 

   903 bool QLineEdit::isModified() const

   904 {

   905     Q_D(const QLineEdit);

   906     return d->control->isModified();

   907 }

   908 

   909 void QLineEdit::setModified(bool modified)

   910 {

   911     Q_D(QLineEdit);

   912     d->control->setModified(modified);

   913 }

   914 

   915 

   916 /*!\fn QLineEdit::clearModified()

   917 

   918 Use setModified(false) instead.

   919 

   920     \sa isModified()

   921 */

   922 

   923 

   924 /*!

   925     \property QLineEdit::hasSelectedText

   926     \brief whether there is any text selected

   927 

   928     hasSelectedText() returns true if some or all of the text has been

   929     selected by the user; otherwise returns false.

   930 

   931     By default, this property is false.

   932 

   933     \sa selectedText()

   934 */

   935 

   936 

   937 bool QLineEdit::hasSelectedText() const

   938 {

   939     Q_D(const QLineEdit);

   940     return d->control->hasSelectedText();

   941 }

   942 

   943 /*!

   944     \property QLineEdit::selectedText

   945     \brief the selected text

   946 

   947     If there is no selected text this property's value is

   948     an empty string.

   949 

   950     By default, this property contains an empty string.

   951 

   952     \sa hasSelectedText()

   953 */

   954 

   955 QString QLineEdit::selectedText() const

   956 {

   957     Q_D(const QLineEdit);

   958     return d->control->selectedText();

   959 }

   960 

   961 /*!

   962     selectionStart() returns the index of the first selected character in the

   963     line edit or -1 if no text is selected.

   964 

   965     \sa selectedText()

   966 */

   967 

   968 int QLineEdit::selectionStart() const

   969 {

   970     Q_D(const QLineEdit);

   971     return d->control->selectionStart();

   972 }

   973 

   974 

   975 #ifdef QT3_SUPPORT

   976 

   977 /*!

   978     \fn void QLineEdit::lostFocus()

   979 

   980     This signal is emitted when the line edit has lost focus.

   981 

   982     Use editingFinished() instead

   983     \sa editingFinished(), returnPressed()

   984 */

   985 

   986 /*!

   987     Use isModified() instead.

   988 */

   989 bool QLineEdit::edited() const { return isModified(); }

   990 /*!

   991     Use setModified()  or setText().

   992 */

   993 void QLineEdit::setEdited(bool on) { setModified(on); }

   994 

   995 /*!

   996     There exists no equivalent functionality in Qt 4.

   997 */

   998 int QLineEdit::characterAt(int xpos, QChar *chr) const

   999 {

  1000     Q_D(const QLineEdit);

  1001     int pos = d->xToPos(xpos + contentsRect().x() - d->hscroll + d->horizontalMargin);

  1002     QString txt = d->control->text();

  1003     if (chr && pos < (int) txt.length())

  1004         *chr = txt.at(pos);

  1005     return pos;

  1006 

  1007 }

  1008 

  1009 /*!

  1010     Use selectedText() and selectionStart() instead.

  1011 */

  1012 bool QLineEdit::getSelection(int *start, int *end)

  1013 {

  1014     Q_D(QLineEdit);

  1015     if (d->control->hasSelectedText() && start && end) {

  1016         *start = selectionStart();

  1017         *end = *start + selectedText().length();

  1018         return true;

  1019     }

  1020     return false;

  1021 }

  1022 #endif

  1023 

  1024 

  1025 /*!

  1026     Selects text from position \a start and for \a length characters.

  1027     Negative lengths are allowed.

  1028 

  1029     \sa deselect() selectAll() selectedText()

  1030 */

  1031 

  1032 void QLineEdit::setSelection(int start, int length)

  1033 {

  1034     Q_D(QLineEdit);

  1035     if (start < 0 || start > (int)d->control->text().length()) {

  1036         qWarning("QLineEdit::setSelection: Invalid start position (%d)", start);

  1037         return;

  1038     }

  1039 

  1040     d->control->setSelection(start, length);

  1041 

  1042     if (d->control->hasSelectedText()){

  1043         QStyleOptionFrameV2 opt;

  1044         initStyleOption(&opt);

  1045         if (!style()->styleHint(QStyle::SH_BlinkCursorWhenTextSelected, &opt, this))

  1046             d->setCursorVisible(false);

  1047     }

  1048 }

  1049 

  1050 

  1051 /*!

  1052     \property QLineEdit::undoAvailable

  1053     \brief whether undo is available

  1054 

  1055     Undo becomes available once the user has modified the text in the line edit.

  1056 

  1057     By default, this property is false.

  1058 */

  1059 

  1060 bool QLineEdit::isUndoAvailable() const

  1061 {

  1062     Q_D(const QLineEdit);

  1063     return d->control->isUndoAvailable();

  1064 }

  1065 

  1066 /*!

  1067     \property QLineEdit::redoAvailable

  1068     \brief whether redo is available

  1069 

  1070     Redo becomes available once the user has performed one or more undo operations

  1071     on text in the line edit.

  1072 

  1073     By default, this property is false.

  1074 */

  1075 

  1076 bool QLineEdit::isRedoAvailable() const

  1077 {

  1078     Q_D(const QLineEdit);

  1079     return d->control->isRedoAvailable();

  1080 }

  1081 

  1082 /*!

  1083     \property QLineEdit::dragEnabled

  1084     \brief whether the lineedit starts a drag if the user presses and

  1085     moves the mouse on some selected text

  1086 

  1087     Dragging is disabled by default.

  1088 */

  1089 

  1090 bool QLineEdit::dragEnabled() const

  1091 {

  1092     Q_D(const QLineEdit);

  1093     return d->dragEnabled;

  1094 }

  1095 

  1096 void QLineEdit::setDragEnabled(bool b)

  1097 {

  1098     Q_D(QLineEdit);

  1099     d->dragEnabled = b;

  1100 }

  1101 

  1102 

  1103 /*!

  1104     \property QLineEdit::acceptableInput

  1105     \brief whether the input satisfies the inputMask and the

  1106     validator.

  1107 

  1108     By default, this property is true.

  1109 

  1110     \sa setInputMask(), setValidator()

  1111 */

  1112 bool QLineEdit::hasAcceptableInput() const

  1113 {

  1114     Q_D(const QLineEdit);

  1115     return d->control->hasAcceptableInput();

  1116 }

  1117 

  1118 /*!

  1119     Sets the margins around the text inside the frame to have the

  1120     sizes \a left, \a top, \a right, and \a bottom.

  1121     \since 4.5

  1122 

  1123     See also getTextMargins().

  1124 */

  1125 void QLineEdit::setTextMargins(int left, int top, int right, int bottom)

  1126 {

  1127     Q_D(QLineEdit);

  1128     d->leftTextMargin = left;

  1129     d->topTextMargin = top;

  1130     d->rightTextMargin = right;

  1131     d->bottomTextMargin = bottom;

  1132     updateGeometry();

  1133     update();

  1134 }

  1135