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 "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()

    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)

   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     insert(QApplication::clipboard()->text(QClipboard::Clipboard));

   142 }

   143 

   144 #endif // !QT_NO_CLIPBOARD

   145 

   146 /*!

   147     \internal

   148 

   149     Handles the behavior for the backspace key or function.

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

   151     removes the character prior to the cursor position.

   152 

   153     \sa del()

   154 */

   155 void QLineControl::backspace()

   156 {

   157     int priorState = m_undoState;

   158     if (hasSelectedText()) {

   159         removeSelectedText();

   160     } else if (m_cursor) {

   161             --m_cursor;

   162             if (m_maskData)

   163                 m_cursor = prevMaskBlank(m_cursor);

   164             QChar uc = m_text.at(m_cursor);

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

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

   167                 // if yes delete both at once

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

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

   170                     internalDelete(true);

   171                     --m_cursor;

   172                 }

   173             }

   174             internalDelete(true);

   175     }

   176     finishChange(priorState);

   177 }

   178 

   179 /*!

   180     \internal

   181 

   182     Handles the behavior for the delete key or function.

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

   184     removes the character after the cursor position.

   185 

   186     \sa del()

   187 */

   188 void QLineControl::del()

   189 {

   190     int priorState = m_undoState;

   191     if (hasSelectedText()) {

   192         removeSelectedText();

   193     } else {

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

   195         while (n--)

   196             internalDelete();

   197     }

   198     finishChange(priorState);

   199 }

   200 

   201 /*!

   202     \internal

   203 

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

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

   206     the new text.

   207 */

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

   209 {

   210     int priorState = m_undoState;

   211     removeSelectedText();

   212     internalInsert(newText);

   213     finishChange(priorState);

   214 }

   215 

   216 /*!

   217     \internal

   218 

   219     Clears the line control text.

   220 */

   221 void QLineControl::clear()

   222 {

   223     int priorState = m_undoState;

   224     m_selstart = 0;

   225     m_selend = m_text.length();

   226     removeSelectedText();

   227     separate();

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

   229 }

   230 

   231 /*!

   232     \internal

   233 

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

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

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

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

   238 */

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

   240 {

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

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

   243         return;

   244     }

   245 

   246     if (length > 0) {

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

   248             return;

   249         m_selstart = start;

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

   251         m_cursor = m_selend;

   252     } else {

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

   254             return;

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

   256         m_selend = start;

   257         m_cursor = m_selstart;

   258     }

   259     emit selectionChanged();

   260     emitCursorPositionChanged();

   261 }

   262 

   263 void QLineControl::_q_clipboardChanged()

   264 {

   265 }

   266 

   267 void QLineControl::_q_deleteSelected()

   268 {

   269     if (!hasSelectedText())

   270         return;

   271 

   272     int priorState = m_undoState;

   273     emit resetInputContext();

   274     removeSelectedText();

   275     separate();

   276     finishChange(priorState);

   277 }

   278 

   279 /*!

   280     \internal

   281 

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

   283 */

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

   285 {

   286     m_text = txt;

   287     updateDisplayText();

   288     m_cursor = m_text.length();

   289 }

   290 

   291 /*!

   292     \internal

   293 

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

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

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

   297     does not affect other echo modes.

   298 */

   299 void QLineControl::updatePasswordEchoEditing(bool editing)

   300 {

   301     m_passwordEchoEditing = editing;

   302     updateDisplayText();

   303 }

   304 

   305 /*!

   306     \internal

   307 

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

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

   310     of cursor position is requested.

   311 */

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

   313 {

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

   315 }

   316 

   317 /*!

   318     \internal

   319 

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

   321     between characters cursor.

   322 */

   323 QRect QLineControl::cursorRect() const

   324 {

   325     QTextLine l = m_textLayout.lineAt(0);

   326     int c = m_cursor;

   327     if (m_preeditCursor != -1)

   328         c += m_preeditCursor;

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

   330     int w = m_cursorWidth;

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

   332 

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

   334 }

   335 

   336 /*!

   337     \internal

   338 

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

   340 

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

   342 */

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

   344 {

   345 #ifndef QT_NO_VALIDATOR

   346     if (m_validator) {

   347         QString textCopy = m_text;

   348         int cursorCopy = m_cursor;

   349         m_validator->fixup(textCopy);

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

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

   352                 internalSetText(textCopy, cursorCopy);

   353             return true;

   354         }

   355     }

   356 #endif

   357     return false;

   358 }

   359 

   360 /*!

   361     \internal

   362 

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

   364     adjust the currently selected text.

   365 */

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

   367 {

   368     if (pos != m_cursor) {

   369         separate();

   370         if (m_maskData)

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

   372     }

   373     if (mark) {

   374         int anchor;

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

   376             anchor = m_selend;

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

   378             anchor = m_selstart;

   379         else

   380             anchor = m_cursor;

   381         m_selstart = qMin(anchor, pos);

   382         m_selend = qMax(anchor, pos);

   383         updateDisplayText();

   384     } else {

   385         internalDeselect();

   386     }

   387     m_cursor = pos;

   388     if (mark || m_selDirty) {

   389         m_selDirty = false;

   390         emit selectionChanged();

   391     }

   392     emitCursorPositionChanged();

   393 }

   394 

   395 /*!

   396     \internal

   397 

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

   399     control

   400 */

   401 void QLineControl::processInputMethodEvent(QInputMethodEvent *event)

   402 {

   403     int priorState = 0;

   404     bool isGettingInput = !event->commitString().isEmpty() || !event->preeditString().isEmpty()

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

   406     bool cursorPositionChanged = false;

   407 

   408     if (isGettingInput) {

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

   410         priorState = m_undoState;

   411         removeSelectedText();

   412     }

   413 

   414 

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

   416     if (event->replacementStart() <= 0)

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

   418 

   419     m_cursor += event->replacementStart();

   420 

   421     // insert commit string

   422     if (event->replacementLength()) {

   423         m_selstart = m_cursor;

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

   425         removeSelectedText();

   426     }

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

   428         insert(event->commitString());

   429         cursorPositionChanged = true;

   430     }

   431 

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

   433 

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

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

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

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

   438             if (a.length) {

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

   440                 m_selend = m_cursor;

   441                 if (m_selend < m_selstart) {

   442                     qSwap(m_selstart, m_selend);

   443                 }

   444             } else {

   445                 m_selstart = m_selend = 0;

   446             }

   447             cursorPositionChanged = true;

   448         }

   449     }

   450 

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

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

   453     m_hideCursor = false;

   454     QList<QTextLayout::FormatRange> formats;

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

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

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

   458             m_preeditCursor = a.start;

   459             m_hideCursor = !a.length;

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

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

   462             if (f.isValid()) {

   463                 QTextLayout::FormatRange o;

   464                 o.start = a.start + m_cursor;

   465                 o.length = a.length;

   466                 o.format = f;

   467                 formats.append(o);

   468             }

   469         }

   470     }

   471     m_textLayout.setAdditionalFormats(formats);

   472     updateDisplayText();

   473     if (cursorPositionChanged)

   474         emitCursorPositionChanged();

   475     if (isGettingInput)

   476         finishChange(priorState);

   477 }

   478 

   479 /*!

   480     \internal

   481 

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

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

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

   485 

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

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

   488 

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

   490     will be drawn after drawing the text.

   491 

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

   493 */

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

   495 {

   496     QVector<QTextLayout::FormatRange> selections;

   497     if (flags & DrawSelections) {

   498         QTextLayout::FormatRange o;

   499         if (m_selstart < m_selend) {

   500             o.start = m_selstart;

   501             o.length = m_selend - m_selstart;

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

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

   504         } else {

   505             // mask selection

   506             o.start = m_cursor;

   507             o.length = 1;

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

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

   510         }

   511         selections.append(o);

   512     }

   513 

   514     if (flags & DrawText)

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

   516 

   517     if (flags & DrawCursor){

   518         if(!m_blinkPeriod || m_blinkStatus)

   519             m_textLayout.drawCursor(painter, offset, m_cursor, m_cursorWidth);

   520     }

   521 }

   522 

   523 /*!

   524     \internal

   525 

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

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

   528     cursor mode.

   529 */

   530 void QLineControl::selectWordAtPos(int cursor)

   531 {

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

   533     moveCursor(c, false);

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

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

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

   537         --end;

   538     moveCursor(end, true);

   539 }

   540 

   541 /*!

   542     \internal

   543 

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

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

   546 

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

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

   549     change.

   550 

   551     The \a update value is currently unused.

   552 */

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

   554 {

   555     Q_UNUSED(update)

   556     bool lineDirty = m_selDirty;

   557     if (m_textDirty) {

   558         // do validation

   559         bool wasValidInput = m_validInput;

   560         m_validInput = true;

   561 #ifndef QT_NO_VALIDATOR

   562         if (m_validator) {

   563             m_validInput = false;

   564             QString textCopy = m_text;

   565             int cursorCopy = m_cursor;

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

   567             if (m_validInput) {

   568                 if (m_text != textCopy) {

   569                     internalSetText(textCopy, cursorCopy);

   570                     return true;

   571                 }

   572                 m_cursor = cursorCopy;

   573             }

   574         }

   575 #endif

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

   577             if (m_transactions.count())

   578                 return false;

   579             internalUndo(validateFromState);

   580             m_history.resize(m_undoState);

   581             if (m_modifiedState > m_undoState)

   582                 m_modifiedState = -1;

   583             m_validInput = true;

   584             m_textDirty = false;

   585         }

   586         updateDisplayText();

   587         lineDirty |= m_textDirty;

   588         if (m_textDirty) {

   589             m_textDirty = false;

   590             QString actualText = text();

   591             if (edited)

   592                 emit textEdited(actualText);

   593             emit textChanged(actualText);

   594         }

   595     }

   596     if (m_selDirty) {

   597         m_selDirty = false;

   598         emit selectionChanged();

   599     }

   600     emitCursorPositionChanged();

   601     return true;

   602 }

   603 

   604 /*!

   605     \internal

   606 

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

   608 */

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

   610 {

   611     internalDeselect();

   612     emit resetInputContext();

   613     QString oldText = m_text;

   614     if (m_maskData) {

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

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

   617     } else {

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

   619     }

   620     m_history.clear();

   621     m_modifiedState =  m_undoState = 0;

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

   623     m_textDirty = (oldText != m_text);

   624     finishChange(-1, true, edited);

   625 }

   626 

   627 

   628 /*!

   629     \internal

   630 

   631     Adds the given \a command to the undo history

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

   633 */

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

   635 {

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

   637         m_history.resize(m_undoState + 2);

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

   639     } else {

   640         m_history.resize(m_undoState + 1);

   641     }

   642     m_separator = false;

   643     m_history[m_undoState++] = cmd;

   644 }

   645 

   646 /*!

   647     \internal

   648 

   649     Inserts the given string \a s into the line

   650     control.

   651 

   652     Also adds the appropriate commands into the undo history.

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

   654     in an invalid state.

   655 */

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

   657 {

   658     if (hasSelectedText())

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

   660     if (m_maskData) {

   661         QString ms = maskString(m_cursor, s);

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

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

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

   665         }

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

   667         m_cursor += ms.length();

   668         m_cursor = nextMaskBlank(m_cursor);

   669         m_textDirty = true;

   670     } else {

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

   672         if (remaining != 0) {

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

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

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

   676             m_textDirty = true;

   677         }

   678     }

   679 }

   680 

   681 /*!

   682     \internal

   683 

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

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

   686     after the cursor is removed.

   687 

   688     Also adds the appropriate commands into the undo history.

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

   690     in an invalid state.

   691 */

   692 void QLineControl::internalDelete(bool wasBackspace)

   693 {

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

   695         if (hasSelectedText())

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

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

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

   699         if (m_maskData) {

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

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

   702         } else {

   703             m_text.remove(m_cursor, 1);

   704         }

   705         m_textDirty = true;

   706     }

   707 }

   708 

   709 /*!

   710     \internal

   711 

   712     removes the currently selected text from the line control.

   713 

   714     Also adds the appropriate commands into the undo history.

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

   716     in an invalid state.

   717 */

   718 void QLineControl::removeSelectedText()

   719 {

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

   721         separate();

   722         int i ;

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

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

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

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

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

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

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

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

   731         } else {

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

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

   734         }

   735         if (m_maskData) {

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

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

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

   739         } else {

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

   741         }

   742         if (m_cursor > m_selstart)

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

   744         internalDeselect();

   745         m_textDirty = true;

   746     }

   747 }

   748 

   749 /*!

   750     \internal

   751 

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

   753     the mask data used to handle input masks.

   754 */

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

   756 {

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

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

   759         if (m_maskData) {

   760             delete [] m_maskData;

   761             m_maskData = 0;

   762             m_maxLength = 32767;

   763             internalSetText(QString());

   764         }

   765         return;

   766     }

   767 

   768     if (delimiter == -1) {

   769         m_blank = QLatin1Char(' ');

   770         m_inputMask = maskFields;

   771     } else {

   772         m_inputMask = maskFields.left(delimiter);

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

   774     }

   775 

   776     // calculate m_maxLength / m_maskData length

   777     m_maxLength = 0;

   778     QChar c = 0;

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

   780         c = m_inputMask.at(i);

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

   782             m_maxLength++;

   783             continue;

   784         }

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

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

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

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

   789             m_maxLength++;

   790     }

   791 

   792     delete [] m_maskData;

   793     m_maskData = new MaskInputData[m_maxLength];

   794 

   795     MaskInputData::Casemode m = MaskInputData::NoCaseMode;

   796     c = 0;

   797     bool s;

   798     bool escape = false;

   799     int index = 0;

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

   801         c = m_inputMask.at(i);

   802         if (escape) {

   803             s = true;

   804             m_maskData[index].maskChar = c;

   805             m_maskData[index].separator = s;

   806             m_maskData[index].caseMode = m;

   807             index++;

   808             escape = false;

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

   810                 m = MaskInputData::Lower;

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

   812             m = MaskInputData::Upper;

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

   814             m = MaskInputData::NoCaseMode;

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

   816             switch (c.unicode()) {

   817             case 'A':

   818             case 'a':

   819             case 'N':

   820             case 'n':

   821             case 'X':

   822             case 'x':

   823             case '9':

   824             case '0':

   825             case 'D':

   826             case 'd':

   827             case '#':

   828             case 'H':

   829             case 'h':

   830             case 'B':

   831             case 'b':

   832                 s = false;

   833                 break;

   834             case '\\':

   835                 escape = true;

   836             default:

   837                 s = true;

   838                 break;

   839             }

   840 

   841             if (!escape) {

   842                 m_maskData[index].maskChar = c;

   843                 m_maskData[index].separator = s;

   844                 m_maskData[index].caseMode = m;

   845                 index++;

   846             }

   847         }

   848     }

   849     internalSetText(m_text);

   850 }

   851 

   852 

   853 /*!

   854     \internal

   855 

   856     checks if the key is valid compared to the inputMask

   857 */

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

   859 {

   860     switch (mask.unicode()) {

   861     case 'A':

   862         if (key.isLetter())

   863             return true;

   864         break;

   865     case 'a':

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

   867             return true;

   868         break;

   869     case 'N':

   870         if (key.isLetterOrNumber())

   871             return true;

   872         break;

   873     case 'n':

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

   875             return true;

   876         break;

   877     case 'X':

   878         if (key.isPrint())

   879             return true;

   880         break;

   881     case 'x':

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

   883             return true;

   884         break;

   885     case '9':

   886         if (key.isNumber())

   887             return true;

   888         break;

   889     case '0':

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

   891             return true;

   892         break;

   893     case 'D':

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

   895             return true;

   896         break;

   897     case 'd':

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

   899             return true;

   900         break;

   901     case '#':

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

   903             return true;

   904         break;

   905     case 'B':

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

   907             return true;

   908         break;

   909     case 'b':

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

   911             return true;

   912         break;

   913     case 'H':

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

   915             return true;

   916         break;

   917     case 'h':

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

   919             return true;

   920         break;

   921     default:

   922         break;

   923     }

   924     return false;

   925 }

   926 

   927 /*!

   928     \internal

   929 

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

   931     validator or input mask set for the line control.

   932 

   933     Otherwise returns false

   934 */

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

   936 {

   937 #ifndef QT_NO_VALIDATOR

   938     QString textCopy = str;

   939     int cursorCopy = m_cursor;

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

   941         != QValidator::Acceptable)

   942         return false;

   943 #endif

   944 

   945     if (!m_maskData)

   946         return true;

   947 

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

   949         return false;

   950 

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

   952         if (m_maskData[i].separator) {

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

   954                 return false;

   955         } else {

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

   957                 return false;

   958         }

   959     }

   960     return true;

   961 }

   962 

   963 /*!

   964     \internal

   965 

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

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

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

   969     Calling this when no inputMask is set is undefined.

   970 */

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

   972 {

   973     if (pos >= (uint)m_maxLength)

   974         return QString::fromLatin1("");

   975 

   976     QString fill;

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

   978 

   979     int strIndex = 0;

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

   981     int i = pos;

   982     while (i < m_maxLength) {

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

   984             if (m_maskData[i].separator) {

   985                 s += m_maskData[i].maskChar;

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

   987                     strIndex++;

   988                 ++i;

   989             } else {

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

   991                     switch (m_maskData[i].caseMode) {

   992                     case MaskInputData::Upper:

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

   994                         break;

   995                     case MaskInputData::Lower:

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

   997                         break;

   998                     default:

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

  1000                     }

  1001                     ++i;

  1002                 } else {

  1003                     // search for separator first

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

  1005                     if (n != -1) {

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

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

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

  1009                         }

  1010                     } else {

  1011                         // search for valid m_blank if not

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

  1013                         if (n != -1) {

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

  1015                             switch (m_maskData[n].caseMode) {

  1016                             case MaskInputData::Upper:

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

  1018                                 break;

  1019                             case MaskInputData::Lower:

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

  1021                                 break;

  1022                             default:

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

  1024                             }

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

  1026                         }

  1027                     }

  1028                 }

  1029                 ++strIndex;

  1030             }

  1031         } else

  1032             break;

  1033     }

  1034 

  1035     return s;

  1036 }

  1037 

  1038 

  1039 

  1040 /*!

  1041     \internal

  1042 

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

  1044     Calling this when no inputMask is set is undefined.

  1045 */

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

  1047 {

  1048     if (pos >= (uint)m_maxLength)

  1049         return QString();

  1050 

  1051     QString s;

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

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

  1054         if (m_maskData[i].separator)

  1055             s += m_maskData[i].maskChar;

  1056         else

  1057             s += m_blank;

  1058 

  1059     return s;

  1060 }

  1061 

  1062 /*!

  1063     \internal

  1064 

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

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

  1067 */

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

  1069 {

  1070     if (!m_maskData)

  1071         return str;

  1072 

  1073     QString s;

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

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

  1076         if (m_maskData[i].separator)

  1077             s += m_maskData[i].maskChar;

  1078         else

  1079             if (str[i] != m_blank)

  1080                 s += str[i];

  1081 

  1082     return s;

  1083 }

  1084 

  1085 /*!

  1086     \internal

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

  1088 */

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

  1090 {

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

  1092         return -1;

  1093 

  1094     int end = forward ? m_maxLength : -1;

  1095     int step = forward ? 1 : -1;

  1096     int i = pos;

  1097 

  1098     while (i != end) {

  1099         if (findSeparator) {

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

  1101                 return i;

  1102         } else {

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

  1104                 if (searchChar.isNull())

  1105                     return i;

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

  1107                     return i;

  1108             }

  1109         }

  1110         i += step;

  1111     }

  1112     return -1;

  1113 }

  1114 

  1115 void QLineControl::internalUndo(int until)

  1116 {

  1117     if (!isUndoAvailable())

  1118         return;

  1119     internalDeselect();

  1120     while (m_undoState && m_undoState > until) {

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

  1122         switch (cmd.type) {

  1123         case Insert:

  1124             m_text.remove(cmd.pos, 1);

  1125             m_cursor = cmd.pos;

  1126             break;

  1127         case SetSelection:

  1128             m_selstart = cmd.selStart;

  1129             m_selend = cmd.selEnd;

  1130             m_cursor = cmd.pos;

  1131             break;

  1132         case Remove:

  1133         case RemoveSelection:

  1134             m_text.insert(cmd.pos, cmd.uc);