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

     2 **

     3 ** Copyright (C) 2009 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 

   387 /*!

   388     \property QLineEdit::displayText

   389     \brief the displayed text

   390 

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

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

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

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

   395 

   396     By default, this property contains an empty string.

   397 

   398     \sa setEchoMode() text() EchoMode

   399 */

   400 

   401 QString QLineEdit::displayText() const

   402 {

   403     Q_D(const QLineEdit);

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

   405 }

   406 

   407 

   408 /*!

   409     \property QLineEdit::maxLength

   410     \brief the maximum permitted length of the text

   411 

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

   413 

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

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

   416     shown.

   417 

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

   419     string length.

   420 

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

   422 

   423     \sa inputMask

   424 */

   425 

   426 int QLineEdit::maxLength() const

   427 {

   428     Q_D(const QLineEdit);

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

   430 }

   431 

   432 void QLineEdit::setMaxLength(int maxLength)

   433 {

   434     Q_D(QLineEdit);

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

   436 }

   437 

   438 /*!

   439     \property QLineEdit::frame

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

   441 

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

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

   444 */

   445 bool QLineEdit::hasFrame() const

   446 {

   447     Q_D(const QLineEdit);

   448     return d->frame;

   449 }

   450 

   451 

   452 void QLineEdit::setFrame(bool enable)

   453 {

   454     Q_D(QLineEdit);

   455     d->frame = enable;

   456     update();

   457     updateGeometry();

   458 }

   459 

   460 

   461 /*!

   462     \enum QLineEdit::EchoMode

   463 

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

   465     contents.

   466 

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

   468                     default.

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

   470                     for passwords where even the length of the

   471                     password should be kept secret.

   472     \value Password  Display asterisks instead of the characters

   473                     actually entered.

   474     \value PasswordEchoOnEdit Display characters as they are entered

   475                     while editing otherwise display asterisks.

   476 

   477     \sa setEchoMode() echoMode()

   478 */

   479 

   480 

   481 /*!

   482     \property QLineEdit::echoMode

   483     \brief the line edit's echo mode

   484 

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

   486     displayed (or echoed) to the user.

   487 

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

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

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

   491     \l Password and \l PasswordEchoOnEdit.

   492 

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

   494     affected by this setting.

   495 

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

   497 

   498     \sa EchoMode displayText()

   499 */

   500 

   501 QLineEdit::EchoMode QLineEdit::echoMode() const

   502 {

   503     Q_D(const QLineEdit);

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

   505 }

   506 

   507 void QLineEdit::setEchoMode(EchoMode mode)

   508 {

   509     Q_D(QLineEdit);

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

   511         return;

   512     Qt::InputMethodHints imHints = inputMethodHints();

   513     if (mode == Password) {

   514         imHints |= Qt::ImhHiddenText;

   515     } else {

   516         imHints &= ~Qt::ImhHiddenText;

   517     }

   518     setInputMethodHints(imHints);

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

   520     update();

   521 #ifdef Q_WS_MAC

   522     if (hasFocus())

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

   524 #endif

   525 }

   526 

   527 

   528 #ifndef QT_NO_VALIDATOR

   529 /*!

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

   531     validator has been set.

   532 

   533     \sa setValidator()

   534 */

   535 

   536 const QValidator * QLineEdit::validator() const

   537 {

   538     Q_D(const QLineEdit);

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

   540 }

   541 

   542 /*!

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

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

   545     the text which may be entered.

   546 

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

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

   549     is accepted up to maxLength()).

   550 

   551     \sa validator() QIntValidator QDoubleValidator QRegExpValidator

   552 */

   553 

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

   555 {

   556     Q_D(QLineEdit);

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

   558 }

   559 #endif // QT_NO_VALIDATOR

   560 

   561 #ifndef QT_NO_COMPLETER

   562 /*!

   563     \since 4.2

   564 

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

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

   567 

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

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

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

   571     only valid entries.

   572 

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

   574     disabling auto completion.

   575 

   576     \sa QCompleter

   577 */

   578 void QLineEdit::setCompleter(QCompleter *c)

   579 {

   580     Q_D(QLineEdit);

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

   582         return;

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

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

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

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

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

   588     }

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

   590     if (!c)

   591         return;

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

   593         c->setWidget(this);

   594     if (hasFocus()) {

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

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

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

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

   599     }

   600 }

   601 

   602 /*!

   603     \since 4.2

   604 

   605     Returns the current QCompleter that provides completions.

   606 */

   607 QCompleter *QLineEdit::completer() const

   608 {

   609     Q_D(const QLineEdit);

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

   611 }

   612 

   613 #endif // QT_NO_COMPLETER

   614 

   615 /*!

   616     Returns a recommended size for the widget.

   617 

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

   619     20 characters.

   620 */

   621 

   622 QSize QLineEdit::sizeHint() const

   623 {

   624     Q_D(const QLineEdit);

   625     ensurePolished();

   626     QFontMetrics fm(font());

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

   628             + d->topTextMargin + d->bottomTextMargin

   629             + d->topmargin + d->bottommargin;

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

   631             + d->leftTextMargin + d->rightTextMargin

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

   633     QStyleOptionFrameV2 opt;

   634     initStyleOption(&opt);

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

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

   637 }

   638 

   639 

   640 /*!

   641     Returns a minimum size for the line edit.

   642 

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

   644 */

   645 

   646 QSize QLineEdit::minimumSizeHint() const

   647 {

   648     Q_D(const QLineEdit);

   649     ensurePolished();

   650     QFontMetrics fm = fontMetrics();

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

   652             + d->topmargin + d->bottommargin;

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

   654     QStyleOptionFrameV2 opt;

   655     initStyleOption(&opt);

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

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

   658 }

   659 

   660 

   661 /*!

   662     \property QLineEdit::cursorPosition

   663     \brief the current cursor position for this line edit

   664 

   665     Setting the cursor position causes a repaint when appropriate.

   666 

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

   668 */

   669 

   670 int QLineEdit::cursorPosition() const

   671 {

   672     Q_D(const QLineEdit);

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

   674 }

   675 

   676 void QLineEdit::setCursorPosition(int pos)

   677 {

   678     Q_D(QLineEdit);

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

   680 }

   681 

   682 /*!

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

   684 */

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

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

   687 {

   688     Q_D(QLineEdit);

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

   690 }

   691 

   692 

   693 #ifdef QT3_SUPPORT

   694 /*! \obsolete

   695 

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

   697 */

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

   699                                  int newMarkAnchor, int newMarkDrag)

   700 {

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

   702     // below code tries to mimic previous behaviour.

   703     QString oldText = text();

   704     setText(newText);

   705     if(!hasAcceptableInput()){

   706         setText(oldText);

   707         return false;

   708     }

   709     setCursorPosition(newPos);

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

   711     return true;

   712 }

   713 #endif //QT3_SUPPORT

   714 

   715 /*!

   716     \property QLineEdit::alignment

   717     \brief the alignment of the line edit

   718 

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

   720     will map to Qt::AlignLeft.

   721 

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

   723 

   724     \sa Qt::Alignment

   725 */

   726 

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

   728 {

   729     Q_D(const QLineEdit);

   730     return QFlag(d->alignment);

   731 }

   732 

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

   734 {

   735     Q_D(QLineEdit);

   736     d->alignment = alignment;

   737     update();

   738 }

   739 

   740 

   741 /*!

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

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

   744     false the selection is cleared.

   745 

   746     \sa cursorBackward()

   747 */

   748 

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

   750 {

   751     Q_D(QLineEdit);

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

   753 }

   754 

   755 

   756 /*!

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

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

   759     false the selection is cleared.

   760 

   761     \sa cursorForward()

   762 */

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

   764 {

   765     cursorForward(mark, -steps);

   766 }

   767 

   768 /*!

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

   770     also selected.

   771 

   772     \sa cursorWordBackward()

   773 */

   774 void QLineEdit::cursorWordForward(bool mark)

   775 {

   776     Q_D(QLineEdit);

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

   778 }

   779 

   780 /*!

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

   782     is also selected.

   783 

   784     \sa cursorWordForward()

   785 */

   786 

   787 void QLineEdit::cursorWordBackward(bool mark)

   788 {

   789     Q_D(QLineEdit);

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

   791 }

   792 

   793 

   794 /*!

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

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

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

   798     selected text and the selected text is deleted.

   799 

   800     \sa del()

   801 */

   802 void QLineEdit::backspace()

   803 {

   804     Q_D(QLineEdit);

   805     d->control->backspace();

   806 }

   807 

   808 /*!

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

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

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

   812 

   813     \sa backspace()

   814 */

   815 

   816 void QLineEdit::del()

   817 {

   818     Q_D(QLineEdit);

   819     d->control->del();

   820 }

   821 

   822 /*!

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

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

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

   826     cursor is moved.

   827 

   828     \sa end()

   829 */

   830 

   831 void QLineEdit::home(bool mark)

   832 {

   833     Q_D(QLineEdit);

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

   835 }

   836 

   837 /*!

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

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

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

   841     is moved.

   842 

   843     \sa home()

   844 */

   845 

   846 void QLineEdit::end(bool mark)

   847 {

   848     Q_D(QLineEdit);

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

   850 }

   851 

   852 

   853 /*!

   854     \property QLineEdit::modified

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

   856 

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

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

   859     edit's contents.

   860 

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

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

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

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

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

   866     default value.

   867 

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

   869 */

   870 

   871 bool QLineEdit::isModified() const

   872 {

   873     Q_D(const QLineEdit);

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

   875 }

   876 

   877 void QLineEdit::setModified(bool modified)

   878 {

   879     Q_D(QLineEdit);

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

   881 }

   882 

   883 

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

   885 

   886 Use setModified(false) instead.

   887 

   888     \sa isModified()

   889 */

   890 

   891 

   892 /*!

   893     \property QLineEdit::hasSelectedText

   894     \brief whether there is any text selected

   895 

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

   897     selected by the user; otherwise returns false.

   898 

   899     By default, this property is false.

   900 

   901     \sa selectedText()

   902 */

   903 

   904 

   905 bool QLineEdit::hasSelectedText() const

   906 {

   907     Q_D(const QLineEdit);

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

   909 }

   910 

   911 /*!

   912     \property QLineEdit::selectedText

   913     \brief the selected text

   914 

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

   916     an empty string.

   917 

   918     By default, this property contains an empty string.

   919 

   920     \sa hasSelectedText()

   921 */

   922 

   923 QString QLineEdit::selectedText() const

   924 {

   925     Q_D(const QLineEdit);

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

   927 }

   928 

   929 /*!

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

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

   932 

   933     \sa selectedText()

   934 */

   935 

   936 int QLineEdit::selectionStart() const

   937 {

   938     Q_D(const QLineEdit);

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

   940 }

   941 

   942 

   943 #ifdef QT3_SUPPORT

   944 

   945 /*!

   946     \fn void QLineEdit::lostFocus()

   947 

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

   949 

   950     Use editingFinished() instead

   951     \sa editingFinished(), returnPressed()

   952 */

   953 

   954 /*!

   955     Use isModified() instead.

   956 */

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

   958 /*!

   959     Use setModified()  or setText().

   960 */

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

   962 

   963 /*!

   964     There exists no equivalent functionality in Qt 4.

   965 */

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

   967 {

   968     Q_D(const QLineEdit);

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

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

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

   972         *chr = txt.at(pos);

   973     return pos;

   974 

   975 }

   976 

   977 /*!

   978     Use selectedText() and selectionStart() instead.

   979 */

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

   981 {

   982     Q_D(QLineEdit);

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

   984         *start = selectionStart();

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

   986         return true;

   987     }

   988     return false;

   989 }

   990 #endif

   991 

   992 

   993 /*!

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

   995     Negative lengths are allowed.

   996 

   997     \sa deselect() selectAll() selectedText()

   998 */

   999 

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

  1001 {

  1002     Q_D(QLineEdit);

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

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

  1005         return;

  1006     }

  1007 

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

  1009 

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

  1011         QStyleOptionFrameV2 opt;

  1012         initStyleOption(&opt);

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

  1014             d->setCursorVisible(false);

  1015     }

  1016 }

  1017 

  1018 

  1019 /*!

  1020     \property QLineEdit::undoAvailable

  1021     \brief whether undo is available

  1022 

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

  1024 

  1025     By default, this property is false.

  1026 */

  1027 

  1028 bool QLineEdit::isUndoAvailable() const

  1029 {

  1030     Q_D(const QLineEdit);

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

  1032 }

  1033 

  1034 /*!

  1035     \property QLineEdit::redoAvailable

  1036     \brief whether redo is available

  1037 

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

  1039     on text in the line edit.

  1040 

  1041     By default, this property is false.

  1042 */

  1043 

  1044 bool QLineEdit::isRedoAvailable() const

  1045 {

  1046     Q_D(const QLineEdit);

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

  1048 }

  1049 

  1050 /*!

  1051     \property QLineEdit::dragEnabled

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

  1053     moves the mouse on some selected text

  1054 

  1055     Dragging is disabled by default.

  1056 */

  1057 

  1058 bool QLineEdit::dragEnabled() const

  1059 {

  1060     Q_D(const QLineEdit);

  1061     return d->dragEnabled;

  1062 }

  1063 

  1064 void QLineEdit::setDragEnabled(bool b)

  1065 {

  1066     Q_D(QLineEdit);

  1067     d->dragEnabled = b;

  1068 }

  1069 

  1070 

  1071 /*!

  1072     \property QLineEdit::acceptableInput

  1073     \brief whether the input satisfies the inputMask and the

  1074     validator.

  1075 

  1076     By default, this property is true.

  1077 

  1078     \sa setInputMask(), setValidator()

  1079 */

  1080 bool QLineEdit::hasAcceptableInput() const

  1081 {

  1082     Q_D(const QLineEdit);

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

  1084 }

  1085 

  1086 /*!

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

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

  1089     \since 4.5

  1090 

  1091     See also getTextMargins().

  1092 */

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

  1094 {

  1095     Q_D(QLineEdit);

  1096     d->leftTextMargin = left;

  1097     d->topTextMargin = top;

  1098     d->rightTextMargin = right;

  1099     d->bottomTextMargin = bottom;

  1100     updateGeometry();

  1101     update();

  1102 }

  1103 

  1104 /*!

  1105     Returns the widget's text margins for \a left, \a top, \a right, and \a bottom.

  1106     \since 4.5

  1107 

  1108     \sa setTextMargins()

  1109 */

  1110 void QLineEdit::getTextMargins(int *left, int *top, int *right, int *bottom) const

  1111 {

  1112     Q_D(const QLineEdit);

  1113     if (left)

  1114         *left = d->leftTextMargin;

  1115     if (top)

  1116         *top = d->topTextMargin;

  1117     if (right)

  1118         *right = d->rightTextMargin;

  1119     if (bottom)

  1120         *bottom = d->bottomTextMargin;

  1121 }

  1122 

  1123 /*!

  1124     \property QLineEdit::inputMask

  1125     \brief The validation input mask

  1126 

  1127     If no mask is set, inputMask() returns an empty string.

  1128 

  1129     Sets the QLineEdit's validation mask. Validators can be used

  1130     instead of, or in conjunction with masks; see setValidator().

  1131 

  1132     Unset the mask and return to normal QLineEdit operation by passing

  1133     an empty string ("") or just calling setInputMask() with no

  1134     arguments.