diff options
Diffstat (limited to 'src/designer/src/lib/shared/textpropertyeditor.cpp')
| -rw-r--r-- | src/designer/src/lib/shared/textpropertyeditor.cpp | 430 |
1 files changed, 430 insertions, 0 deletions
diff --git a/src/designer/src/lib/shared/textpropertyeditor.cpp b/src/designer/src/lib/shared/textpropertyeditor.cpp new file mode 100644 index 000000000..bc6cbeac7 --- /dev/null +++ b/src/designer/src/lib/shared/textpropertyeditor.cpp @@ -0,0 +1,430 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "textpropertyeditor_p.h" +#include "propertylineedit_p.h" +#include "stylesheeteditor_p.h" + +#include <QtGui/QLineEdit> +#include <QtGui/QRegExpValidator> +#include <QtGui/QResizeEvent> +#include <QtGui/QCompleter> +#include <QtGui/QAbstractItemView> +#include <QtCore/QRegExp> +#include <QtCore/QUrl> +#include <QtCore/QFile> +#include <QtCore/QDebug> + +QT_BEGIN_NAMESPACE + +namespace { + const QChar NewLineChar(QLatin1Char('\n')); + const QLatin1String EscapedNewLine("\\n"); + + // A validator that replaces offending strings + class ReplacementValidator : public QValidator { + public: + ReplacementValidator (QObject * parent, + const QString &offending, + const QString &replacement); + virtual void fixup ( QString & input ) const; + virtual State validate ( QString & input, int &pos) const; + private: + const QString m_offending; + const QString m_replacement; + }; + + ReplacementValidator::ReplacementValidator (QObject * parent, + const QString &offending, + const QString &replacement) : + QValidator(parent ), + m_offending(offending), + m_replacement(replacement) + { + } + + void ReplacementValidator::fixup ( QString & input ) const { + input.replace(m_offending, m_replacement); + } + + QValidator::State ReplacementValidator::validate ( QString & input, int &/* pos */) const { + fixup (input); + return Acceptable; + } + + // A validator for style sheets. Does newline handling and validates sheets. + class StyleSheetValidator : public ReplacementValidator { + public: + StyleSheetValidator (QObject * parent); + virtual State validate(QString & input, int &pos) const; + }; + + StyleSheetValidator::StyleSheetValidator (QObject * parent) : + ReplacementValidator(parent, NewLineChar, EscapedNewLine) + { + } + + QValidator::State StyleSheetValidator::validate ( QString & input, int &pos) const + { + // base class + const State state = ReplacementValidator:: validate(input, pos); + if (state != Acceptable) + return state; + // now check style sheet, create string with newlines + const QString styleSheet = qdesigner_internal::TextPropertyEditor::editorStringToString(input, qdesigner_internal::ValidationStyleSheet); + const bool valid = qdesigner_internal::StyleSheetEditorDialog::isStyleSheetValid(styleSheet); + return valid ? Acceptable : Intermediate; + } + + // A validator for URLs based on QUrl. Enforces complete protocol + // specification with a completer (adds a trailing slash) + class UrlValidator : public QValidator { + public: + UrlValidator(QCompleter *completer, QObject *parent); + + virtual State validate(QString &input, int &pos) const; + virtual void fixup(QString &input) const; + private: + QUrl guessUrlFromString(const QString &string) const; + QCompleter *m_completer; + }; + + UrlValidator::UrlValidator(QCompleter *completer, QObject *parent) : + QValidator(parent), + m_completer(completer) + { + } + + QValidator::State UrlValidator::validate(QString &input, int &pos) const + { + Q_UNUSED(pos); + + if (input.isEmpty()) + return Acceptable; + + const QUrl url(input, QUrl::StrictMode); + + if (!url.isValid() || url.isEmpty()) + return Intermediate; + + if (url.scheme().isEmpty()) + return Intermediate; + + if (url.host().isEmpty() && url.path().isEmpty()) + return Intermediate; + + return Acceptable; + } + + void UrlValidator::fixup(QString &input) const + { + // Don't try to fixup if the user is busy selecting a completion proposal + if (const QAbstractItemView *iv = m_completer->popup()) { + if (iv->isVisible()) + return; + } + + input = guessUrlFromString(input).toString(); + } + + QUrl UrlValidator::guessUrlFromString(const QString &string) const + { + const QString urlStr = string.trimmed(); + const QRegExp qualifiedUrl(QLatin1String("^[a-zA-Z]+\\:.*")); + + // Check if it looks like a qualified URL. Try parsing it and see. + const bool hasSchema = qualifiedUrl.exactMatch(urlStr); + if (hasSchema) { + const QUrl url(urlStr, QUrl::TolerantMode); + if (url.isValid()) + return url; + } + + // Might be a Qt resource + if (string.startsWith(QLatin1String(":/"))) + return QUrl(QLatin1String("qrc") + string); + + // Might be a file. + if (QFile::exists(urlStr)) + return QUrl::fromLocalFile(urlStr); + + // Might be a short url - try to detect the schema. + if (!hasSchema) { + const int dotIndex = urlStr.indexOf(QLatin1Char('.')); + if (dotIndex != -1) { + const QString prefix = urlStr.left(dotIndex).toLower(); + QString urlString; + if (prefix == QLatin1String("ftp")) + urlString += prefix; + else + urlString += QLatin1String("http"); + urlString += QLatin1String("://"); + urlString += urlStr; + const QUrl url(urlString, QUrl::TolerantMode); + if (url.isValid()) + return url; + } + } + + // Fall back to QUrl's own tolerant parser. + return QUrl(string, QUrl::TolerantMode); + } +} + +namespace qdesigner_internal { + // TextPropertyEditor + TextPropertyEditor::TextPropertyEditor(QWidget *parent, + EmbeddingMode embeddingMode, + TextPropertyValidationMode validationMode) : + QWidget(parent), + m_validationMode(ValidationSingleLine), + m_updateMode(UpdateAsYouType), + m_lineEdit(new PropertyLineEdit(this)), + m_textEdited(false) + { + switch (embeddingMode) { + case EmbeddingNone: + break; + case EmbeddingTreeView: + m_lineEdit->setFrame(false); + break; + case EmbeddingInPlace: + m_lineEdit->setFrame(false); + Q_ASSERT(parent); + m_lineEdit->setBackgroundRole(parent->backgroundRole()); + break; + } + + setFocusProxy(m_lineEdit); + + connect(m_lineEdit,SIGNAL(editingFinished()), this, SIGNAL(editingFinished())); + connect(m_lineEdit,SIGNAL(returnPressed()), this, SLOT(slotEditingFinished())); + connect(m_lineEdit,SIGNAL(textChanged(QString)), this, SLOT(slotTextChanged(QString))); + connect(m_lineEdit,SIGNAL(textEdited(QString)), this, SLOT(slotTextEdited())); + + setTextPropertyValidationMode(validationMode); + } + + void TextPropertyEditor::setTextPropertyValidationMode(TextPropertyValidationMode vm) { + m_validationMode = vm; + m_lineEdit->setWantNewLine(multiLine(m_validationMode)); + switch (m_validationMode) { + case ValidationStyleSheet: + m_lineEdit->setValidator(new StyleSheetValidator(m_lineEdit)); + m_lineEdit->setCompleter(0); + break; + case ValidationMultiLine: + case ValidationRichText: + // Set a validator that replaces newline characters by literal "\\n". + // While it is not possible to actually type a newline characters, + // it can be pasted into the line edit. + m_lineEdit->setValidator(new ReplacementValidator(m_lineEdit, NewLineChar, EscapedNewLine)); + m_lineEdit->setCompleter(0); + break; + case ValidationSingleLine: + // Set a validator that replaces newline characters by a blank. + m_lineEdit->setValidator(new ReplacementValidator(m_lineEdit, NewLineChar, QString(QLatin1Char(' ')))); + m_lineEdit->setCompleter(0); + break; + case ValidationObjectName: + setRegExpValidator(QLatin1String("[_a-zA-Z][_a-zA-Z0-9]{,1023}")); + m_lineEdit->setCompleter(0); + break; + case ValidationObjectNameScope: + setRegExpValidator(QLatin1String("[_a-zA-Z:][_a-zA-Z0-9:]{,1023}")); + m_lineEdit->setCompleter(0); + break; + case ValidationURL: { + static QStringList urlCompletions; + if (urlCompletions.empty()) { + urlCompletions.push_back(QLatin1String("about:blank")); + urlCompletions.push_back(QLatin1String("http://")); + urlCompletions.push_back(QLatin1String("http://www.")); + urlCompletions.push_back(QLatin1String("http://qt.nokia.com/")); + urlCompletions.push_back(QLatin1String("file://")); + urlCompletions.push_back(QLatin1String("ftp://")); + urlCompletions.push_back(QLatin1String("data:")); + urlCompletions.push_back(QLatin1String("data:text/html,")); + urlCompletions.push_back(QLatin1String("qrc:/")); + } + QCompleter *completer = new QCompleter(urlCompletions, m_lineEdit); + m_lineEdit->setCompleter(completer); + m_lineEdit->setValidator(new UrlValidator(completer, m_lineEdit)); + } + break; + } + + setFocusProxy(m_lineEdit); + setText(m_cachedText); + markIntermediateState(); + } + + void TextPropertyEditor::setRegExpValidator(const QString &pattern) + { + const QRegExp regExp(pattern); + Q_ASSERT(regExp.isValid()); + m_lineEdit->setValidator(new QRegExpValidator(regExp,m_lineEdit)); + } + + QString TextPropertyEditor::text() const + { + return m_cachedText; + } + + void TextPropertyEditor::markIntermediateState() + { + if (m_lineEdit->hasAcceptableInput()) { + m_lineEdit->setPalette(QPalette()); + } else { + QPalette palette = m_lineEdit->palette(); + palette.setColor(QPalette::Active, QPalette::Text, Qt::red); + m_lineEdit->setPalette(palette); + } + + } + + void TextPropertyEditor::setText(const QString &text) + { + m_cachedText = text; + m_lineEdit->setText(stringToEditorString(text, m_validationMode)); + markIntermediateState(); + m_textEdited = false; + } + + void TextPropertyEditor::slotTextEdited() + { + m_textEdited = true; + } + + void TextPropertyEditor::slotTextChanged(const QString &text) { + m_cachedText = editorStringToString(text, m_validationMode); + markIntermediateState(); + if (m_updateMode == UpdateAsYouType) + emit textChanged(m_cachedText); + } + + void TextPropertyEditor::slotEditingFinished() + { + if (m_updateMode == UpdateOnFinished && m_textEdited) { + emit textChanged(m_cachedText); + m_textEdited = false; + } + } + + void TextPropertyEditor::selectAll() { + m_lineEdit->selectAll(); + } + + void TextPropertyEditor::clear() { + m_lineEdit->clear(); + } + + void TextPropertyEditor::setAlignment(Qt::Alignment alignment) { + m_lineEdit->setAlignment(alignment); + } + + void TextPropertyEditor::installEventFilter(QObject *filterObject) + { + if (m_lineEdit) + m_lineEdit->installEventFilter(filterObject); + } + + void TextPropertyEditor::resizeEvent ( QResizeEvent * event ) { + m_lineEdit->resize( event->size()); + } + + QSize TextPropertyEditor::sizeHint () const { + return m_lineEdit->sizeHint (); + } + + QSize TextPropertyEditor::minimumSizeHint () const { + return m_lineEdit->minimumSizeHint (); + } + + // Returns whether newline characters are valid in validationMode. + bool TextPropertyEditor::multiLine(TextPropertyValidationMode validationMode) { + return validationMode == ValidationMultiLine || validationMode == ValidationStyleSheet || validationMode == ValidationRichText; + } + + // Replace newline characters literal "\n" for inline editing in mode ValidationMultiLine + QString TextPropertyEditor::stringToEditorString(const QString &s, TextPropertyValidationMode validationMode) { + if (s.isEmpty() || !multiLine(validationMode)) + return s; + + QString rc(s); + // protect backslashes + rc.replace(QLatin1Char('\\'), QLatin1String("\\\\")); + // escape newlines + rc.replace(NewLineChar, QString(EscapedNewLine)); + return rc; + + } + + // Replace literal "\n" by actual new lines for inline editing in mode ValidationMultiLine + // Note: As the properties are updated while the user types, it is important + // that trailing slashes ('bla\') are not deleted nor ignored, else this will + // cause jumping of the cursor + QString TextPropertyEditor::editorStringToString(const QString &s, TextPropertyValidationMode validationMode) { + if (s.isEmpty() || !multiLine(validationMode)) + return s; + + QString rc(s); + for (int pos = 0; (pos = rc.indexOf(QLatin1Char('\\'),pos)) >= 0 ; ) { + // found an escaped character. If not a newline or at end of string, leave as is, else insert '\n' + const int nextpos = pos + 1; + if (nextpos >= rc.length()) // trailing '\\' + break; + // Escaped NewLine + if (rc.at(nextpos) == QChar(QLatin1Char('n'))) + rc[nextpos] = NewLineChar; + // Remove escape, go past escaped + rc.remove(pos,1); + pos++; + } + return rc; + } + + bool TextPropertyEditor::hasAcceptableInput() const { + return m_lineEdit->hasAcceptableInput(); + } +} + +QT_END_NAMESPACE |