[556] | 1 | /****************************************************************************
|
---|
| 2 | **
|
---|
[846] | 3 | ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
|
---|
[556] | 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 | ** Commercial Usage
|
---|
| 11 | ** Licensees holding valid Qt Commercial licenses may use this file in
|
---|
| 12 | ** accordance with the Qt Commercial License Agreement provided with the
|
---|
| 13 | ** Software or, alternatively, in accordance with the terms contained in
|
---|
| 14 | ** a written agreement between you and Nokia.
|
---|
| 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 | ** GNU General Public License Usage
|
---|
| 29 | ** Alternatively, this file may be used under the terms of the GNU
|
---|
| 30 | ** General Public License version 3.0 as published by the Free Software
|
---|
| 31 | ** Foundation and appearing in the file LICENSE.GPL included in the
|
---|
| 32 | ** packaging of this file. Please review the following information to
|
---|
| 33 | ** ensure the GNU General Public License version 3.0 requirements will be
|
---|
| 34 | ** met: http://www.gnu.org/copyleft/gpl.html.
|
---|
| 35 | **
|
---|
| 36 | ** If you have questions regarding the use of this file, please contact
|
---|
| 37 | ** Nokia at qt-info@nokia.com.
|
---|
| 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 | */
|
---|
[769] | 68 | void QLineControl::updateDisplayText(bool forceUpdate)
|
---|
[556] | 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 |
|
---|
[769] | 105 | if (str != orig || forceUpdate)
|
---|
[556] | 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 | */
|
---|
[846] | 139 | void QLineControl::paste(QClipboard::Mode clipboardMode)
|
---|
[556] | 140 | {
|
---|
[846] | 141 | QString clip = QApplication::clipboard()->text(clipboardMode);
|
---|
[556] | 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
|
---|
[846] | 422 | if (event->replacementStart() <= 0)
|
---|
[556] | 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);
|
---|
[769] | 479 | updateDisplayText(/*force*/ true);
|
---|
[556] | 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
|
---|
[651] | 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 | }
|
---|
[556] | 519 | }
|
---|
| 520 | selections.append(o);
|
---|
| 521 | }
|
---|
| 522 |
|
---|
| 523 | if (flags & DrawText)
|
---|
| 524 | m_textLayout.draw(painter, offset, selections, clip);
|
---|
| 525 |
|
---|
| 526 | if (flags & DrawCursor){
|
---|
[651] | 527 | int cursor = m_cursor;
|
---|
| 528 | if (m_preeditCursor != -1)
|
---|
| 529 | cursor += m_preeditCursor;
|
---|
[846] | 530 | if (!m_hideCursor && (!m_blinkPeriod || m_blinkStatus))
|
---|
[651] | 531 | m_textLayout.drawCursor(painter, offset, cursor, m_cursorWidth);
|
---|
[556] | 532 | }
|
---|
| 533 | }
|
---|
| 534 |
|
---|
| 535 | /*!
|
---|
| 536 | \internal
|
---|
| 537 |
|
---|
| 538 | Sets the selection to cover the word at the given cursor position.
|
---|
[846] | 539 | The word boundaries are defined by the behavior of QTextLayout::SkipWords
|
---|
[556] | 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:
|
---|
| 1136 | m_text.remove(cmd.pos, 1);
|
---|
| 1137 | m_cursor = cmd.pos;
|
---|
| 1138 | break;
|
---|
| 1139 | case SetSelection:
|
---|
| 1140 | m_selstart = cmd.selStart;
|
---|
| 1141 | m_selend = cmd.selEnd;
|
---|
| 1142 | m_cursor = cmd.pos;
|
---|
| 1143 | break;
|
---|
| 1144 | case Remove:
|
---|
| 1145 | case RemoveSelection:
|
---|
| 1146 | m_text.insert(cmd.pos, cmd.uc);
|
---|
| 1147 | m_cursor = cmd.pos + 1;
|
---|
| 1148 | break;
|
---|
| 1149 | case Delete:
|
---|
| 1150 | case DeleteSelection:
|
---|
| 1151 | m_text.insert(cmd.pos, cmd.uc);
|
---|
| 1152 | m_cursor = cmd.pos;
|
---|
| 1153 | break;
|
---|
| 1154 | case Separator:
|
---|
| 1155 | continue;
|
---|
| 1156 | }
|
---|
| 1157 | if (until < 0 && m_undoState) {
|
---|
| 1158 | Command& next = m_history[m_undoState-1];
|
---|
| 1159 | if (next.type != cmd.type && next.type < RemoveSelection
|
---|
| 1160 | && (cmd.type < RemoveSelection || next.type == Separator))
|
---|
| 1161 | break;
|
---|
| 1162 | }
|
---|
| 1163 | }
|
---|
| 1164 | m_textDirty = true;
|
---|
| 1165 | emitCursorPositionChanged();
|
---|
| 1166 | }
|
---|
| 1167 |
|
---|
| 1168 | void QLineControl::internalRedo()
|
---|
| 1169 | {
|
---|
| 1170 | if (!isRedoAvailable())
|
---|
| 1171 | return;
|
---|
| 1172 | internalDeselect();
|
---|
| 1173 | while (m_undoState < (int)m_history.size()) {
|
---|
| 1174 | Command& cmd = m_history[m_undoState++];
|
---|
| 1175 | switch (cmd.type) {
|
---|
| 1176 | case Insert:
|
---|
| 1177 | m_text.insert(cmd.pos, cmd.uc);
|
---|
| 1178 | m_cursor = cmd.pos + 1;
|
---|
| 1179 | break;
|
---|
| 1180 | case SetSelection:
|
---|
| 1181 | m_selstart = cmd.selStart;
|
---|
| 1182 | m_selend = cmd.selEnd;
|
---|
| 1183 | m_cursor = cmd.pos;
|
---|
| 1184 | break;
|
---|
| 1185 | case Remove:
|
---|
| 1186 | case Delete:
|
---|
| 1187 | case RemoveSelection:
|
---|
| 1188 | case DeleteSelection:
|
---|
| 1189 | m_text.remove(cmd.pos, 1);
|
---|
| 1190 | m_selstart = cmd.selStart;
|
---|
| 1191 | m_selend = cmd.selEnd;
|
---|
| 1192 | m_cursor = cmd.pos;
|
---|
| 1193 | break;
|
---|
| 1194 | case Separator:
|
---|
| 1195 | m_selstart = cmd.selStart;
|
---|
| 1196 | m_selend = cmd.selEnd;
|
---|
| 1197 | m_cursor = cmd.pos;
|
---|
| 1198 | break;
|
---|
| 1199 | }
|
---|
| 1200 | if (m_undoState < (int)m_history.size()) {
|
---|
| 1201 | Command& next = m_history[m_undoState];
|
---|
| 1202 | if (next.type != cmd.type && cmd.type < RemoveSelection && next.type != Separator
|
---|
| 1203 | && (next.type < RemoveSelection || cmd.type == Separator))
|
---|
| 1204 | break;
|
---|
| 1205 | }
|
---|
| 1206 | }
|
---|
| 1207 | m_textDirty = true;
|
---|
| 1208 | emitCursorPositionChanged();
|
---|
| 1209 | }
|
---|
| 1210 |
|
---|
| 1211 | /*!
|
---|
| 1212 | \internal
|
---|
| 1213 |
|
---|
[846] | 1214 | If the current cursor position differs from the last emitted cursor
|
---|
[556] | 1215 | position, emits cursorPositionChanged().
|
---|
| 1216 | */
|
---|
| 1217 | void QLineControl::emitCursorPositionChanged()
|
---|
| 1218 | {
|
---|
| 1219 | if (m_cursor != m_lastCursorPos) {
|
---|
| 1220 | const int oldLast = m_lastCursorPos;
|
---|
| 1221 | m_lastCursorPos = m_cursor;
|
---|
| 1222 | cursorPositionChanged(oldLast, m_cursor);
|
---|
| 1223 | }
|
---|
| 1224 | }
|
---|
| 1225 |
|
---|
| 1226 | #ifndef QT_NO_COMPLETER
|
---|
| 1227 | // iterating forward(dir=1)/backward(dir=-1) from the
|
---|
| 1228 | // current row based. dir=0 indicates a new completion prefix was set.
|
---|
| 1229 | bool QLineControl::advanceToEnabledItem(int dir)
|
---|
| 1230 | {
|
---|
| 1231 | int start = m_completer->currentRow();
|
---|
| 1232 | if (start == -1)
|
---|
| 1233 | return false;
|
---|
| 1234 | int i = start + dir;
|
---|
| 1235 | if (dir == 0) dir = 1;
|
---|
| 1236 | do {
|
---|
| 1237 | if (!m_completer->setCurrentRow(i)) {
|
---|
| 1238 | if (!m_completer->wrapAround())
|
---|
| 1239 | break;
|
---|
| 1240 | i = i > 0 ? 0 : m_completer->completionCount() - 1;
|
---|
| 1241 | } else {
|
---|
| 1242 | QModelIndex currentIndex = m_completer->currentIndex();
|
---|
| 1243 | if (m_completer->completionModel()->flags(currentIndex) & Qt::ItemIsEnabled)
|
---|
| 1244 | return true;
|
---|
| 1245 | i += dir;
|
---|
| 1246 | }
|
---|
| 1247 | } while (i != start);
|
---|
| 1248 |
|
---|
| 1249 | m_completer->setCurrentRow(start); // restore
|
---|
| 1250 | return false;
|
---|
| 1251 | }
|
---|
| 1252 |
|
---|
| 1253 | void QLineControl::complete(int key)
|
---|
| 1254 | {
|
---|
| 1255 | if (!m_completer || isReadOnly() || echoMode() != QLineEdit::Normal)
|
---|
| 1256 | return;
|
---|
| 1257 |
|
---|
| 1258 | QString text = this->text();
|
---|
| 1259 | if (m_completer->completionMode() == QCompleter::InlineCompletion) {
|
---|
| 1260 | if (key == Qt::Key_Backspace)
|
---|
| 1261 | return;
|
---|
| 1262 | int n = 0;
|
---|
| 1263 | if (key == Qt::Key_Up || key == Qt::Key_Down) {
|
---|
| 1264 | if (textAfterSelection().length())
|
---|
| 1265 | return;
|
---|
| 1266 | QString prefix = hasSelectedText() ? textBeforeSelection()
|
---|
| 1267 | : text;
|
---|
| 1268 | if (text.compare(m_completer->currentCompletion(), m_completer->caseSensitivity()) != 0
|
---|
| 1269 | || prefix.compare(m_completer->completionPrefix(), m_completer->caseSensitivity()) != 0) {
|
---|
| 1270 | m_completer->setCompletionPrefix(prefix);
|
---|
| 1271 | } else {
|
---|
| 1272 | n = (key == Qt::Key_Up) ? -1 : +1;
|
---|
| 1273 | }
|
---|
| 1274 | } else {
|
---|
| 1275 | m_completer->setCompletionPrefix(text);
|
---|
| 1276 | }
|
---|
| 1277 | if (!advanceToEnabledItem(n))
|
---|
| 1278 | return;
|
---|
| 1279 | } else {
|
---|
| 1280 | #ifndef QT_KEYPAD_NAVIGATION
|
---|
| 1281 | if (text.isEmpty()) {
|
---|
| 1282 | m_completer->popup()->hide();
|
---|
| 1283 | return;
|
---|
| 1284 | }
|
---|
| 1285 | #endif
|
---|
| 1286 | m_completer->setCompletionPrefix(text);
|
---|
| 1287 | }
|
---|
| 1288 |
|
---|
| 1289 | m_completer->complete();
|
---|
| 1290 | }
|
---|
| 1291 | #endif
|
---|
| 1292 |
|
---|
| 1293 | void QLineControl::setCursorBlinkPeriod(int msec)
|
---|
| 1294 | {
|
---|
| 1295 | if (msec == m_blinkPeriod)
|
---|
| 1296 | return;
|
---|
| 1297 | if (m_blinkTimer) {
|
---|
| 1298 | killTimer(m_blinkTimer);
|
---|
| 1299 | }
|
---|
| 1300 | if (msec) {
|
---|
| 1301 | m_blinkTimer = startTimer(msec / 2);
|
---|
| 1302 | m_blinkStatus = 1;
|
---|
| 1303 | } else {
|
---|
| 1304 | m_blinkTimer = 0;
|
---|
| 1305 | if (m_blinkStatus == 1)
|
---|
| 1306 | emit updateNeeded(inputMask().isEmpty() ? cursorRect() : QRect());
|
---|
| 1307 | }
|
---|
| 1308 | m_blinkPeriod = msec;
|
---|
| 1309 | }
|
---|
| 1310 |
|
---|
[846] | 1311 | void QLineControl::resetCursorBlinkTimer()
|
---|
| 1312 | {
|
---|
| 1313 | if (m_blinkPeriod == 0 || m_blinkTimer == 0)
|
---|
| 1314 | return;
|
---|
| 1315 | killTimer(m_blinkTimer);
|
---|
| 1316 | m_blinkTimer = startTimer(m_blinkPeriod / 2);
|
---|
| 1317 | m_blinkStatus = 1;
|
---|
| 1318 | }
|
---|
| 1319 |
|
---|
[556] | 1320 | void QLineControl::timerEvent(QTimerEvent *event)
|
---|
| 1321 | {
|
---|
| 1322 | if (event->timerId() == m_blinkTimer) {
|
---|
| 1323 | m_blinkStatus = !m_blinkStatus;
|
---|
| 1324 | emit updateNeeded(inputMask().isEmpty() ? cursorRect() : QRect());
|
---|
| 1325 | } else if (event->timerId() == m_deleteAllTimer) {
|
---|
| 1326 | killTimer(m_deleteAllTimer);
|
---|
| 1327 | m_deleteAllTimer = 0;
|
---|
| 1328 | clear();
|
---|
| 1329 | } else if (event->timerId() == m_tripleClickTimer) {
|
---|
| 1330 | killTimer(m_tripleClickTimer);
|
---|
| 1331 | m_tripleClickTimer = 0;
|
---|
| 1332 | }
|
---|
| 1333 | }
|
---|
| 1334 |
|
---|
| 1335 | bool QLineControl::processEvent(QEvent* ev)
|
---|
| 1336 | {
|
---|
| 1337 | #ifdef QT_KEYPAD_NAVIGATION
|
---|
| 1338 | if (QApplication::keypadNavigationEnabled()) {
|
---|
| 1339 | if ((ev->type() == QEvent::KeyPress) || (ev->type() == QEvent::KeyRelease)) {
|
---|
| 1340 | QKeyEvent *ke = (QKeyEvent *)ev;
|
---|
| 1341 | if (ke->key() == Qt::Key_Back) {
|
---|
| 1342 | if (ke->isAutoRepeat()) {
|
---|
| 1343 | // Swallow it. We don't want back keys running amok.
|
---|
| 1344 | ke->accept();
|
---|
| 1345 | return true;
|
---|
| 1346 | }
|
---|
| 1347 | if ((ev->type() == QEvent::KeyRelease)
|
---|
| 1348 | && !isReadOnly()
|
---|
| 1349 | && m_deleteAllTimer) {
|
---|
| 1350 | killTimer(m_deleteAllTimer);
|
---|
| 1351 | m_deleteAllTimer = 0;
|
---|
| 1352 | backspace();
|
---|
| 1353 | ke->accept();
|
---|
| 1354 | return true;
|
---|
| 1355 | }
|
---|
| 1356 | }
|
---|
| 1357 | }
|
---|
| 1358 | }
|
---|
| 1359 | #endif
|
---|
| 1360 | switch(ev->type()){
|
---|
| 1361 | #ifndef QT_NO_GRAPHICSVIEW
|
---|
[846] | 1362 | case QEvent::GraphicsSceneMouseDoubleClick:
|
---|
[556] | 1363 | case QEvent::GraphicsSceneMouseMove:
|
---|
| 1364 | case QEvent::GraphicsSceneMouseRelease:
|
---|
| 1365 | case QEvent::GraphicsSceneMousePress:{
|
---|
| 1366 | QGraphicsSceneMouseEvent *gvEv = static_cast<QGraphicsSceneMouseEvent*>(ev);
|
---|
| 1367 | QMouseEvent* mouse = new QMouseEvent(ev->type(),
|
---|
| 1368 | gvEv->pos().toPoint(), gvEv->button(), gvEv->buttons(), gvEv->modifiers());
|
---|
| 1369 | processMouseEvent(mouse); break;
|
---|
| 1370 | }
|
---|
| 1371 | #endif
|
---|
| 1372 | case QEvent::MouseButtonPress:
|
---|
| 1373 | case QEvent::MouseButtonRelease:
|
---|
| 1374 | case QEvent::MouseButtonDblClick:
|
---|
| 1375 | case QEvent::MouseMove:
|
---|
| 1376 | processMouseEvent(static_cast<QMouseEvent*>(ev)); break;
|
---|
| 1377 | case QEvent::KeyPress:
|
---|
| 1378 | case QEvent::KeyRelease:
|
---|
| 1379 | processKeyEvent(static_cast<QKeyEvent*>(ev)); break;
|
---|
| 1380 | case QEvent::InputMethod:
|
---|
| 1381 | processInputMethodEvent(static_cast<QInputMethodEvent*>(ev)); break;
|
---|
| 1382 | #ifndef QT_NO_SHORTCUT
|
---|
| 1383 | case QEvent::ShortcutOverride:{
|
---|
[769] | 1384 | if (isReadOnly())
|
---|
| 1385 | return false;
|
---|
[556] | 1386 | QKeyEvent* ke = static_cast<QKeyEvent*>(ev);
|
---|
| 1387 | if (ke == QKeySequence::Copy
|
---|
| 1388 | || ke == QKeySequence::Paste
|
---|
| 1389 | || ke == QKeySequence::Cut
|
---|
| 1390 | || ke == QKeySequence::Redo
|
---|
| 1391 | || ke == QKeySequence::Undo
|
---|
| 1392 | || ke == QKeySequence::MoveToNextWord
|
---|
| 1393 | || ke == QKeySequence::MoveToPreviousWord
|
---|
| 1394 | || ke == QKeySequence::MoveToStartOfDocument
|
---|
| 1395 | || ke == QKeySequence::MoveToEndOfDocument
|
---|
| 1396 | || ke == QKeySequence::SelectNextWord
|
---|
| 1397 | || ke == QKeySequence::SelectPreviousWord
|
---|
| 1398 | || ke == QKeySequence::SelectStartOfLine
|
---|
| 1399 | || ke == QKeySequence::SelectEndOfLine
|
---|
| 1400 | || ke == QKeySequence::SelectStartOfBlock
|
---|
| 1401 | || ke == QKeySequence::SelectEndOfBlock
|
---|
| 1402 | || ke == QKeySequence::SelectStartOfDocument
|
---|
| 1403 | || ke == QKeySequence::SelectAll
|
---|
| 1404 | || ke == QKeySequence::SelectEndOfDocument) {
|
---|
| 1405 | ke->accept();
|
---|
| 1406 | } else if (ke->modifiers() == Qt::NoModifier || ke->modifiers() == Qt::ShiftModifier
|
---|
| 1407 | || ke->modifiers() == Qt::KeypadModifier) {
|
---|
| 1408 | if (ke->key() < Qt::Key_Escape) {
|
---|
| 1409 | ke->accept();
|
---|
| 1410 | } else {
|
---|
| 1411 | switch (ke->key()) {
|
---|
| 1412 | case Qt::Key_Delete:
|
---|
| 1413 | case Qt::Key_Home:
|
---|
| 1414 | case Qt::Key_End:
|
---|
| 1415 | case Qt::Key_Backspace:
|
---|
| 1416 | case Qt::Key_Left:
|
---|
| 1417 | case Qt::Key_Right:
|
---|
| 1418 | ke->accept();
|
---|
| 1419 | default:
|
---|
| 1420 | break;
|
---|
| 1421 | }
|
---|
| 1422 | }
|
---|
| 1423 | }
|
---|
| 1424 | }
|
---|
| 1425 | #endif
|
---|
| 1426 | default:
|
---|
| 1427 | return false;
|
---|
| 1428 | }
|
---|
| 1429 | return true;
|
---|
| 1430 | }
|
---|
| 1431 |
|
---|
| 1432 | void QLineControl::processMouseEvent(QMouseEvent* ev)
|
---|
| 1433 | {
|
---|
| 1434 |
|
---|
| 1435 | switch (ev->type()) {
|
---|
| 1436 | case QEvent::GraphicsSceneMousePress:
|
---|
| 1437 | case QEvent::MouseButtonPress:{
|
---|
| 1438 | if (m_tripleClickTimer
|
---|
| 1439 | && (ev->pos() - m_tripleClick).manhattanLength()
|
---|
| 1440 | < QApplication::startDragDistance()) {
|
---|
| 1441 | selectAll();
|
---|
| 1442 | return;
|
---|
| 1443 | }
|
---|
| 1444 | if (ev->button() == Qt::RightButton)
|
---|
| 1445 | return;
|
---|
| 1446 |
|
---|
| 1447 | bool mark = ev->modifiers() & Qt::ShiftModifier;
|
---|
| 1448 | int cursor = xToPos(ev->pos().x());
|
---|
| 1449 | moveCursor(cursor, mark);
|
---|
| 1450 | break;
|
---|
| 1451 | }
|
---|
[846] | 1452 | case QEvent::GraphicsSceneMouseDoubleClick:
|
---|
[556] | 1453 | case QEvent::MouseButtonDblClick:
|
---|
| 1454 | if (ev->button() == Qt::LeftButton) {
|
---|
| 1455 | selectWordAtPos(xToPos(ev->pos().x()));
|
---|
| 1456 | if (m_tripleClickTimer)
|
---|
| 1457 | killTimer(m_tripleClickTimer);
|
---|
| 1458 | m_tripleClickTimer = startTimer(QApplication::doubleClickInterval());
|
---|
| 1459 | m_tripleClick = ev->pos();
|
---|
| 1460 | }
|
---|
| 1461 | break;
|
---|
| 1462 | case QEvent::GraphicsSceneMouseRelease:
|
---|
| 1463 | case QEvent::MouseButtonRelease:
|
---|
| 1464 | #ifndef QT_NO_CLIPBOARD
|
---|
| 1465 | if (QApplication::clipboard()->supportsSelection()) {
|
---|
| 1466 | if (ev->button() == Qt::LeftButton) {
|
---|
| 1467 | copy(QClipboard::Selection);
|
---|
| 1468 | } else if (!isReadOnly() && ev->button() == Qt::MidButton) {
|
---|
| 1469 | deselect();
|
---|
| 1470 | insert(QApplication::clipboard()->text(QClipboard::Selection));
|
---|
| 1471 | }
|
---|
| 1472 | }
|
---|
| 1473 | #endif
|
---|
| 1474 | break;
|
---|
| 1475 | case QEvent::GraphicsSceneMouseMove:
|
---|
| 1476 | case QEvent::MouseMove:
|
---|
| 1477 | if (ev->buttons() & Qt::LeftButton) {
|
---|
| 1478 | moveCursor(xToPos(ev->pos().x()), true);
|
---|
| 1479 | }
|
---|
| 1480 | break;
|
---|
| 1481 | default:
|
---|
| 1482 | break;
|
---|
| 1483 | }
|
---|
| 1484 | }
|
---|
| 1485 |
|
---|
| 1486 | void QLineControl::processKeyEvent(QKeyEvent* event)
|
---|
| 1487 | {
|
---|
| 1488 | bool inlineCompletionAccepted = false;
|
---|
| 1489 |
|
---|
| 1490 | #ifndef QT_NO_COMPLETER
|
---|
| 1491 | if (m_completer) {
|
---|
| 1492 | QCompleter::CompletionMode completionMode = m_completer->completionMode();
|
---|
| 1493 | if ((completionMode == QCompleter::PopupCompletion
|
---|
| 1494 | || completionMode == QCompleter::UnfilteredPopupCompletion)
|
---|
| 1495 | && m_completer->popup()
|
---|
| 1496 | && m_completer->popup()->isVisible()) {
|
---|
| 1497 | // The following keys are forwarded by the completer to the widget
|
---|
| 1498 | // Ignoring the events lets the completer provide suitable default behavior
|
---|
| 1499 | switch (event->key()) {
|
---|
| 1500 | case Qt::Key_Escape:
|
---|
| 1501 | event->ignore();
|
---|
| 1502 | return;
|
---|
| 1503 | case Qt::Key_Enter:
|
---|
| 1504 | case Qt::Key_Return:
|
---|
| 1505 | case Qt::Key_F4:
|
---|
| 1506 | #ifdef QT_KEYPAD_NAVIGATION
|
---|
| 1507 | case Qt::Key_Select:
|
---|
| 1508 | if (!QApplication::keypadNavigationEnabled())
|
---|
| 1509 | break;
|
---|
| 1510 | #endif
|
---|
| 1511 | m_completer->popup()->hide(); // just hide. will end up propagating to parent
|
---|
| 1512 | default:
|
---|
| 1513 | break; // normal key processing
|
---|
| 1514 | }
|
---|
| 1515 | } else if (completionMode == QCompleter::InlineCompletion) {
|
---|
| 1516 | switch (event->key()) {
|
---|
| 1517 | case Qt::Key_Enter:
|
---|
| 1518 | case Qt::Key_Return:
|
---|
| 1519 | case Qt::Key_F4:
|
---|
| 1520 | #ifdef QT_KEYPAD_NAVIGATION
|
---|
| 1521 | case Qt::Key_Select:
|
---|
| 1522 | if (!QApplication::keypadNavigationEnabled())
|
---|
| 1523 | break;
|
---|
| 1524 | #endif
|
---|
| 1525 | if (!m_completer->currentCompletion().isEmpty() && hasSelectedText()
|
---|
| 1526 | && textAfterSelection().isEmpty()) {
|
---|
| 1527 | setText(m_completer->currentCompletion());
|
---|
| 1528 | inlineCompletionAccepted = true;
|
---|
| 1529 | }
|
---|
| 1530 | default:
|
---|
| 1531 | break; // normal key processing
|
---|
| 1532 | }
|
---|
| 1533 | }
|
---|
| 1534 | }
|
---|
| 1535 | #endif // QT_NO_COMPLETER
|
---|
| 1536 |
|
---|
| 1537 | if (event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return) {
|
---|
| 1538 | if (hasAcceptableInput() || fixup()) {
|
---|
| 1539 | emit accepted();
|
---|
| 1540 | emit editingFinished();
|
---|
| 1541 | }
|
---|
| 1542 | if (inlineCompletionAccepted)
|
---|
| 1543 | event->accept();
|
---|
| 1544 | else
|
---|
| 1545 | event->ignore();
|
---|
| 1546 | return;
|
---|
| 1547 | }
|
---|
| 1548 |
|
---|
| 1549 | if (echoMode() == QLineEdit::PasswordEchoOnEdit
|
---|
| 1550 | && !passwordEchoEditing()
|
---|
| 1551 | && !isReadOnly()
|
---|
| 1552 | && !event->text().isEmpty()
|
---|
| 1553 | #ifdef QT_KEYPAD_NAVIGATION
|
---|
| 1554 | && event->key() != Qt::Key_Select
|
---|
| 1555 | && event->key() != Qt::Key_Up
|
---|
| 1556 | && event->key() != Qt::Key_Down
|
---|
| 1557 | && event->key() != Qt::Key_Back
|
---|
| 1558 | #endif
|
---|
| 1559 | && !(event->modifiers() & Qt::ControlModifier)) {
|
---|
| 1560 | // Clear the edit and reset to normal echo mode while editing; the
|
---|
| 1561 | // echo mode switches back when the edit loses focus
|
---|
| 1562 | // ### resets current content. dubious code; you can
|
---|
| 1563 | // navigate with keys up, down, back, and select(?), but if you press
|
---|
| 1564 | // "left" or "right" it clears?
|
---|
| 1565 | updatePasswordEchoEditing(true);
|
---|
| 1566 | clear();
|
---|
| 1567 | }
|
---|
| 1568 |
|
---|
| 1569 | bool unknown = false;
|
---|
| 1570 |
|
---|
| 1571 | if (false) {
|
---|
| 1572 | }
|
---|
| 1573 | #ifndef QT_NO_SHORTCUT
|
---|
| 1574 | else if (event == QKeySequence::Undo) {
|
---|
| 1575 | if (!isReadOnly())
|
---|
| 1576 | undo();
|
---|
| 1577 | }
|
---|
| 1578 | else if (event == QKeySequence::Redo) {
|
---|
| 1579 | if (!isReadOnly())
|
---|
| 1580 | redo();
|
---|
| 1581 | }
|
---|
| 1582 | else if (event == QKeySequence::SelectAll) {
|
---|
| 1583 | selectAll();
|
---|
| 1584 | }
|
---|
| 1585 | #ifndef QT_NO_CLIPBOARD
|
---|
| 1586 | else if (event == QKeySequence::Copy) {
|
---|
| 1587 | copy();
|
---|
| 1588 | }
|
---|
| 1589 | else if (event == QKeySequence::Paste) {
|
---|
[846] | 1590 | if (!isReadOnly()) {
|
---|
| 1591 | QClipboard::Mode mode = QClipboard::Clipboard;
|
---|
| 1592 | #ifdef Q_WS_X11
|
---|
| 1593 | if (event->modifiers() == (Qt::CTRL | Qt::SHIFT) && event->key() == Qt::Key_Insert)
|
---|
| 1594 | mode = QClipboard::Selection;
|
---|
| 1595 | #endif
|
---|
| 1596 | paste(mode);
|
---|
| 1597 | }
|
---|
[556] | 1598 | }
|
---|
| 1599 | else if (event == QKeySequence::Cut) {
|
---|
| 1600 | if (!isReadOnly()) {
|
---|
| 1601 | copy();
|
---|
| 1602 | del();
|
---|
| 1603 | }
|
---|
| 1604 | }
|
---|
| 1605 | else if (event == QKeySequence::DeleteEndOfLine) {
|
---|
| 1606 | if (!isReadOnly()) {
|
---|
| 1607 | setSelection(cursor(), end());
|
---|
| 1608 | copy();
|
---|
| 1609 | del();
|
---|
| 1610 | }
|
---|
| 1611 | }
|
---|
| 1612 | #endif //QT_NO_CLIPBOARD
|
---|
| 1613 | else if (event == QKeySequence::MoveToStartOfLine || event == QKeySequence::MoveToStartOfBlock) {
|
---|
| 1614 | home(0);
|
---|
| 1615 | }
|
---|
| 1616 | else if (event == QKeySequence::MoveToEndOfLine || event == QKeySequence::MoveToEndOfBlock) {
|
---|
| 1617 | end(0);
|
---|
| 1618 | }
|
---|
| 1619 | else if (event == QKeySequence::SelectStartOfLine || event == QKeySequence::SelectStartOfBlock) {
|
---|
| 1620 | home(1);
|
---|
| 1621 | }
|
---|
| 1622 | else if (event == QKeySequence::SelectEndOfLine || event == QKeySequence::SelectEndOfBlock) {
|
---|
| 1623 | end(1);
|
---|
| 1624 | }
|
---|
| 1625 | else if (event == QKeySequence::MoveToNextChar) {
|
---|
| 1626 | #if !defined(Q_WS_WIN) || defined(QT_NO_COMPLETER)
|
---|
| 1627 | if (hasSelectedText()) {
|
---|
| 1628 | #else
|
---|
| 1629 | if (hasSelectedText() && m_completer
|
---|
| 1630 | && m_completer->completionMode() == QCompleter::InlineCompletion) {
|
---|
| 1631 | #endif
|
---|
| 1632 | moveCursor(selectionEnd(), false);
|
---|
| 1633 | } else {
|
---|
| 1634 | cursorForward(0, layoutDirection() == Qt::LeftToRight ? 1 : -1);
|
---|
| 1635 | }
|
---|
| 1636 | }
|
---|
| 1637 | else if (event == QKeySequence::SelectNextChar) {
|
---|
| 1638 | cursorForward(1, layoutDirection() == Qt::LeftToRight ? 1 : -1);
|
---|
| 1639 | }
|
---|
| 1640 | else if (event == QKeySequence::MoveToPreviousChar) {
|
---|
| 1641 | #if !defined(Q_WS_WIN) || defined(QT_NO_COMPLETER)
|
---|
| 1642 | if (hasSelectedText()) {
|
---|
| 1643 | #else
|
---|
| 1644 | if (hasSelectedText() && m_completer
|
---|
| 1645 | && m_completer->completionMode() == QCompleter::InlineCompletion) {
|
---|
| 1646 | #endif
|
---|
| 1647 | moveCursor(selectionStart(), false);
|
---|
| 1648 | } else {
|
---|
| 1649 | cursorForward(0, layoutDirection() == Qt::LeftToRight ? -1 : 1);
|
---|
| 1650 | }
|
---|
| 1651 | }
|
---|
| 1652 | else if (event == QKeySequence::SelectPreviousChar) {
|
---|
| 1653 | cursorForward(1, layoutDirection() == Qt::LeftToRight ? -1 : 1);
|
---|
| 1654 | }
|
---|
| 1655 | else if (event == QKeySequence::MoveToNextWord) {
|
---|
| 1656 | if (echoMode() == QLineEdit::Normal)
|
---|
| 1657 | layoutDirection() == Qt::LeftToRight ? cursorWordForward(0) : cursorWordBackward(0);
|
---|
| 1658 | else
|
---|
| 1659 | layoutDirection() == Qt::LeftToRight ? end(0) : home(0);
|
---|
| 1660 | }
|
---|
| 1661 | else if (event == QKeySequence::MoveToPreviousWord) {
|
---|
| 1662 | if (echoMode() == QLineEdit::Normal)
|
---|
| 1663 | layoutDirection() == Qt::LeftToRight ? cursorWordBackward(0) : cursorWordForward(0);
|
---|
| 1664 | else if (!isReadOnly()) {
|
---|
| 1665 | layoutDirection() == Qt::LeftToRight ? home(0) : end(0);
|
---|
| 1666 | }
|
---|
| 1667 | }
|
---|
| 1668 | else if (event == QKeySequence::SelectNextWord) {
|
---|
| 1669 | if (echoMode() == QLineEdit::Normal)
|
---|
| 1670 | layoutDirection() == Qt::LeftToRight ? cursorWordForward(1) : cursorWordBackward(1);
|
---|
| 1671 | else
|
---|
| 1672 | layoutDirection() == Qt::LeftToRight ? end(1) : home(1);
|
---|
| 1673 | }
|
---|
| 1674 | else if (event == QKeySequence::SelectPreviousWord) {
|
---|
| 1675 | if (echoMode() == QLineEdit::Normal)
|
---|
| 1676 | layoutDirection() == Qt::LeftToRight ? cursorWordBackward(1) : cursorWordForward(1);
|
---|
| 1677 | else
|
---|
| 1678 | layoutDirection() == Qt::LeftToRight ? home(1) : end(1);
|
---|
| 1679 | }
|
---|
| 1680 | else if (event == QKeySequence::Delete) {
|
---|
| 1681 | if (!isReadOnly())
|
---|
| 1682 | del();
|
---|
| 1683 | }
|
---|
| 1684 | else if (event == QKeySequence::DeleteEndOfWord) {
|
---|
| 1685 | if (!isReadOnly()) {
|
---|
| 1686 | cursorWordForward(true);
|
---|
| 1687 | del();
|
---|
| 1688 | }
|
---|
| 1689 | }
|
---|
| 1690 | else if (event == QKeySequence::DeleteStartOfWord) {
|
---|
| 1691 | if (!isReadOnly()) {
|
---|
| 1692 | cursorWordBackward(true);
|
---|
| 1693 | del();
|
---|
| 1694 | }
|
---|
| 1695 | }
|
---|
| 1696 | #endif // QT_NO_SHORTCUT
|
---|
| 1697 | else {
|
---|
| 1698 | bool handled = false;
|
---|
| 1699 | #ifdef Q_WS_MAC
|
---|
| 1700 | if (event->key() == Qt::Key_Up || event->key() == Qt::Key_Down) {
|
---|
| 1701 | Qt::KeyboardModifiers myModifiers = (event->modifiers() & ~Qt::KeypadModifier);
|
---|
| 1702 | if (myModifiers & Qt::ShiftModifier) {
|
---|
| 1703 | if (myModifiers == (Qt::ControlModifier|Qt::ShiftModifier)
|
---|
| 1704 | || myModifiers == (Qt::AltModifier|Qt::ShiftModifier)
|
---|
| 1705 | || myModifiers == Qt::ShiftModifier) {
|
---|
| 1706 |
|
---|
| 1707 | event->key() == Qt::Key_Up ? home(1) : end(1);
|
---|
| 1708 | }
|
---|
| 1709 | } else {
|
---|
| 1710 | if ((myModifiers == Qt::ControlModifier
|
---|
| 1711 | || myModifiers == Qt::AltModifier
|
---|
| 1712 | || myModifiers == Qt::NoModifier)) {
|
---|
| 1713 | event->key() == Qt::Key_Up ? home(0) : end(0);
|
---|
| 1714 | }
|
---|
| 1715 | }
|
---|
| 1716 | handled = true;
|
---|
| 1717 | }
|
---|
| 1718 | #endif
|
---|
| 1719 | if (event->modifiers() & Qt::ControlModifier) {
|
---|
| 1720 | switch (event->key()) {
|
---|
| 1721 | case Qt::Key_Backspace:
|
---|
| 1722 | if (!isReadOnly()) {
|
---|
| 1723 | cursorWordBackward(true);
|
---|
| 1724 | del();
|
---|
| 1725 | }
|
---|
| 1726 | break;
|
---|
| 1727 | #ifndef QT_NO_COMPLETER
|
---|
| 1728 | case Qt::Key_Up:
|
---|
| 1729 | case Qt::Key_Down:
|
---|
| 1730 | complete(event->key());
|
---|
| 1731 | break;
|
---|
| 1732 | #endif
|
---|
| 1733 | #if defined(Q_WS_X11)
|
---|
| 1734 | case Qt::Key_E:
|
---|
| 1735 | end(0);
|
---|
| 1736 | break;
|
---|
| 1737 |
|
---|
| 1738 | case Qt::Key_U:
|
---|
| 1739 | if (!isReadOnly()) {
|
---|
| 1740 | setSelection(0, text().size());
|
---|
| 1741 | #ifndef QT_NO_CLIPBOARD
|
---|
| 1742 | copy();
|
---|
| 1743 | #endif
|
---|
| 1744 | del();
|
---|
| 1745 | }
|
---|
| 1746 | break;
|
---|
| 1747 | #endif
|
---|
| 1748 | default:
|
---|
| 1749 | if (!handled)
|
---|
| 1750 | unknown = true;
|
---|
| 1751 | }
|
---|
| 1752 | } else { // ### check for *no* modifier
|
---|
| 1753 | switch (event->key()) {
|
---|
| 1754 | case Qt::Key_Backspace:
|
---|
| 1755 | if (!isReadOnly()) {
|
---|
| 1756 | backspace();
|
---|
| 1757 | #ifndef QT_NO_COMPLETER
|
---|
| 1758 | complete(Qt::Key_Backspace);
|
---|
| 1759 | #endif
|
---|
| 1760 | }
|
---|
| 1761 | break;
|
---|
| 1762 | #ifdef QT_KEYPAD_NAVIGATION
|
---|
| 1763 | case Qt::Key_Back:
|
---|
| 1764 | if (QApplication::keypadNavigationEnabled() && !event->isAutoRepeat()
|
---|
| 1765 | && !isReadOnly()) {
|
---|
| 1766 | if (text().length() == 0) {
|
---|
| 1767 | setText(m_cancelText);
|
---|
| 1768 |
|
---|
| 1769 | if (passwordEchoEditing())
|
---|
| 1770 | updatePasswordEchoEditing(false);
|
---|
| 1771 |
|
---|
| 1772 | emit editFocusChange(false);
|
---|
| 1773 | } else if (!m_deleteAllTimer) {
|
---|
| 1774 | m_deleteAllTimer = startTimer(750);
|
---|
| 1775 | }
|
---|
| 1776 | } else {
|
---|
| 1777 | unknown = true;
|
---|
| 1778 | }
|
---|
| 1779 | break;
|
---|
| 1780 | #endif
|
---|
| 1781 | default:
|
---|
| 1782 | if (!handled)
|
---|
| 1783 | unknown = true;
|
---|
| 1784 | }
|
---|
| 1785 | }
|
---|
| 1786 | }
|
---|
| 1787 |
|
---|
| 1788 | if (event->key() == Qt::Key_Direction_L || event->key() == Qt::Key_Direction_R) {
|
---|
| 1789 | setLayoutDirection((event->key() == Qt::Key_Direction_L) ? Qt::LeftToRight : Qt::RightToLeft);
|
---|
| 1790 | unknown = false;
|
---|
| 1791 | }
|
---|
| 1792 |
|
---|
| 1793 | if (unknown && !isReadOnly()) {
|
---|
| 1794 | QString t = event->text();
|
---|
| 1795 | if (!t.isEmpty() && t.at(0).isPrint()) {
|
---|
| 1796 | insert(t);
|
---|
| 1797 | #ifndef QT_NO_COMPLETER
|
---|
| 1798 | complete(event->key());
|
---|
| 1799 | #endif
|
---|
| 1800 | event->accept();
|
---|
| 1801 | return;
|
---|
| 1802 | }
|
---|
| 1803 | }
|
---|
| 1804 |
|
---|
| 1805 | if (unknown)
|
---|
| 1806 | event->ignore();
|
---|
| 1807 | else
|
---|
| 1808 | event->accept();
|
---|
| 1809 | }
|
---|
| 1810 |
|
---|
| 1811 |
|
---|
| 1812 | QT_END_NAMESPACE
|
---|
| 1813 |
|
---|
| 1814 | #endif
|
---|