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

    43 

    44 #ifndef QT_NO_LINEEDIT

    45 

    46 #include "qabstractitemview.h"

    47 #include "qclipboard.h"

    48 #ifndef QT_NO_ACCESSIBILITY

    49 #include "qaccessible.h"

    50 #endif

    51 #ifndef QT_NO_IM

    52 #include "qinputcontext.h"

    53 #include "qlist.h"

    54 #endif

    55 #include "qapplication.h"

    56 #ifndef QT_NO_GRAPHICSVIEW

    57 #include "qgraphicssceneevent.h"

    58 #endif

    59 

    60 QT_BEGIN_NAMESPACE

    61 

    62 /*!

    63     \internal

    64 

    65     Updates the display text based of the current edit text

    66     If the text has changed will emit displayTextChanged()

    67 */

    68 void QLineControl::updateDisplayText(bool forceUpdate)

    69 {

    70     QString orig = m_textLayout.text();

    71     QString str;

    72     if (m_echoMode == QLineEdit::NoEcho)

    73         str = QString::fromLatin1("");

    74     else

    75         str = m_text;

    76 

    77     if (m_echoMode == QLineEdit::Password || (m_echoMode == QLineEdit::PasswordEchoOnEdit

    78                 && !m_passwordEchoEditing))

    79         str.fill(m_passwordCharacter);

    80 

    81     // replace certain non-printable characters with spaces (to avoid

    82     // drawing boxes when using fonts that don't have glyphs for such

    83     // characters)

    84     QChar* uc = str.data();

    85     for (int i = 0; i < (int)str.length(); ++i) {

    86         if ((uc[i] < 0x20 && uc[i] != 0x09)

    87             || uc[i] == QChar::LineSeparator

    88             || uc[i] == QChar::ParagraphSeparator

    89             || uc[i] == QChar::ObjectReplacementCharacter)

    90             uc[i] = QChar(0x0020);

    91     }

    92 

    93     m_textLayout.setText(str);

    94 

    95     QTextOption option;

    96     option.setTextDirection(m_layoutDirection);

    97     option.setFlags(QTextOption::IncludeTrailingSpaces);

    98     m_textLayout.setTextOption(option);

    99 

   100     m_textLayout.beginLayout();

   101     QTextLine l = m_textLayout.createLine();

   102     m_textLayout.endLayout();

   103     m_ascent = qRound(l.ascent());

   104 

   105     if (str != orig || forceUpdate)

   106         emit displayTextChanged(str);

   107 }

   108 

   109 #ifndef QT_NO_CLIPBOARD

   110 /*!

   111     \internal

   112 

   113     Copies the currently selected text into the clipboard using the given

   114     \a mode.

   115   

   116     \note If the echo mode is set to a mode other than Normal then copy

   117     will not work.  This is to prevent using copy as a method of bypassing

   118     password features of the line control.

   119 */

   120 void QLineControl::copy(QClipboard::Mode mode) const

   121 {

   122     QString t = selectedText();

   123     if (!t.isEmpty() && m_echoMode == QLineEdit::Normal) {

   124         disconnect(QApplication::clipboard(), SIGNAL(selectionChanged()), this, 0);

   125         QApplication::clipboard()->setText(t, mode);

   126         connect(QApplication::clipboard(), SIGNAL(selectionChanged()),

   127                    this, SLOT(_q_clipboardChanged()));

   128     }

   129 }

   130 

   131 /*!

   132     \internal

   133 

   134     Inserts the text stored in the application clipboard into the line

   135     control.

   136 

   137     \sa insert()

   138 */

   139 void QLineControl::paste()

   140 {

   141     QString clip = QApplication::clipboard()->text(QClipboard::Clipboard);

   142     if (!clip.isEmpty() || hasSelectedText()) {

   143         separate(); //make it a separate undo/redo command

   144         insert(clip);

   145         separate();

   146     }

   147 }

   148 

   149 #endif // !QT_NO_CLIPBOARD

   150 

   151 /*!

   152     \internal

   153 

   154     Handles the behavior for the backspace key or function.

   155     Removes the current selection if there is a selection, otherwise

   156     removes the character prior to the cursor position.

   157 

   158     \sa del()

   159 */

   160 void QLineControl::backspace()

   161 {

   162     int priorState = m_undoState;

   163     if (hasSelectedText()) {

   164         removeSelectedText();

   165     } else if (m_cursor) {

   166             --m_cursor;

   167             if (m_maskData)

   168                 m_cursor = prevMaskBlank(m_cursor);

   169             QChar uc = m_text.at(m_cursor);

   170             if (m_cursor > 0 && uc.unicode() >= 0xdc00 && uc.unicode() < 0xe000) {

   171                 // second half of a surrogate, check if we have the first half as well,

   172                 // if yes delete both at once

   173                 uc = m_text.at(m_cursor - 1);

   174                 if (uc.unicode() >= 0xd800 && uc.unicode() < 0xdc00) {

   175                     internalDelete(true);

   176                     --m_cursor;

   177                 }

   178             }

   179             internalDelete(true);

   180     }

   181     finishChange(priorState);

   182 }

   183 

   184 /*!

   185     \internal

   186 

   187     Handles the behavior for the delete key or function.

   188     Removes the current selection if there is a selection, otherwise

   189     removes the character after the cursor position.

   190 

   191     \sa del()

   192 */

   193 void QLineControl::del()

   194 {

   195     int priorState = m_undoState;

   196     if (hasSelectedText()) {

   197         removeSelectedText();

   198     } else {

   199         int n = m_textLayout.nextCursorPosition(m_cursor) - m_cursor;

   200         while (n--)

   201             internalDelete();

   202     }

   203     finishChange(priorState);

   204 }

   205 

   206 /*!

   207     \internal

   208 

   209     Inserts the given \a newText at the current cursor position.

   210     If there is any selected text it is removed prior to insertion of

   211     the new text.

   212 */

   213 void QLineControl::insert(const QString &newText)

   214 {

   215     int priorState = m_undoState;

   216     removeSelectedText();

   217     internalInsert(newText);

   218     finishChange(priorState);

   219 }

   220 

   221 /*!

   222     \internal

   223 

   224     Clears the line control text.

   225 */

   226 void QLineControl::clear()

   227 {

   228     int priorState = m_undoState;

   229     m_selstart = 0;

   230     m_selend = m_text.length();

   231     removeSelectedText();

   232     separate();

   233     finishChange(priorState, /*update*/false, /*edited*/false);

   234 }

   235 

   236 /*!

   237     \internal

   238 

   239     Sets \a length characters from the given \a start position as selected.

   240     The given \a start position must be within the current text for

   241     the line control.  If \a length characters cannot be selected, then

   242     the selection will extend to the end of the current text.

   243 */

   244 void QLineControl::setSelection(int start, int length)

   245 {

   246     if(start < 0 || start > (int)m_text.length()){

   247         qWarning("QLineControl::setSelection: Invalid start position");

   248         return;

   249     }

   250 

   251     if (length > 0) {

   252         if (start == m_selstart && start + length == m_selend)

   253             return;

   254         m_selstart = start;

   255         m_selend = qMin(start + length, (int)m_text.length());

   256         m_cursor = m_selend;

   257     } else {

   258         if (start == m_selend && start + length == m_selstart)

   259             return;

   260         m_selstart = qMax(start + length, 0);

   261         m_selend = start;

   262         m_cursor = m_selstart;

   263     }

   264     emit selectionChanged();

   265     emitCursorPositionChanged();

   266 }

   267 

   268 void QLineControl::_q_clipboardChanged()

   269 {

   270 }

   271 

   272 void QLineControl::_q_deleteSelected()

   273 {

   274     if (!hasSelectedText())

   275         return;

   276 

   277     int priorState = m_undoState;

   278     emit resetInputContext();

   279     removeSelectedText();

   280     separate();

   281     finishChange(priorState);

   282 }

   283 

   284 /*!

   285     \internal

   286 

   287     Initializes the line control with a starting text value of \a txt.

   288 */

   289 void QLineControl::init(const QString &txt)

   290 {

   291     m_text = txt;

   292     updateDisplayText();

   293     m_cursor = m_text.length();

   294 }

   295 

   296 /*!

   297     \internal

   298 

   299     Sets the password echo editing to \a editing.  If password echo editing

   300     is true, then the text of the password is displayed even if the echo

   301     mode is set to QLineEdit::PasswordEchoOnEdit.  Password echoing editing

   302     does not affect other echo modes.

   303 */

   304 void QLineControl::updatePasswordEchoEditing(bool editing)

   305 {

   306     m_passwordEchoEditing = editing;

   307     updateDisplayText();

   308 }

   309 

   310 /*!

   311     \internal

   312 

   313     Returns the cursor position of the given \a x pixel value in relation

   314     to the displayed text.  The given \a betweenOrOn specified what kind

   315     of cursor position is requested.

   316 */

   317 int QLineControl::xToPos(int x, QTextLine::CursorPosition betweenOrOn) const

   318 {

   319     return m_textLayout.lineAt(0).xToCursor(x, betweenOrOn);

   320 }

   321 

   322 /*!

   323     \internal

   324 

   325     Returns the bounds of the current cursor, as defined as a

   326     between characters cursor.

   327 */

   328 QRect QLineControl::cursorRect() const

   329 {

   330     QTextLine l = m_textLayout.lineAt(0);

   331     int c = m_cursor;

   332     if (m_preeditCursor != -1)

   333         c += m_preeditCursor;

   334     int cix = qRound(l.cursorToX(c));

   335     int w = m_cursorWidth;

   336     int ch = l.height() + 1;

   337 

   338     return QRect(cix-5, 0, w+9, ch);

   339 }

   340 

   341 /*!

   342     \internal

   343 

   344     Fixes the current text so that it is valid given any set validators.

   345 

   346     Returns true if the text was changed.  Otherwise returns false.

   347 */

   348 bool QLineControl::fixup() // this function assumes that validate currently returns != Acceptable

   349 {

   350 #ifndef QT_NO_VALIDATOR

   351     if (m_validator) {

   352         QString textCopy = m_text;

   353         int cursorCopy = m_cursor;

   354         m_validator->fixup(textCopy);

   355         if (m_validator->validate(textCopy, cursorCopy) == QValidator::Acceptable) {

   356             if (textCopy != m_text || cursorCopy != m_cursor)

   357                 internalSetText(textCopy, cursorCopy);

   358             return true;

   359         }

   360     }

   361 #endif

   362     return false;

   363 }

   364 

   365 /*!

   366     \internal

   367 

   368     Moves the cursor to the given position \a pos.   If \a mark is true will

   369     adjust the currently selected text.

   370 */

   371 void QLineControl::moveCursor(int pos, bool mark)

   372 {

   373     if (pos != m_cursor) {

   374         separate();

   375         if (m_maskData)

   376             pos = pos > m_cursor ? nextMaskBlank(pos) : prevMaskBlank(pos);

   377     }

   378     if (mark) {

   379         int anchor;

   380         if (m_selend > m_selstart && m_cursor == m_selstart)

   381             anchor = m_selend;

   382         else if (m_selend > m_selstart && m_cursor == m_selend)

   383             anchor = m_selstart;

   384         else

   385             anchor = m_cursor;

   386         m_selstart = qMin(anchor, pos);

   387         m_selend = qMax(anchor, pos);

   388         updateDisplayText();

   389     } else {

   390         internalDeselect();

   391     }

   392     m_cursor = pos;

   393     if (mark || m_selDirty) {

   394         m_selDirty = false;

   395         emit selectionChanged();

   396     }

   397     emitCursorPositionChanged();

   398 }

   399 

   400 /*!

   401     \internal

   402 

   403     Applies the given input method event \a event to the text of the line

   404     control

   405 */

   406 void QLineControl::processInputMethodEvent(QInputMethodEvent *event)

   407 {

   408     int priorState = 0;

   409     bool isGettingInput = !event->commitString().isEmpty()

   410             || event->preeditString() != preeditAreaText()

   411             || event->replacementLength() > 0;

   412     bool cursorPositionChanged = false;

   413 

   414     if (isGettingInput) {

   415         // If any text is being input, remove selected text.

   416         priorState = m_undoState;

   417         removeSelectedText();

   418     }

   419 

   420 

   421     int c = m_cursor; // cursor position after insertion of commit string

   422     if (event->replacementStart() == 0)

   423         c += event->commitString().length() + qMin(-event->replacementStart(), event->replacementLength());

   424 

   425     m_cursor += event->replacementStart();

   426 

   427     // insert commit string

   428     if (event->replacementLength()) {

   429         m_selstart = m_cursor;

   430         m_selend = m_selstart + event->replacementLength();

   431         removeSelectedText();

   432     }

   433     if (!event->commitString().isEmpty()) {

   434         insert(event->commitString());

   435         cursorPositionChanged = true;

   436     }

   437 

   438     m_cursor = qMin(c, m_text.length());

   439 

   440     for (int i = 0; i < event->attributes().size(); ++i) {

   441         const QInputMethodEvent::Attribute &a = event->attributes().at(i);

   442         if (a.type == QInputMethodEvent::Selection) {

   443             m_cursor = qBound(0, a.start + a.length, m_text.length());

   444             if (a.length) {

   445                 m_selstart = qMax(0, qMin(a.start, m_text.length()));

   446                 m_selend = m_cursor;

   447                 if (m_selend < m_selstart) {

   448                     qSwap(m_selstart, m_selend);

   449                 }

   450             } else {

   451                 m_selstart = m_selend = 0;

   452             }

   453             cursorPositionChanged = true;

   454         }

   455     }

   456 #ifndef QT_NO_IM

   457     setPreeditArea(m_cursor, event->preeditString());

   458 #endif //QT_NO_IM

   459     m_preeditCursor = event->preeditString().length();

   460     m_hideCursor = false;

   461     QList<QTextLayout::FormatRange> formats;

   462     for (int i = 0; i < event->attributes().size(); ++i) {

   463         const QInputMethodEvent::Attribute &a = event->attributes().at(i);

   464         if (a.type == QInputMethodEvent::Cursor) {

   465             m_preeditCursor = a.start;

   466             m_hideCursor = !a.length;

   467         } else if (a.type == QInputMethodEvent::TextFormat) {

   468             QTextCharFormat f = qvariant_cast<QTextFormat>(a.value).toCharFormat();

   469             if (f.isValid()) {

   470                 QTextLayout::FormatRange o;

   471                 o.start = a.start + m_cursor;

   472                 o.length = a.length;

   473                 o.format = f;

   474                 formats.append(o);

   475             }

   476         }

   477     }

   478     m_textLayout.setAdditionalFormats(formats);

   479     updateDisplayText(/*force*/ true);

   480     if (cursorPositionChanged)

   481         emitCursorPositionChanged();

   482     if (isGettingInput)

   483         finishChange(priorState);

   484 }

   485 

   486 /*!

   487     \internal

   488 

   489     Draws the display text for the line control using the given 

   490     \a painter, \a clip, and \a offset.  Which aspects of the display text

   491     are drawn is specified by the given \a flags.

   492 

   493     If the flags contain DrawSelections, then the selection or input mask

   494     backgrounds and foregrounds will be applied before drawing the text.

   495 

   496     If the flags contain DrawCursor a cursor of the current cursorWidth()

   497     will be drawn after drawing the text.

   498 

   499     The display text will only be drawn if the flags contain DrawText

   500 */

   501 void QLineControl::draw(QPainter *painter, const QPoint &offset, const QRect &clip, int flags)

   502 {

   503     QVector<QTextLayout::FormatRange> selections;

   504     if (flags & DrawSelections) {

   505         QTextLayout::FormatRange o;

   506         if (m_selstart < m_selend) {

   507             o.start = m_selstart;

   508             o.length = m_selend - m_selstart;

   509             o.format.setBackground(m_palette.brush(QPalette::Highlight));

   510             o.format.setForeground(m_palette.brush(QPalette::HighlightedText));

   511         } else {

   512             // mask selection

   513             if(!m_blinkPeriod || m_blinkStatus){

   514                 o.start = m_cursor;

   515                 o.length = 1;

   516                 o.format.setBackground(m_palette.brush(QPalette::Text));

   517                 o.format.setForeground(m_palette.brush(QPalette::Window));

   518             }

   519         }

   520         selections.append(o);

   521     }

   522 

   523     if (flags & DrawText)

   524         m_textLayout.draw(painter, offset, selections, clip);

   525 

   526     if (flags & DrawCursor){

   527         int cursor = m_cursor;

   528         if (m_preeditCursor != -1)

   529             cursor += m_preeditCursor;

   530         if(!m_blinkPeriod || m_blinkStatus)

   531             m_textLayout.drawCursor(painter, offset, cursor, m_cursorWidth);

   532     }

   533 }

   534 

   535 /*!

   536     \internal

   537 

   538     Sets the selection to cover the word at the given cursor position.

   539     The word boundries is defined by the behavior of QTextLayout::SkipWords

   540     cursor mode.

   541 */

   542 void QLineControl::selectWordAtPos(int cursor)

   543 {

   544     int c = m_textLayout.previousCursorPosition(cursor, QTextLayout::SkipWords);

   545     moveCursor(c, false);

   546     // ## text layout should support end of words.

   547     int end = m_textLayout.nextCursorPosition(cursor, QTextLayout::SkipWords);

   548     while (end > cursor && m_text[end-1].isSpace())

   549         --end;

   550     moveCursor(end, true);

   551 }

   552 

   553 /*!

   554     \internal

   555 

   556     Completes a change to the line control text.  If the change is not valid

   557     will undo the line control state back to the given \a validateFromState.

   558 

   559     If \a edited is true and the change is valid, will emit textEdited() in

   560     addition to textChanged().  Otherwise only emits textChanged() on a valid

   561     change.

   562 

   563     The \a update value is currently unused.

   564 */

   565 bool QLineControl::finishChange(int validateFromState, bool update, bool edited)

   566 {

   567     Q_UNUSED(update)

   568     bool lineDirty = m_selDirty;

   569     if (m_textDirty) {

   570         // do validation

   571         bool wasValidInput = m_validInput;

   572         m_validInput = true;

   573 #ifndef QT_NO_VALIDATOR

   574         if (m_validator) {

   575             m_validInput = false;

   576             QString textCopy = m_text;

   577             int cursorCopy = m_cursor;

   578             m_validInput = (m_validator->validate(textCopy, cursorCopy) != QValidator::Invalid);

   579             if (m_validInput) {

   580                 if (m_text != textCopy) {

   581                     internalSetText(textCopy, cursorCopy);

   582                     return true;

   583                 }

   584                 m_cursor = cursorCopy;

   585             }

   586         }

   587 #endif

   588         if (validateFromState >= 0 && wasValidInput && !m_validInput) {

   589             if (m_transactions.count())

   590                 return false;

   591             internalUndo(validateFromState);

   592             m_history.resize(m_undoState);

   593             if (m_modifiedState > m_undoState)

   594                 m_modifiedState = -1;

   595             m_validInput = true;

   596             m_textDirty = false;

   597         }

   598         updateDisplayText();

   599         lineDirty |= m_textDirty;

   600         if (m_textDirty) {

   601             m_textDirty = false;

   602             QString actualText = text();

   603             if (edited)

   604                 emit textEdited(actualText);

   605             emit textChanged(actualText);

   606         }

   607     }

   608     if (m_selDirty) {

   609         m_selDirty = false;

   610         emit selectionChanged();

   611     }

   612     emitCursorPositionChanged();

   613     return true;

   614 }

   615 

   616 /*!

   617     \internal

   618 

   619     An internal function for setting the text of the line control.

   620 */

   621 void QLineControl::internalSetText(const QString &txt, int pos, bool edited)

   622 {

   623     internalDeselect();

   624     emit resetInputContext();

   625     QString oldText = m_text;

   626     if (m_maskData) {

   627         m_text = maskString(0, txt, true);

   628         m_text += clearString(m_text.length(), m_maxLength - m_text.length());

   629     } else {

   630         m_text = txt.isEmpty() ? txt : txt.left(m_maxLength);

   631     }

   632     m_history.clear();

   633     m_modifiedState =  m_undoState = 0;

   634     m_cursor = (pos < 0 || pos > m_text.length()) ? m_text.length() : pos;

   635     m_textDirty = (oldText != m_text);

   636     finishChange(-1, true, edited);

   637 }

   638 

   639 

   640 /*!

   641     \internal

   642 

   643     Adds the given \a command to the undo history

   644     of the line control.  Does not apply the command.

   645 */

   646 void QLineControl::addCommand(const Command &cmd)

   647 {

   648     if (m_separator && m_undoState && m_history[m_undoState - 1].type != Separator) {

   649         m_history.resize(m_undoState + 2);

   650         m_history[m_undoState++] = Command(Separator, m_cursor, 0, m_selstart, m_selend);

   651     } else {

   652         m_history.resize(m_undoState + 1);

   653     }

   654     m_separator = false;

   655     m_history[m_undoState++] = cmd;

   656 }

   657 

   658 /*!

   659     \internal

   660 

   661     Inserts the given string \a s into the line

   662     control.

   663 

   664     Also adds the appropriate commands into the undo history.

   665     This function does not call finishChange(), and may leave the text

   666     in an invalid state.

   667 */

   668 void QLineControl::internalInsert(const QString &s)

   669 {

   670     if (hasSelectedText())

   671         addCommand(Command(SetSelection, m_cursor, 0, m_selstart, m_selend));

   672     if (m_maskData) {

   673         QString ms = maskString(m_cursor, s);

   674         for (int i = 0; i < (int) ms.length(); ++i) {

   675             addCommand (Command(DeleteSelection, m_cursor + i, m_text.at(m_cursor + i), -1, -1));

   676             addCommand(Command(Insert, m_cursor + i, ms.at(i), -1, -1));

   677         }

   678         m_text.replace(m_cursor, ms.length(), ms);

   679         m_cursor += ms.length();

   680         m_cursor = nextMaskBlank(m_cursor);

   681         m_textDirty = true;

   682     } else {

   683         int remaining = m_maxLength - m_text.length();

   684         if (remaining != 0) {

   685             m_text.insert(m_cursor, s.left(remaining));

   686             for (int i = 0; i < (int) s.left(remaining).length(); ++i)

   687                addCommand(Command(Insert, m_cursor++, s.at(i), -1, -1));

   688             m_textDirty = true;

   689         }

   690     }

   691 }

   692 

   693 /*!

   694     \internal

   695 

   696     deletes a single character from the current text.  If \a wasBackspace,

   697     the character prior to the cursor is removed.  Otherwise the character

   698     after the cursor is removed.

   699 

   700     Also adds the appropriate commands into the undo history.

   701     This function does not call finishChange(), and may leave the text

   702     in an invalid state.

   703 */

   704 void QLineControl::internalDelete(bool wasBackspace)

   705 {

   706     if (m_cursor < (int) m_text.length()) {

   707         if (hasSelectedText())

   708             addCommand(Command(SetSelection, m_cursor, 0, m_selstart, m_selend));

   709         addCommand(Command((CommandType)((m_maskData ? 2 : 0) + (wasBackspace ? Remove : Delete)),

   710                    m_cursor, m_text.at(m_cursor), -1, -1));

   711         if (m_maskData) {

   712             m_text.replace(m_cursor, 1, clearString(m_cursor, 1));

   713             addCommand(Command(Insert, m_cursor, m_text.at(m_cursor), -1, -1));

   714         } else {

   715             m_text.remove(m_cursor, 1);

   716         }

   717         m_textDirty = true;

   718     }

   719 }

   720 

   721 /*!

   722     \internal

   723 

   724     removes the currently selected text from the line control.

   725 

   726     Also adds the appropriate commands into the undo history.

   727     This function does not call finishChange(), and may leave the text

   728     in an invalid state.

   729 */

   730 void QLineControl::removeSelectedText()

   731 {

   732     if (m_selstart < m_selend && m_selend <= (int) m_text.length()) {

   733         separate();

   734         int i ;

   735         addCommand(Command(SetSelection, m_cursor, 0, m_selstart, m_selend));

   736         if (m_selstart <= m_cursor && m_cursor < m_selend) {

   737             // cursor is within the selection. Split up the commands

   738             // to be able to restore the correct cursor position

   739             for (i = m_cursor; i >= m_selstart; --i)

   740                 addCommand (Command(DeleteSelection, i, m_text.at(i), -1, 1));

   741             for (i = m_selend - 1; i > m_cursor; --i)

   742                 addCommand (Command(DeleteSelection, i - m_cursor + m_selstart - 1, m_text.at(i), -1, -1));

   743         } else {

   744             for (i = m_selend-1; i >= m_selstart; --i)

   745                 addCommand (Command(RemoveSelection, i, m_text.at(i), -1, -1));

   746         }

   747         if (m_maskData) {

   748             m_text.replace(m_selstart, m_selend - m_selstart,  clearString(m_selstart, m_selend - m_selstart));

   749             for (int i = 0; i < m_selend - m_selstart; ++i)

   750                 addCommand(Command(Insert, m_selstart + i, m_text.at(m_selstart + i), -1, -1));

   751         } else {

   752             m_text.remove(m_selstart, m_selend - m_selstart);

   753         }

   754         if (m_cursor > m_selstart)

   755             m_cursor -= qMin(m_cursor, m_selend) - m_selstart;

   756         internalDeselect();

   757         m_textDirty = true;

   758     }

   759 }

   760 

   761 /*!

   762     \internal

   763 

   764     Parses the input mask specified by \a maskFields to generate

   765     the mask data used to handle input masks.

   766 */

   767 void QLineControl::parseInputMask(const QString &maskFields)

   768 {

   769     int delimiter = maskFields.indexOf(QLatin1Char(';'));

   770     if (maskFields.isEmpty() || delimiter == 0) {

   771         if (m_maskData) {

   772             delete [] m_maskData;

   773             m_maskData = 0;

   774             m_maxLength = 32767;

   775             internalSetText(QString());

   776         }

   777         return;

   778     }

   779 

   780     if (delimiter == -1) {

   781         m_blank = QLatin1Char(' ');

   782         m_inputMask = maskFields;

   783     } else {

   784         m_inputMask = maskFields.left(delimiter);

   785         m_blank = (delimiter + 1 < maskFields.length()) ? maskFields[delimiter + 1] : QLatin1Char(' ');

   786     }

   787 

   788     // calculate m_maxLength / m_maskData length

   789     m_maxLength = 0;

   790     QChar c = 0;

   791     for (int i=0; i<m_inputMask.length(); i++) {

   792         c = m_inputMask.at(i);

   793         if (i > 0 && m_inputMask.at(i-1) == QLatin1Char('\\')) {

   794             m_maxLength++;

   795             continue;

   796         }

   797         if (c != QLatin1Char('\\') && c != QLatin1Char('!') &&

   798              c != QLatin1Char('<') && c != QLatin1Char('>') &&

   799              c != QLatin1Char('{') && c != QLatin1Char('}') &&

   800              c != QLatin1Char('[') && c != QLatin1Char(']'))

   801             m_maxLength++;

   802     }

   803 

   804     delete [] m_maskData;

   805     m_maskData = new MaskInputData[m_maxLength];

   806 

   807     MaskInputData::Casemode m = MaskInputData::NoCaseMode;

   808     c = 0;

   809     bool s;

   810     bool escape = false;

   811     int index = 0;

   812     for (int i = 0; i < m_inputMask.length(); i++) {

   813         c = m_inputMask.at(i);

   814         if (escape) {

   815             s = true;

   816             m_maskData[index].maskChar = c;

   817             m_maskData[index].separator = s;

   818             m_maskData[index].caseMode = m;

   819             index++;

   820             escape = false;

   821         } else if (c == QLatin1Char('<')) {

   822                 m = MaskInputData::Lower;

   823         } else if (c == QLatin1Char('>')) {

   824             m = MaskInputData::Upper;

   825         } else if (c == QLatin1Char('!')) {

   826             m = MaskInputData::NoCaseMode;

   827         } else if (c != QLatin1Char('{') && c != QLatin1Char('}') && c != QLatin1Char('[') && c != QLatin1Char(']')) {

   828             switch (c.unicode()) {

   829             case 'A':

   830             case 'a':

   831             case 'N':

   832             case 'n':

   833             case 'X':

   834             case 'x':

   835             case '9':

   836             case '0':

   837             case 'D':

   838             case 'd':

   839             case '#':

   840             case 'H':

   841             case 'h':

   842             case 'B':

   843             case 'b':

   844                 s = false;

   845                 break;

   846             case '\\':

   847                 escape = true;

   848             default:

   849                 s = true;

   850                 break;

   851             }

   852 

   853             if (!escape) {

   854                 m_maskData[index].maskChar = c;

   855                 m_maskData[index].separator = s;

   856                 m_maskData[index].caseMode = m;

   857                 index++;

   858             }

   859         }

   860     }

   861     internalSetText(m_text);

   862 }

   863 

   864 

   865 /*!

   866     \internal

   867 

   868     checks if the key is valid compared to the inputMask

   869 */

   870 bool QLineControl::isValidInput(QChar key, QChar mask) const

   871 {

   872     switch (mask.unicode()) {

   873     case 'A':

   874         if (key.isLetter())

   875             return true;

   876         break;

   877     case 'a':

   878         if (key.isLetter() || key == m_blank)

   879             return true;

   880         break;

   881     case 'N':

   882         if (key.isLetterOrNumber())

   883             return true;

   884         break;

   885     case 'n':

   886         if (key.isLetterOrNumber() || key == m_blank)

   887             return true;

   888         break;

   889     case 'X':

   890         if (key.isPrint())

   891             return true;

   892         break;

   893     case 'x':

   894         if (key.isPrint() || key == m_blank)

   895             return true;

   896         break;

   897     case '9':

   898         if (key.isNumber())

   899             return true;

   900         break;

   901     case '0':

   902         if (key.isNumber() || key == m_blank)

   903             return true;

   904         break;

   905     case 'D':

   906         if (key.isNumber() && key.digitValue() > 0)

   907             return true;

   908         break;

   909     case 'd':

   910         if ((key.isNumber() && key.digitValue() > 0) || key == m_blank)

   911             return true;

   912         break;

   913     case '#':

   914         if (key.isNumber() || key == QLatin1Char('+') || key == QLatin1Char('-') || key == m_blank)

   915             return true;

   916         break;

   917     case 'B':

   918         if (key == QLatin1Char('0') || key == QLatin1Char('1'))

   919             return true;

   920         break;

   921     case 'b':

   922         if (key == QLatin1Char('0') || key == QLatin1Char('1') || key == m_blank)

   923             return true;

   924         break;

   925     case 'H':

   926         if (key.isNumber() || (key >= QLatin1Char('a') && key <= QLatin1Char('f')) || (key >= QLatin1Char('A') && key <= QLatin1Char('F')))

   927             return true;

   928         break;

   929     case 'h':

   930         if (key.isNumber() || (key >= QLatin1Char('a') && key <= QLatin1Char('f')) || (key >= QLatin1Char('A') && key <= QLatin1Char('F')) || key == m_blank)

   931             return true;

   932         break;

   933     default:

   934         break;

   935     }

   936     return false;

   937 }

   938 

   939 /*!

   940     \internal

   941 

   942     Returns true if the given text \a str is valid for any

   943     validator or input mask set for the line control.

   944 

   945     Otherwise returns false

   946 */

   947 bool QLineControl::hasAcceptableInput(const QString &str) const

   948 {

   949 #ifndef QT_NO_VALIDATOR

   950     QString textCopy = str;

   951     int cursorCopy = m_cursor;

   952     if (m_validator && m_validator->validate(textCopy, cursorCopy)

   953         != QValidator::Acceptable)

   954         return false;

   955 #endif

   956 

   957     if (!m_maskData)

   958         return true;

   959 

   960     if (str.length() != m_maxLength)

   961         return false;

   962 

   963     for (int i=0; i < m_maxLength; ++i) {

   964         if (m_maskData[i].separator) {

   965             if (str.at(i) != m_maskData[i].maskChar)

   966                 return false;

   967         } else {

   968             if (!isValidInput(str.at(i), m_maskData[i].maskChar))

   969                 return false;

   970         }

   971     }

   972     return true;

   973 }

   974 

   975 /*!

   976     \internal

   977 

   978     Applies the inputMask on \a str starting from position \a pos in the mask. \a clear

   979     specifies from where characters should be gotten when a separator is met in \a str - true means

   980     that blanks will be used, false that previous input is used.

   981     Calling this when no inputMask is set is undefined.

   982 */

   983 QString QLineControl::maskString(uint pos, const QString &str, bool clear) const

   984 {

   985     if (pos >= (uint)m_maxLength)

   986         return QString::fromLatin1("");

   987 

   988     QString fill;

   989     fill = clear ? clearString(0, m_maxLength) : m_text;

   990 

   991     int strIndex = 0;

   992     QString s = QString::fromLatin1("");

   993     int i = pos;

   994     while (i < m_maxLength) {

   995         if (strIndex < str.length()) {

   996             if (m_maskData[i].separator) {

   997                 s += m_maskData[i].maskChar;

   998                 if (str[(int)strIndex] == m_maskData[i].maskChar)

   999                     strIndex++;

  1000                 ++i;

  1001             } else {

  1002                 if (isValidInput(str[(int)strIndex], m_maskData[i].maskChar)) {

  1003                     switch (m_maskData[i].caseMode) {

  1004                     case MaskInputData::Upper:

  1005                         s += str[(int)strIndex].toUpper();

  1006                         break;

  1007                     case MaskInputData::Lower:

  1008                         s += str[(int)strIndex].toLower();

  1009                         break;

  1010                     default:

  1011                         s += str[(int)strIndex];

  1012                     }

  1013                     ++i;

  1014                 } else {

  1015                     // search for separator first

  1016                     int n = findInMask(i, true, true, str[(int)strIndex]);

  1017                     if (n != -1) {

  1018                         if (str.length() != 1 || i == 0 || (i > 0 && (!m_maskData[i-1].separator || m_maskData[i-1].maskChar != str[(int)strIndex]))) {

  1019                             s += fill.mid(i, n-i+1);

  1020                             i = n + 1; // update i to find + 1

  1021                         }

  1022                     } else {

  1023                         // search for valid m_blank if not

  1024                         n = findInMask(i, true, false, str[(int)strIndex]);

  1025                         if (n != -1) {

  1026                             s += fill.mid(i, n-i);

  1027                             switch (m_maskData[n].caseMode) {

  1028                             case MaskInputData::Upper:

  1029                                 s += str[(int)strIndex].toUpper();

  1030                                 break;

  1031                             case MaskInputData::Lower:

  1032                                 s += str[(int)strIndex].toLower();

  1033                                 break;

  1034                             default:

  1035                                 s += str[(int)strIndex];

  1036                             }

  1037                             i = n + 1; // updates i to find + 1

  1038                         }

  1039                     }

  1040                 }

  1041                 ++strIndex;

  1042             }

  1043         } else

  1044             break;

  1045     }

  1046 

  1047     return s;

  1048 }

  1049 

  1050 

  1051 

  1052 /*!

  1053     \internal

  1054 

  1055     Returns a "cleared" string with only separators and blank chars.

  1056     Calling this when no inputMask is set is undefined.

  1057 */

  1058 QString QLineControl::clearString(uint pos, uint len) const

  1059 {

  1060     if (pos >= (uint)m_maxLength)

  1061         return QString();

  1062 

  1063     QString s;

  1064     int end = qMin((uint)m_maxLength, pos + len);

  1065     for (int i = pos; i < end; ++i)

  1066         if (m_maskData[i].separator)

  1067             s += m_maskData[i].maskChar;

  1068         else

  1069             s += m_blank;

  1070 

  1071     return s;

  1072 }

  1073 

  1074 /*!

  1075     \internal

  1076 

  1077     Strips blank parts of the input in a QLineControl when an inputMask is set,

  1078     separators are still included. Typically "127.0__.0__.1__" becomes "127.0.0.1".

  1079 */

  1080 QString QLineControl::stripString(const QString &str) const

  1081 {

  1082     if (!m_maskData)

  1083         return str;

  1084 

  1085     QString s;

  1086     int end = qMin(m_maxLength, (int)str.length());

  1087     for (int i = 0; i < end; ++i)

  1088         if (m_maskData[i].separator)

  1089             s += m_maskData[i].maskChar;

  1090         else

  1091             if (str[i] != m_blank)

  1092                 s += str[i];

  1093 

  1094     return s;

  1095 }

  1096 

  1097 /*!

  1098     \internal

  1099     searches forward/backward in m_maskData for either a separator or a m_blank

  1100 */

  1101 int QLineControl::findInMask(int pos, bool forward, bool findSeparator, QChar searchChar) const

  1102 {

  1103     if (pos >= m_maxLength || pos < 0)

  1104         return -1;

  1105 

  1106     int end = forward ? m_maxLength : -1;

  1107     int step = forward ? 1 : -1;

  1108     int i = pos;

  1109 

  1110     while (i != end) {

  1111         if (findSeparator) {

  1112             if (m_maskData[i].separator && m_maskData[i].maskChar == searchChar)

  1113                 return i;

  1114         } else {

  1115             if (!m_maskData[i].separator) {

  1116                 if (searchChar.isNull())

  1117                     return i;

  1118                 else if (isValidInput(searchChar, m_maskData[i].maskChar))

  1119                     return i;

  1120             }

  1121         }

  1122         i += step;

  1123     }

  1124     return -1;

  1125 }

  1126 

  1127 void QLineControl::internalUndo(int until)

  1128 {

  1129     if (!isUndoAvailable())

  1130         return;

  1131     internalDeselect();

  1132     while (m_undoState && m_undoState > until) {

  1133         Command& cmd = m_history[--m_undoState];

  1134         switch (cmd.type) {

  1135         case Insert: