/****************************************************************************
**
** Copyright (C) 2010 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 "designerpropertymanager.h"
#include "qtpropertymanager.h"
#include "paletteeditorbutton.h"
#include "qlonglongvalidator.h"
#include "stringlisteditorbutton.h"
#include "qtresourceview_p.h"
#include "qtpropertybrowserutils_p.h"
#include <formwindowbase_p.h>
#include <textpropertyeditor_p.h>
#include <stylesheeteditor_p.h>
#include <richtexteditor_p.h>
#include <plaintexteditor_p.h>
#include <iconloader_p.h>
#include <iconselector_p.h>
#include <abstractdialoggui_p.h>
#include <QtDesigner/QDesignerIconCacheInterface>
#include <QtGui/QLabel>
#include <QtGui/QToolButton>
#include <QtGui/QHBoxLayout>
#include <QtCore/QFileInfo>
#include <QtGui/QClipboard>
#include <QtGui/QLineEdit>
#include <QtGui/QDialogButtonBox>
#include <QtGui/QPushButton>
#include <QtGui/QFileDialog>
#include <QtGui/QAction>
#include <QtGui/QMenu>
#include <QtGui/QContextMenuEvent>
#include <QtGui/QApplication>
#include <QtCore/QUrl>
#include <QtCore/QDebug>
QT_BEGIN_NAMESPACE
static const char *resettableAttributeC = "resettable";
static const char *flagsAttributeC = "flags";
static const char *validationModesAttributeC = "validationMode";
static const char *superPaletteAttributeC = "superPalette";
static const char *defaultResourceAttributeC = "defaultResource";
static const char *fontAttributeC = "font";
class DesignerFlagPropertyType
{
};
class DesignerAlignmentPropertyType
{
};
QT_END_NAMESPACE
Q_DECLARE_METATYPE(DesignerFlagPropertyType)
Q_DECLARE_METATYPE(DesignerAlignmentPropertyType)
QT_BEGIN_NAMESPACE
namespace qdesigner_internal {
// ------------ TextEditor
class TextEditor : public QWidget
{
Q_OBJECT
public:
TextEditor(QDesignerFormEditorInterface *core, QWidget *parent);
TextPropertyValidationMode textPropertyValidationMode() const;
void setTextPropertyValidationMode(TextPropertyValidationMode vm);
void setRichTextDefaultFont(const QFont &font) { m_richTextDefaultFont = font; }
QFont richTextDefaultFont() const { return m_richTextDefaultFont; }
void setSpacing(int spacing);
TextPropertyEditor::UpdateMode updateMode() const { return m_editor->updateMode(); }
void setUpdateMode(TextPropertyEditor::UpdateMode um) { m_editor->setUpdateMode(um); }
public slots:
void setText(const QString &text);
signals:
void textChanged(const QString &text);
private slots:
void buttonClicked();
void resourceActionActivated();
void fileActionActivated();
private:
TextPropertyEditor *m_editor;
QFont m_richTextDefaultFont;
QToolButton *m_button;
QMenu *m_menu;
QAction *m_resourceAction;
QAction *m_fileAction;
QHBoxLayout *m_layout;
QDesignerFormEditorInterface *m_core;
};
TextEditor::TextEditor(QDesignerFormEditorInterface *core, QWidget *parent) :
QWidget(parent),
m_editor(new TextPropertyEditor(this)),
m_richTextDefaultFont(QApplication::font()),
m_button(new QToolButton(this)),
m_menu(new QMenu(this)),
m_resourceAction(new QAction(tr("Choose Resource..."), this)),
m_fileAction(new QAction(tr("Choose File..."), this)),
m_layout(new QHBoxLayout(this)),
m_core(core)
{
m_layout->addWidget(m_editor);
m_button->setText(tr("..."));
m_button->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Ignored);
m_button->setFixedWidth(20);
m_layout->addWidget(m_button);
m_layout->setMargin(0);
m_layout->setSpacing(0);
connect(m_resourceAction, SIGNAL(triggered()), this, SLOT(resourceActionActivated()));
connect(m_fileAction, SIGNAL(triggered()), this, SLOT(fileActionActivated()));
connect(m_editor, SIGNAL(textChanged(QString)), this, SIGNAL(textChanged(QString)));
connect(m_button, SIGNAL(clicked()), this, SLOT(buttonClicked()));
setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));
m_button->setVisible(false);
setFocusProxy(m_editor);
m_menu->addAction(m_resourceAction);
m_menu->addAction(m_fileAction);
}
void TextEditor::setSpacing(int spacing)
{
m_layout->setSpacing(spacing);
}
TextPropertyValidationMode TextEditor::textPropertyValidationMode() const
{
return m_editor->textPropertyValidationMode();
}
void TextEditor::setTextPropertyValidationMode(TextPropertyValidationMode vm)
{
m_editor->setTextPropertyValidationMode(vm);
if (vm == ValidationURL) {
m_button->setMenu(m_menu);
m_button->setFixedWidth(30);
m_button->setPopupMode(QToolButton::MenuButtonPopup);
} else {
m_button->setMenu(0);
m_button->setFixedWidth(20);
m_button->setPopupMode(QToolButton::DelayedPopup);
}
m_button->setVisible(vm == ValidationStyleSheet || vm == ValidationRichText || vm == ValidationMultiLine || vm == ValidationURL);
}
void TextEditor::setText(const QString &text)
{
m_editor->setText(text);
}
void TextEditor::buttonClicked()
{
const QString oldText = m_editor->text();
QString newText;
switch (textPropertyValidationMode()) {
case ValidationStyleSheet: {
StyleSheetEditorDialog dlg(m_core, this);
dlg.setText(oldText);
if (dlg.exec() != QDialog::Accepted)
return;
newText = dlg.text();
}
break;
case ValidationRichText: {
RichTextEditorDialog dlg(m_core, this);
dlg.setDefaultFont(m_richTextDefaultFont);
dlg.setText(oldText);
if (dlg.showDialog() != QDialog::Accepted)
return;
newText = dlg.text(Qt::AutoText);
}
break;
case ValidationMultiLine: {
PlainTextEditorDialog dlg(m_core, this);
dlg.setDefaultFont(m_richTextDefaultFont);
dlg.setText(oldText);
if (dlg.showDialog() != QDialog::Accepted)
return;
newText = dlg.text();
}
break;
case ValidationURL: {
QString oldPath = oldText;
if (oldPath.isEmpty() || oldPath.startsWith(QLatin1String("qrc:")))
resourceActionActivated();
else
fileActionActivated();
}
return;
default:
return;
}
if (newText != oldText) {
m_editor->setText(newText);
emit textChanged(newText);
}
}
void TextEditor::resourceActionActivated()
{
QString oldPath = m_editor->text();
if (oldPath.startsWith(QLatin1String("qrc:")))
oldPath.remove(0, 4);
// returns ':/file'
QString newPath = IconSelector::choosePixmapResource(m_core, m_core->resourceModel(), oldPath, this);
if (newPath.startsWith(QLatin1Char(':')))
newPath.remove(0, 1);
if (newPath.isEmpty() || newPath == oldPath)
return;
const QString newText = QLatin1String("qrc:") + newPath;
m_editor->setText(newText);
emit textChanged(newText);
}
void TextEditor::fileActionActivated()
{
QString oldPath = m_editor->text();
if (oldPath.startsWith(QLatin1String("file:")))
oldPath = oldPath.mid(5);
const QString newPath = m_core->dialogGui()->getOpenFileName(this, tr("Choose a File"), oldPath);
if (newPath.isEmpty() || newPath == oldPath)
return;
const QString newText = QUrl::fromLocalFile(newPath).toString();
m_editor->setText(newText);
emit textChanged(newText);
}
// ------------ PixmapEditor
class PixmapEditor : public QWidget
{
Q_OBJECT
public:
PixmapEditor(QDesignerFormEditorInterface *core, QWidget *parent);
void setSpacing(int spacing);
void setPixmapCache(DesignerPixmapCache *cache);
public slots:
void setPath(const QString &path);
void setDefaultPixmap(const QPixmap &pixmap);
signals:
void pathChanged(const QString &path);
protected:
void contextMenuEvent(QContextMenuEvent *event);
private slots:
void defaultActionActivated();
void resourceActionActivated();
void fileActionActivated();
void copyActionActivated();
void pasteActionActivated();
void clipboardDataChanged();
private:
QDesignerFormEditorInterface *m_core;
QLabel *m_pixmapLabel;
QLabel *m_pathLabel;
QToolButton *m_button;
QAction *m_resourceAction;
QAction *m_fileAction;
QAction *m_copyAction;
QAction *m_pasteAction;
QHBoxLayout *m_layout;
QPixmap m_defaultPixmap;
QString m_path;
DesignerPixmapCache *m_pixmapCache;
};
PixmapEditor::PixmapEditor(QDesignerFormEditorInterface *core, QWidget *parent) :
QWidget(parent),
m_core(core),
m_pixmapLabel(new QLabel(this)),
m_pathLabel(new QLabel(this)),
m_button(new QToolButton(this)),
m_resourceAction(new QAction(tr("Choose Resource..."), this)),
m_fileAction(new QAction(tr("Choose File..."), this)),
m_copyAction(new QAction(createIconSet(QLatin1String("editcopy.png")), tr("Copy Path"), this)),
m_pasteAction(new QAction(createIconSet(QLatin1String("editpaste.png")), tr("Paste Path"), this)),
m_layout(new QHBoxLayout(this)),
m_pixmapCache(0)
{
m_layout->addWidget(m_pixmapLabel);
m_layout->addWidget(m_pathLabel);
m_button->setText(tr("..."));
m_button->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Ignored);
m_button->setFixedWidth(30);
m_button->setPopupMode(QToolButton::MenuButtonPopup);
m_layout->addWidget(m_button);
m_layout->setMargin(0);
m_layout->setSpacing(0);
m_pixmapLabel->setFixedWidth(16);
m_pixmapLabel->setAlignment(Qt::AlignCenter);
m_pathLabel->setSizePolicy(QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed));
QMenu *menu = new QMenu(this);
menu->addAction(m_resourceAction);
menu->addAction(m_fileAction);
m_button->setMenu(menu);
m_button->setText(tr("..."));
connect(m_button, SIGNAL(clicked()), this, SLOT(defaultActionActivated()));
connect(m_resourceAction, SIGNAL(triggered()), this, SLOT(resourceActionActivated()));
connect(m_fileAction, SIGNAL(triggered()), this, SLOT(fileActionActivated()));
connect(m_copyAction, SIGNAL(triggered()), this, SLOT(copyActionActivated()));
connect(m_pasteAction, SIGNAL(triggered()), this, SLOT(pasteActionActivated()));
setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Ignored));
setFocusProxy(m_button);
connect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(clipboardDataChanged()));
clipboardDataChanged();
}
void PixmapEditor::setPixmapCache(DesignerPixmapCache *cache)
{
m_pixmapCache = cache;
}
void PixmapEditor::setSpacing(int spacing)
{
m_layout->setSpacing(spacing);
}
void PixmapEditor::setPath(const QString &path)
{
m_path = path;
if (m_path.isEmpty()) {
m_pathLabel->setText(path);
m_pixmapLabel->setPixmap(m_defaultPixmap);
m_copyAction->setEnabled(false);
} else {
m_pathLabel->setText(QFileInfo(m_path).fileName());
if (m_pixmapCache)
m_pixmapLabel->setPixmap(QIcon(m_pixmapCache->pixmap(PropertySheetPixmapValue(path))).pixmap(16, 16));
m_copyAction->setEnabled(true);
}
}
void PixmapEditor::setDefaultPixmap(const QPixmap &pixmap)
{
m_defaultPixmap = QIcon(pixmap).pixmap(16, 16);
if (m_path.isEmpty())
m_pixmapLabel->setPixmap(m_defaultPixmap);
}
void PixmapEditor::contextMenuEvent(QContextMenuEvent *event)
{
QMenu menu(this);
menu.addAction(m_copyAction);
menu.addAction(m_pasteAction);
menu.exec(event->globalPos());
event->accept();
}
void PixmapEditor::defaultActionActivated()
{
// Default to resource
const PropertySheetPixmapValue::PixmapSource ps = m_path.isEmpty() ? PropertySheetPixmapValue::ResourcePixmap : PropertySheetPixmapValue::getPixmapSource(m_core, m_path);
switch (ps) {
case PropertySheetPixmapValue::LanguageResourcePixmap:
case PropertySheetPixmapValue::ResourcePixmap:
resourceActionActivated();
break;
case PropertySheetPixmapValue::FilePixmap:
fileActionActivated();
break;
}
}
void PixmapEditor::resourceActionActivated()
{
const QString oldPath = m_path;
const QString newPath = IconSelector::choosePixmapResource(m_core, m_core->resourceModel(), oldPath, this);
if (!newPath.isEmpty() && newPath != oldPath) {
setPath(newPath);
emit pathChanged(newPath);
}
}
void PixmapEditor::fileActionActivated()
{
const QString newPath = IconSelector::choosePixmapFile(m_path, m_core->dialogGui(), this);
if (!newPath.isEmpty() && newPath != m_path) {
setPath(newPath);
emit pathChanged(newPath);
}
}
void PixmapEditor::copyActionActivated()
{
QClipboard *clipboard = QApplication::clipboard();
clipboard->setText(m_path);
}
void PixmapEditor::pasteActionActivated()
{
QClipboard *clipboard = QApplication::clipboard();
QString subtype = QLatin1String("plain");
QString text = clipboard->text(subtype);
if (!text.isNull()) {
QStringList list = text.split(QLatin1Char('\n'));
if (list.size() > 0) {
text = list.at(0);
setPath(text);
emit pathChanged(text);
}
}
}
void PixmapEditor::clipboardDataChanged()
{
QClipboard *clipboard = QApplication::clipboard();
QString subtype = QLatin1String("plain");
const QString text = clipboard->text(subtype);
m_pasteAction->setEnabled(!text.isNull());
}
// --------------- ResetWidget
class ResetWidget : public QWidget
{
Q_OBJECT
public:
ResetWidget(QtProperty *property, QWidget *parent = 0);
void setWidget(QWidget *widget);
void setResetEnabled(bool enabled);
void setValueText(const QString &text);
void setValueIcon(const QIcon &icon);
void setSpacing(int spacing);
signals:
void resetProperty(QtProperty *property);
private slots:
void slotClicked();
private:
QtProperty *m_property;
QLabel *m_textLabel;
QLabel *m_iconLabel;
QToolButton *m_button;
int m_spacing;
};
ResetWidget::ResetWidget(QtProperty *property, QWidget *parent) :
QWidget(parent),
m_property(property),
m_textLabel(new QLabel(this)),
m_iconLabel(new QLabel(this)),
m_button(new QToolButton(this)),
m_spacing(-1)
{
m_textLabel->setSizePolicy(QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed));
m_iconLabel->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
m_button->setToolButtonStyle(Qt::ToolButtonIconOnly);
m_button->setIcon(createIconSet(QLatin1String("resetproperty.png")));
m_button->setIconSize(QSize(8,8));
m_button->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::MinimumExpanding));
connect(m_button, SIGNAL(clicked()), this, SLOT(slotClicked()));
QLayout *layout = new QHBoxLayout(this);
layout->setMargin(0);
layout->setSpacing(m_spacing);
layout->addWidget(m_iconLabel);
layout->addWidget(m_textLabel);
layout->addWidget(m_button);
setFocusProxy(m_textLabel);
setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));
}
void ResetWidget::setSpacing(int spacing)
{
m_spacing = spacing;
layout()->setSpacing(m_spacing);
}
void ResetWidget::setWidget(QWidget *widget)
{
if (m_textLabel) {
delete m_textLabel;
m_textLabel = 0;
}
if (m_iconLabel) {
delete m_iconLabel;
m_iconLabel = 0;
}
delete layout();
QLayout *layout = new QHBoxLayout(this);
layout->setMargin(0);
layout->setSpacing(m_spacing);
layout->addWidget(widget);
layout->addWidget(m_button);
setFocusProxy(widget);
}
void ResetWidget::setResetEnabled(bool enabled)
{
m_button->setEnabled(enabled);
}
void ResetWidget::setValueText(const QString &text)
{
if (m_textLabel)
m_textLabel->setText(text);
}
void ResetWidget::setValueIcon(const QIcon &icon)
{
QPixmap pix = icon.pixmap(QSize(16, 16));
if (m_iconLabel) {
m_iconLabel->setVisible(!pix.isNull());
m_iconLabel->setPixmap(pix);
}
}
void ResetWidget::slotClicked()
{
emit resetProperty(m_property);
}
// ------------ DesignerPropertyManager:
DesignerPropertyManager::DesignerPropertyManager(QDesignerFormEditorInterface *core, QObject *parent) :
QtVariantPropertyManager(parent),
m_changingSubValue(false),
m_core(core),
m_sourceOfChange(0)
{
connect(this, SIGNAL(valueChanged(QtProperty*,QVariant)), this, SLOT(slotValueChanged(QtProperty*,QVariant)));
connect(this, SIGNAL(propertyDestroyed(QtProperty*)), this, SLOT(slotPropertyDestroyed(QtProperty*)));
}
DesignerPropertyManager::~DesignerPropertyManager()
{
clear();
}
int DesignerPropertyManager::bitCount(int mask) const
{
int count = 0;
for (; mask; count++)
mask &= mask - 1; // clear the least significant bit set
return count;
}
int DesignerPropertyManager::alignToIndexH(uint align) const
{
if (align & Qt::AlignLeft)
return 0;
if (align & Qt::AlignHCenter)
return 1;
if (align & Qt::AlignRight)
return 2;
if (align & Qt::AlignJustify)
return 3;
return 0;
}
int DesignerPropertyManager::alignToIndexV(uint align) const
{
if (align & Qt::AlignTop)
return 0;
if (align & Qt::AlignVCenter)
return 1;
if (align & Qt::AlignBottom)
return 2;
return 1;
}
uint DesignerPropertyManager::indexHToAlign(int idx) const
{
switch (idx) {
case 0: return Qt::AlignLeft;
case 1: return Qt::AlignHCenter;
case 2: return Qt::AlignRight;
case 3: return Qt::AlignJustify;
default: break;
}
return Qt::AlignLeft;
}
uint DesignerPropertyManager::indexVToAlign(int idx) const
{
switch (idx) {
case 0: return Qt::AlignTop;
case 1: return Qt::AlignVCenter;
case 2: return Qt::AlignBottom;
default: break;
}
return Qt::AlignVCenter;
}
QString DesignerPropertyManager::indexHToString(int idx) const
{
switch (idx) {
case 0: return tr("AlignLeft");
case 1: return tr("AlignHCenter");
case 2: return tr("AlignRight");
case 3: return tr("AlignJustify");
default: break;
}
return tr("AlignLeft");
}
QString DesignerPropertyManager::indexVToString(int idx) const
{
switch (idx) {
case 0: return tr("AlignTop");
case 1: return tr("AlignVCenter");
case 2: return tr("AlignBottom");
default: break;
}
return tr("AlignVCenter");
}
void DesignerPropertyManager::slotValueChanged(QtProperty *property, const QVariant &value)
{
if (m_changingSubValue)
return;
bool enableSubPropertyHandling = true;
if (QtProperty *flagProperty = m_flagToProperty.value(property, 0)) {
const QList<QtProperty *> subFlags = m_propertyToFlags.value(flagProperty);
const int subFlagCount = subFlags.count();
// flag changed
const bool subValue = variantProperty(property)->value().toBool();
const int subIndex = subFlags.indexOf(property);
if (subIndex < 0)
return;
uint newValue = 0;
m_changingSubValue = true;
FlagData data = m_flagValues.value(flagProperty);
const QList<uint> values = data.values;
// Compute new value, without including (additional) supermasks
if (values.at(subIndex) == 0) {
for (int i = 0; i < subFlagCount; ++i) {
QtVariantProperty *subFlag = variantProperty(subFlags.at(i));
subFlag->setValue(i == subIndex);
}
} else {
if (subValue)
newValue = values.at(subIndex); // value mask of subValue
for (int i = 0; i < subFlagCount; ++i) {
QtVariantProperty *subFlag = variantProperty(subFlags.at(i));
if (subFlag->value().toBool() && bitCount(values.at(i)) == 1)
newValue |= values.at(i);
}
if (newValue == 0) {
// Uncheck all items except 0-mask
for (int i = 0; i < subFlagCount; ++i) {
QtVariantProperty *subFlag = variantProperty(subFlags.at(i));
subFlag->setValue(values.at(i) == 0);
}
} else if (newValue == data.val) {
if (!subValue && bitCount(values.at(subIndex)) > 1) {
// We unchecked something, but the original value still holds
variantProperty(property)->setValue(true);
}
} else {
// Make sure 0-mask is not selected
for (int i = 0; i < subFlagCount; ++i) {
QtVariantProperty *subFlag = variantProperty(subFlags.at(i));
if (values.at(i) == 0)
subFlag->setValue(false);
}
// Check/uncheck proper masks
if (subValue) {
// Make sure submasks and supermasks are selected
for (int i = 0; i < subFlagCount; ++i) {
QtVariantProperty *subFlag = variantProperty(subFlags.at(i));
const uint vi = values.at(i);
if ((vi != 0) && ((vi & newValue) == vi) && !subFlag->value().toBool())
subFlag->setValue(true);
}
} else {
// Make sure supermasks are not selected if they're no longer valid
for (int i = 0; i < subFlagCount; ++i) {
QtVariantProperty *subFlag = variantProperty(subFlags.at(i));
const uint vi = values.at(i);
if (subFlag->value().toBool() && ((vi & newValue) != vi))
subFlag->setValue(false);
}
}
}
}
m_changingSubValue = false;
data.val = newValue;
QVariant v;
qVariantSetValue(v, data.val);
variantProperty(flagProperty)->setValue(v);
} else if (QtProperty *alignProperty = m_alignHToProperty.value(property, 0)) {
const uint v = m_alignValues.value(alignProperty);
const uint newValue = indexHToAlign(value.toInt()) | indexVToAlign(alignToIndexV(v));
if (v == newValue)
return;
variantProperty(alignProperty)->setValue(newValue);
} else if (QtProperty *alignProperty = m_alignVToProperty.value(property, 0)) {
const uint v = m_alignValues.value(alignProperty);
const uint newValue = indexVToAlign(value.toInt()) | indexHToAlign(alignToIndexH(v));
if (v == newValue)
return;
variantProperty(alignProperty)->setValue(newValue);
} else if (QtProperty *stringProperty = m_commentToString.value(property, 0)) {
const PropertySheetStringValue v = m_stringValues.value(stringProperty);
PropertySheetStringValue newValue = v;
newValue.setComment(value.toString());
if (v == newValue)
return;
variantProperty(stringProperty)->setValue(qVariantFromValue(newValue));
} else if (QtProperty *stringProperty = m_translatableToString.value(property, 0)) {
const PropertySheetStringValue v = m_stringValues.value(stringProperty);
PropertySheetStringValue newValue = v;
newValue.setTranslatable(value.toBool());
if (v == newValue)
return;
variantProperty(stringProperty)->setValue(qVariantFromValue(newValue));
} else if (QtProperty *stringProperty = m_disambiguationToString.value(property, 0)) {
const PropertySheetStringValue v = m_stringValues.value(stringProperty);
PropertySheetStringValue newValue = v;
newValue.setDisambiguation(value.toString());
if (v == newValue)
return;
variantProperty(stringProperty)->setValue(qVariantFromValue(newValue));
} else if (QtProperty *keySequenceProperty = m_commentToKeySequence.value(property, 0)) {
const PropertySheetKeySequenceValue v = m_keySequenceValues.value(keySequenceProperty);
PropertySheetKeySequenceValue newValue = v;
newValue.setComment(value.toString());
if (v == newValue)
return;
variantProperty(keySequenceProperty)->setValue(qVariantFromValue(newValue));
} else if (QtProperty *keySequenceProperty = m_translatableToKeySequence.value(property, 0)) {
const PropertySheetKeySequenceValue v = m_keySequenceValues.value(keySequenceProperty);
PropertySheetKeySequenceValue newValue = v;
newValue.setTranslatable(value.toBool());
if (v == newValue)
return;
variantProperty(keySequenceProperty)->setValue(qVariantFromValue(newValue));
} else if (QtProperty *keySequenceProperty = m_disambiguationToKeySequence.value(property, 0)) {
const PropertySheetKeySequenceValue v = m_keySequenceValues.value(keySequenceProperty);
PropertySheetKeySequenceValue newValue = v;
newValue.setDisambiguation(value.toString());
if (v == newValue)
return;
variantProperty(keySequenceProperty)->setValue(qVariantFromValue(newValue));
} else if (QtProperty *iProperty = m_iconSubPropertyToProperty.value(property, 0)) {
QtVariantProperty *iconProperty = variantProperty(iProperty);
PropertySheetIconValue icon = qVariantValue<PropertySheetIconValue>(iconProperty->value());
QPair<QIcon::Mode, QIcon::State> pair = m_iconSubPropertyToState.value(property);
icon.setPixmap(pair.first, pair.second, qVariantValue<PropertySheetPixmapValue>(value));
QtProperty *origSourceOfChange = m_sourceOfChange;
if (!origSourceOfChange)
m_sourceOfChange = property;
iconProperty->setValue(qVariantFromValue(icon));
if (!origSourceOfChange)
m_sourceOfChange = origSourceOfChange;
} else if (m_iconValues.contains(property)) {
enableSubPropertyHandling = m_sourceOfChange;
} else {
if (m_brushManager.valueChanged(this, property, value) == BrushPropertyManager::Unchanged)
return;
if (m_fontManager.valueChanged(this, property, value) == FontPropertyManager::Unchanged)
return;
}
emit valueChanged(property, value, enableSubPropertyHandling);
}
void DesignerPropertyManager::slotPropertyDestroyed(QtProperty *property)
{
if (QtProperty *flagProperty = m_flagToProperty.value(property, 0)) {
PropertyToPropertyListMap::iterator it = m_propertyToFlags.find(flagProperty);
QList<QtProperty *> &propertyList = it.value();
propertyList.replace(propertyList.indexOf(property), 0);
m_flagToProperty.remove(property);
} else if (QtProperty *alignProperty = m_alignHToProperty.value(property, 0)) {
m_propertyToAlignH.remove(alignProperty);
m_alignHToProperty.remove(property);
} else if (QtProperty *alignProperty = m_alignVToProperty.value(property, 0)) {
m_propertyToAlignV.remove(alignProperty);
m_alignVToProperty.remove(property);
} else if (QtProperty *stringCommentProperty = m_commentToString.value(property, 0)) {
m_stringToComment.remove(stringCommentProperty);
m_commentToString.remove(property);
} else if (QtProperty *stringTranslatableProperty = m_translatableToString.value(property, 0)) {
m_stringToTranslatable.remove(stringTranslatableProperty);
m_translatableToString.remove(property);
} else if (QtProperty *stringDisambiguationProperty = m_disambiguationToString.value(property, 0)) {
m_stringToDisambiguation.remove(stringDisambiguationProperty);
m_disambiguationToString.remove(property);
} else if (QtProperty *keySequenceCommentProperty = m_commentToKeySequence.value(property, 0)) {
m_keySequenceToComment.remove(keySequenceCommentProperty);
m_commentToKeySequence.remove(property);
} else if (QtProperty *keySequenceTranslatableProperty = m_translatableToKeySequence.value(property, 0)) {
m_keySequenceToTranslatable.remove(keySequenceTranslatableProperty);
m_translatableToKeySequence.remove(property);
} else if (QtProperty *keySequenceDisambiguationProperty = m_disambiguationToKeySequence.value(property, 0)) {
m_keySequenceToDisambiguation.remove(keySequenceDisambiguationProperty);
m_disambiguationToKeySequence.remove(property);
} else if (QtProperty *iconProperty = m_iconSubPropertyToProperty.value(property, 0)) {
QMap<QtProperty *, QMap<QPair<QIcon::Mode, QIcon::State>, QtProperty *> >::iterator it =
m_propertyToIconSubProperties.find(iconProperty);
QPair<QIcon::Mode, QIcon::State> state = m_iconSubPropertyToState.value(property);
QMap<QPair<QIcon::Mode, QIcon::State>, QtProperty *> &propertyList = it.value();
propertyList.remove(state);
m_iconSubPropertyToState.remove(property);
m_iconSubPropertyToProperty.remove(property);
} else {
m_fontManager.slotPropertyDestroyed(property);
m_brushManager.slotPropertyDestroyed(property);
}
}
QStringList DesignerPropertyManager::attributes(int propertyType) const
{
if (!isPropertyTypeSupported(propertyType))
return QStringList();
QStringList list = QtVariantPropertyManager::attributes(propertyType);
if (propertyType == designerFlagTypeId()) {
list.append(QLatin1String(flagsAttributeC));
} else if (propertyType == designerPixmapTypeId()) {
list.append(QLatin1String(defaultResourceAttributeC));
} else if (propertyType == designerIconTypeId()) {
list.append(QLatin1String(defaultResourceAttributeC));
} else if (propertyType == designerStringTypeId() || propertyType == QVariant::String) {
list.append(QLatin1String(validationModesAttributeC));
list.append(QLatin1String(fontAttributeC));
} else if (propertyType == QVariant::Palette) {
list.append(QLatin1String(superPaletteAttributeC));
}
list.append(QLatin1String(resettableAttributeC));
return list;
}
int DesignerPropertyManager::attributeType(int propertyType, const QString &attribute) const
{
if (!isPropertyTypeSupported(propertyType))
return 0;
if (propertyType == designerFlagTypeId() && attribute == QLatin1String(flagsAttributeC))
return designerFlagListTypeId();
if (propertyType == designerPixmapTypeId() && attribute == QLatin1String(defaultResourceAttributeC))
return QVariant::Pixmap;
if (propertyType == designerIconTypeId() && attribute == QLatin1String(defaultResourceAttributeC))
return QVariant::Icon;
if (attribute == QLatin1String(resettableAttributeC))
return QVariant::Bool;
if (propertyType == designerStringTypeId() || propertyType == QVariant::String) {
if (attribute == QLatin1String(validationModesAttributeC))
return QVariant::Int;
if (attribute == QLatin1String(fontAttributeC))
return QVariant::Font;
}
if (propertyType == QVariant::Palette && attribute == QLatin1String(superPaletteAttributeC))
return QVariant::Palette;
return QtVariantPropertyManager::attributeType(propertyType, attribute);
}
QVariant DesignerPropertyManager::attributeValue(const QtProperty *property, const QString &attribute) const
{
QtProperty *prop = const_cast<QtProperty *>(property);
if (attribute == QLatin1String(resettableAttributeC)) {
const PropertyBoolMap::const_iterator it = m_resetMap.constFind(prop);
if (it != m_resetMap.constEnd())
return it.value();
}
if (attribute == QLatin1String(flagsAttributeC)) {
PropertyFlagDataMap::const_iterator it = m_flagValues.constFind(prop);
if (it != m_flagValues.constEnd()) {
QVariant v;
qVariantSetValue(v, it.value().flags);
return v;
}
}
if (attribute == QLatin1String(validationModesAttributeC)) {
const PropertyIntMap::const_iterator it = m_stringAttributes.constFind(prop);
if (it != m_stringAttributes.constEnd())
return it.value();
}
if (attribute == QLatin1String(fontAttributeC)) {
const PropertyFontMap::const_iterator it = m_stringFontAttributes.constFind(prop);
if (it != m_stringFontAttributes.constEnd())
return it.value();
}
if (attribute == QLatin1String(superPaletteAttributeC)) {
PropertyPaletteDataMap::const_iterator it = m_paletteValues.constFind(prop);
if (it != m_paletteValues.constEnd())
return it.value().superPalette;
}
if (attribute == QLatin1String(defaultResourceAttributeC)) {
QMap<QtProperty *, QPixmap>::const_iterator itPix = m_defaultPixmaps.constFind(prop);
if (itPix != m_defaultPixmaps.constEnd())
return itPix.value();
QMap<QtProperty *, QIcon>::const_iterator itIcon = m_defaultIcons.constFind(prop);
if (itIcon != m_defaultIcons.constEnd())
return itIcon.value();
}
return QtVariantPropertyManager::attributeValue(property, attribute);
}
void DesignerPropertyManager::setAttribute(QtProperty *property,
const QString &attribute, const QVariant &value)
{
if (attribute == QLatin1String(resettableAttributeC) && m_resetMap.contains(property)) {
if (value.userType() != QVariant::Bool)
return;
const bool val = value.toBool();
const PropertyBoolMap::iterator it = m_resetMap.find(property);
if (it.value() == val)
return;
it.value() = val;
emit attributeChanged(variantProperty(property), attribute, value);
return;
} else if (attribute == QLatin1String(flagsAttributeC) && m_flagValues.contains(property)) {
if (value.userType() != designerFlagListTypeId())
return;
const DesignerFlagList flags = qVariantValue<DesignerFlagList>(value);
PropertyFlagDataMap::iterator fit = m_flagValues.find(property);
FlagData data = fit.value();
if (data.flags == flags)
return;
PropertyToPropertyListMap::iterator pfit = m_propertyToFlags.find(property);
QListIterator<QtProperty *> itProp(pfit.value());
while (itProp.hasNext()) {
if (QtProperty *prop = itProp.next()) {
delete prop;
m_flagToProperty.remove(prop);
}
}
pfit.value().clear();
QList<uint> values;
QListIterator<QPair<QString, uint> > itFlag(flags);
while (itFlag.hasNext()) {
const QPair<QString, uint> pair = itFlag.next();
const QString flagName = pair.first;
QtProperty *prop = addProperty(QVariant::Bool);
prop->setPropertyName(flagName);
property->addSubProperty(prop);
m_propertyToFlags[property].append(prop);
m_flagToProperty[prop] = property;
values.append(pair.second);
}
data.val = 0;
data.flags = flags;
data.values = values;
fit.value() = data;
QVariant v;
qVariantSetValue(v, flags);
emit attributeChanged(property, attribute, v);
emit propertyChanged(property);
emit QtVariantPropertyManager::valueChanged(property, data.val);
} else if (attribute == QLatin1String(validationModesAttributeC) && m_stringAttributes.contains(property)) {
if (value.userType() != QVariant::Int)
return;
const PropertyIntMap::iterator it = m_stringAttributes.find(property);
const int oldValue = it.value();
const int newValue = value.toInt();
if (oldValue == newValue)
return;
it.value() = newValue;
emit attributeChanged(property, attribute, newValue);
} else if (attribute == QLatin1String(fontAttributeC) && m_stringFontAttributes.contains(property)) {
if (value.userType() != QVariant::Font)
return;
const PropertyFontMap::iterator it = m_stringFontAttributes.find(property);
const QFont oldValue = it.value();
const QFont newValue = qvariant_cast<QFont>(value);
if (oldValue == newValue)
return;
it.value() = newValue;
emit attributeChanged(property, attribute, newValue);
} else if (attribute == QLatin1String(superPaletteAttributeC) && m_paletteValues.contains(property)) {
if (value.userType() != QVariant::Palette)
return;
QPalette superPalette = qVariantValue<QPalette>(value);
const PropertyPaletteDataMap::iterator it = m_paletteValues.find(property);
PaletteData data = it.value();
if (data.superPalette == superPalette)
return;
data.superPalette = superPalette;
// resolve here
const uint mask = data.val.resolve();
data.val = data.val.resolve(superPalette);
data.val.resolve(mask);
it.value() = data;
QVariant v;
qVariantSetValue(v, superPalette);
emit attributeChanged(property, attribute, v);
emit propertyChanged(property);
emit QtVariantPropertyManager::valueChanged(property, data.val); // if resolve was done, this is also for consistency
} else if (attribute == QLatin1String(defaultResourceAttributeC) && m_defaultPixmaps.contains(property)) {
if (value.userType() != QVariant::Pixmap)
return;
QPixmap defaultPixmap = qVariantValue<QPixmap>(value);
const QMap<QtProperty *, QPixmap>::iterator it = m_defaultPixmaps.find(property);
QPixmap oldDefaultPixmap = it.value();
if (defaultPixmap.cacheKey() == oldDefaultPixmap.cacheKey())
return;
it.value() = defaultPixmap;
QVariant v = qVariantFromValue(defaultPixmap);
emit attributeChanged(property, attribute, v);
emit propertyChanged(property);
} else if (attribute == QLatin1String(defaultResourceAttributeC) && m_defaultIcons.contains(property)) {
if (value.userType() != QVariant::Icon)
return;
QIcon defaultIcon = qVariantValue<QIcon>(value);
const QMap<QtProperty *, QIcon>::iterator it = m_defaultIcons.find(property);
QIcon oldDefaultIcon = it.value();
if (defaultIcon.cacheKey() == oldDefaultIcon.cacheKey())
return;
it.value() = defaultIcon;
qdesigner_internal::PropertySheetIconValue icon = m_iconValues.value(property);
if (icon.paths().isEmpty()) {
QMap<QPair<QIcon::Mode, QIcon::State>, QtProperty *> subIconProperties = m_propertyToIconSubProperties.value(property);
QMapIterator<QPair<QIcon::Mode, QIcon::State>, QtProperty *> itSub(subIconProperties);
while (itSub.hasNext()) {
QPair<QIcon::Mode, QIcon::State> pair = itSub.next().key();
QtProperty *subProp = itSub.value();
setAttribute(subProp, QLatin1String(defaultResourceAttributeC),
defaultIcon.pixmap(16, 16, pair.first, pair.second));
}
}
QVariant v = qVariantFromValue(defaultIcon);
emit attributeChanged(property, attribute, v);
emit propertyChanged(property);
}
QtVariantPropertyManager::setAttribute(property, attribute, value);
}
int DesignerPropertyManager::designerFlagTypeId()
{
static const int rc = qMetaTypeId<DesignerFlagPropertyType>();
return rc;
}
int DesignerPropertyManager::designerFlagListTypeId()
{
static const int rc = qMetaTypeId<DesignerFlagList>();
return rc;
}
int DesignerPropertyManager::designerAlignmentTypeId()
{
static const int rc = qMetaTypeId<DesignerAlignmentPropertyType>();
return rc;
}
int DesignerPropertyManager::designerPixmapTypeId()
{
return qMetaTypeId<PropertySheetPixmapValue>();
}
int DesignerPropertyManager::designerIconTypeId()
{
return qMetaTypeId<PropertySheetIconValue>();
}
int DesignerPropertyManager::designerStringTypeId()
{
return qMetaTypeId<PropertySheetStringValue>();
}
int DesignerPropertyManager::designerKeySequenceTypeId()
{
return qMetaTypeId<PropertySheetKeySequenceValue>();
}
bool DesignerPropertyManager::isPropertyTypeSupported(int propertyType) const
{
switch (propertyType) {
case QVariant::Palette:
case QVariant::UInt:
case QVariant::LongLong:
case QVariant::ULongLong:
case QVariant::Url:
case QVariant::ByteArray:
case QVariant::StringList:
case QVariant::Brush:
return true;
default:
break;
}
if (propertyType == designerFlagTypeId())
return true;
if (propertyType == designerAlignmentTypeId())
return true;
if (propertyType == designerPixmapTypeId())
return true;
if (propertyType == designerIconTypeId())
return true;
if (propertyType == designerStringTypeId())
return true;
if (propertyType == designerKeySequenceTypeId())
return true;
return QtVariantPropertyManager::isPropertyTypeSupported(propertyType);
}
QString DesignerPropertyManager::valueText(const QtProperty *property) const
{
if (m_flagValues.contains(const_cast<QtProperty *>(property))) {
const FlagData data = m_flagValues.value(const_cast<QtProperty *>(property));
const uint v = data.val;
const QChar bar = QLatin1Char('|');
QString valueStr;
const QList<QPair<QString, uint> > flags = data.flags;
const QList<QPair<QString, uint> >::const_iterator fcend = flags.constEnd();
for (QList<QPair<QString, uint> >::const_iterator it = flags.constBegin(); it != fcend; ++it) {
const uint val = it->second;
const bool checked = (val == 0) ? (v == 0) : ((val & v) == val);
if (checked) {
if (!valueStr.isEmpty())
valueStr += bar;
valueStr += it->first;
}
}
return valueStr;
}
if (m_alignValues.contains(const_cast<QtProperty *>(property))) {
const uint v = m_alignValues.value(const_cast<QtProperty *>(property));
return tr("%1, %2").arg(indexHToString(alignToIndexH(v))).arg(indexVToString(alignToIndexV(v)));
}
if (m_paletteValues.contains(const_cast<QtProperty *>(property))) {
const PaletteData data = m_paletteValues.value(const_cast<QtProperty *>(property));
const uint mask = data.val.resolve();
if (mask)
return tr("Customized (%n roles)", 0, bitCount(mask));
static const QString inherited = tr("Inherited");
return inherited;
}
if (m_iconValues.contains(const_cast<QtProperty *>(property))) {
const PropertySheetIconValue::ModeStateToPixmapMap paths = m_iconValues.value(const_cast<QtProperty *>(property)).paths();
const PropertySheetIconValue::ModeStateToPixmapMap::const_iterator it = paths.constFind(qMakePair(QIcon::Normal, QIcon::Off));
if (it == paths.constEnd())
return QString();
return QFileInfo(it.value().path()).fileName();
}
if (m_pixmapValues.contains(const_cast<QtProperty *>(property))) {
const QString path = m_pixmapValues.value(const_cast<QtProperty *>(property)).path();
if (path.isEmpty())
return QString();
return QFileInfo(path).fileName();
}
if (m_uintValues.contains(const_cast<QtProperty *>(property))) {
return QString::number(m_uintValues.value(const_cast<QtProperty *>(property)));
}
if (m_longLongValues.contains(const_cast<QtProperty *>(property))) {
return QString::number(m_longLongValues.value(const_cast<QtProperty *>(property)));
}
if (m_uLongLongValues.contains(const_cast<QtProperty *>(property))) {
return QString::number(m_uLongLongValues.value(const_cast<QtProperty *>(property)));
}
if (m_urlValues.contains(const_cast<QtProperty *>(property))) {
return m_urlValues.value(const_cast<QtProperty *>(property)).toString();
}
if (m_byteArrayValues.contains(const_cast<QtProperty *>(property))) {
return QString::fromUtf8(m_byteArrayValues.value(const_cast<QtProperty *>(property)));
}
if (m_stringListValues.contains(const_cast<QtProperty *>(property))) {
return m_stringListValues.value(const_cast<QtProperty *>(property)).join(QLatin1String("; "));
}
if (QtVariantPropertyManager::valueType(property) == QVariant::String || QtVariantPropertyManager::valueType(property) == designerStringTypeId()) {
const QString str = (QtVariantPropertyManager::valueType(property) == QVariant::String) ? value(property).toString() : qVariantValue<PropertySheetStringValue>(value(property)).value();
const int validationMode = attributeValue(property, QLatin1String(validationModesAttributeC)).toInt();
return TextPropertyEditor::stringToEditorString(str, static_cast<TextPropertyValidationMode>(validationMode));
}
if (QtVariantPropertyManager::valueType(property) == designerKeySequenceTypeId()) {
return qVariantValue<PropertySheetKeySequenceValue>(value(property)).value();
}
if (QtVariantPropertyManager::valueType(property) == QVariant::Bool) {
return QString();
}
QString rc;
if (m_brushManager.valueText(property, &rc))
return rc;
return QtVariantPropertyManager::valueText(property);
}
void DesignerPropertyManager::reloadResourceProperties()
{
DesignerIconCache *iconCache = 0;
QMapIterator<QtProperty *, qdesigner_internal::PropertySheetIconValue> itIcon(m_iconValues);
while (itIcon.hasNext()) {
QtProperty *property = itIcon.next().key();
PropertySheetIconValue icon = itIcon.value();
QIcon defaultIcon = m_defaultIcons.value(property);
if (!icon.paths().isEmpty()) {
if (!iconCache) {
QDesignerFormWindowInterface *formWindow = QDesignerFormWindowInterface::findFormWindow(m_object);
qdesigner_internal::FormWindowBase *fwb = qobject_cast<qdesigner_internal::FormWindowBase *>(formWindow);
iconCache = fwb->iconCache();
}
if (iconCache)
defaultIcon = iconCache->icon(icon);
}
QMap<QPair<QIcon::Mode, QIcon::State>, PropertySheetPixmapValue> iconPaths = icon.paths();
QMap<QPair<QIcon::Mode, QIcon::State>, QtProperty *> subProperties = m_propertyToIconSubProperties.value(property);
QMapIterator<QPair<QIcon::Mode, QIcon::State>, QtProperty *> itSub(subProperties);
while (itSub.hasNext()) {
const QPair<QIcon::Mode, QIcon::State> pair = itSub.next().key();
QtVariantProperty *subProperty = variantProperty(itSub.value());
subProperty->setAttribute(QLatin1String(defaultResourceAttributeC),
defaultIcon.pixmap(16, 16, pair.first, pair.second));
}
emit propertyChanged(property);
emit QtVariantPropertyManager::valueChanged(property, qVariantFromValue(itIcon.value()));
}
QMapIterator<QtProperty *, qdesigner_internal::PropertySheetPixmapValue> itPix(m_pixmapValues);
while (itPix.hasNext()) {
QtProperty *property = itPix.next().key();
emit propertyChanged(property);
emit QtVariantPropertyManager::valueChanged(property, qVariantFromValue(itPix.value()));
}
}
QIcon DesignerPropertyManager::valueIcon(const QtProperty *property) const
{
if (m_iconValues.contains(const_cast<QtProperty *>(property))) {
if (!property->isModified())
return m_defaultIcons.value(const_cast<QtProperty *>(property)).pixmap(16, 16);
QDesignerFormWindowInterface *formWindow = QDesignerFormWindowInterface::findFormWindow(m_object);
qdesigner_internal::FormWindowBase *fwb = qobject_cast<qdesigner_internal::FormWindowBase *>(formWindow);
if (fwb)
return fwb->iconCache()->icon(m_iconValues.value(const_cast<QtProperty *>(property))).pixmap(16, 16);
} else if (m_pixmapValues.contains(const_cast<QtProperty *>(property))) {
if (!property->isModified())
return m_defaultPixmaps.value(const_cast<QtProperty *>(property));
QDesignerFormWindowInterface *formWindow = QDesignerFormWindowInterface::findFormWindow(m_object);
qdesigner_internal::FormWindowBase *fwb = qobject_cast<qdesigner_internal::FormWindowBase *>(formWindow);
if (fwb)
return fwb->pixmapCache()->pixmap(m_pixmapValues.value(const_cast<QtProperty *>(property)));
} else {
QIcon rc;
if (m_brushManager.valueIcon(property, &rc))
return rc;
}
return QtVariantPropertyManager::valueIcon(property);
}
QVariant DesignerPropertyManager::value(const QtProperty *property) const
{
if (m_flagValues.contains(const_cast<QtProperty *>(property)))
return m_flagValues.value(const_cast<QtProperty *>(property)).val;
if (m_alignValues.contains(const_cast<QtProperty *>(property)))
return m_alignValues.value(const_cast<QtProperty *>(property));
if (m_paletteValues.contains(const_cast<QtProperty *>(property)))
return m_paletteValues.value(const_cast<QtProperty *>(property)).val;
if (m_iconValues.contains(const_cast<QtProperty *>(property)))
return qVariantFromValue(m_iconValues.value(const_cast<QtProperty *>(property)));
if (m_pixmapValues.contains(const_cast<QtProperty *>(property)))
return qVariantFromValue(m_pixmapValues.value(const_cast<QtProperty *>(property)));
if (m_stringValues.contains(const_cast<QtProperty *>(property)))
return qVariantFromValue(m_stringValues.value(const_cast<QtProperty *>(property)));
if (m_keySequenceValues.contains(const_cast<QtProperty *>(property)))
return qVariantFromValue(m_keySequenceValues.value(const_cast<QtProperty *>(property)));
if (m_uintValues.contains(const_cast<QtProperty *>(property)))
return m_uintValues.value(const_cast<QtProperty *>(property));
if (m_longLongValues.contains(const_cast<QtProperty *>(property)))
return m_longLongValues.value(const_cast<QtProperty *>(property));
if (m_uLongLongValues.contains(const_cast<QtProperty *>(property)))
return m_uLongLongValues.value(const_cast<QtProperty *>(property));
if (m_urlValues.contains(const_cast<QtProperty *>(property)))
return m_urlValues.value(const_cast<QtProperty *>(property));
if (m_byteArrayValues.contains(const_cast<QtProperty *>(property)))
return m_byteArrayValues.value(const_cast<QtProperty *>(property));
if (m_stringListValues.contains(const_cast<QtProperty *>(property)))
return m_stringListValues.value(const_cast<QtProperty *>(property));
QVariant rc;
if (m_brushManager.value(property, &rc))
return rc;
return QtVariantPropertyManager::value(property);
}
int DesignerPropertyManager::valueType(int propertyType) const
{
switch (propertyType) {
case QVariant::Palette:
case QVariant::UInt:
case QVariant::LongLong:
case QVariant::ULongLong:
case QVariant::Url:
case QVariant::ByteArray:
case QVariant::StringList:
case QVariant::Brush:
return propertyType;
default:
break;
}
if (propertyType == designerFlagTypeId())
return QVariant::UInt;
if (propertyType == designerAlignmentTypeId())
return QVariant::UInt;
if (propertyType == designerPixmapTypeId())
return propertyType;
if (propertyType == designerIconTypeId())
return propertyType;
if (propertyType == designerStringTypeId())
return propertyType;
if (propertyType == designerKeySequenceTypeId())
return propertyType;
return QtVariantPropertyManager::valueType(propertyType);
}
void DesignerPropertyManager::setValue(QtProperty *property, const QVariant &value)
{
const PropertyFlagDataMap::iterator fit = m_flagValues.find(property);
if (fit != m_flagValues.end()) {
if (value.type() != QVariant::UInt && !value.canConvert(QVariant::UInt))
return;
const uint v = value.toUInt();
FlagData data = fit.value();
if (data.val == v)
return;
// set Value
const QList<uint> values = data.values;
const QList<QtProperty *> subFlags = m_propertyToFlags.value(property);
const int subFlagCount = subFlags.count();
for (int i = 0; i < subFlagCount; ++i) {
QtVariantProperty *subFlag = variantProperty(subFlags.at(i));
const uint val = values.at(i);
const bool checked = (val == 0) ? (v == 0) : ((val & v) == val);
subFlag->setValue(checked);
}
for (int i = 0; i < subFlagCount; ++i) {
QtVariantProperty *subFlag = variantProperty(subFlags.at(i));
const uint val = values.at(i);
const bool checked = (val == 0) ? (v == 0) : ((val & v) == val);
bool enabled = true;
if (val == 0) {
if (checked)
enabled = false;
} else if (bitCount(val) > 1) {
// Disabled if all flags contained in the mask are checked
uint currentMask = 0;
for (int j = 0; j < subFlagCount; ++j) {
QtVariantProperty *subFlag = variantProperty(subFlags.at(j));
if (bitCount(values.at(j)) == 1)
currentMask |= subFlag->value().toBool() ? values.at(j) : 0;
}
if ((currentMask & values.at(i)) == values.at(i))
enabled = false;
}
subFlag->setEnabled(enabled);
}
data.val = v;
fit.value() = data;
emit QtVariantPropertyManager::valueChanged(property, data.val);
emit propertyChanged(property);
return;
} else if (m_alignValues.contains(property)) {
if (value.type() != QVariant::UInt && !value.canConvert(QVariant::UInt))
return;
const uint v = value.toUInt();
uint val = m_alignValues.value(property);
if (val == v)
return;
QtVariantProperty *alignH = variantProperty(m_propertyToAlignH.value(property));
QtVariantProperty *alignV = variantProperty(m_propertyToAlignV.value(property));
if (alignH)
alignH->setValue(alignToIndexH(v));
if (alignV)
alignV->setValue(alignToIndexV(v));
m_alignValues[property] = v;
emit QtVariantPropertyManager::valueChanged(property, v);
emit propertyChanged(property);
return;
} else if (m_stringValues.contains(property)) {
if (value.userType() != designerStringTypeId())
return;
const PropertySheetStringValue v = qVariantValue<PropertySheetStringValue>(value);
const PropertySheetStringValue val = m_stringValues.value(property);
if (val == v)
return;
QtVariantProperty *comment = variantProperty(m_stringToComment.value(property));
QtVariantProperty *translatable = variantProperty(m_stringToTranslatable.value(property));
QtVariantProperty *disambiguation = variantProperty(m_stringToDisambiguation.value(property));
if (comment)
comment->setValue(v.comment());
if (translatable)
translatable->setValue(v.translatable());
if (disambiguation)
disambiguation->setValue(v.disambiguation());
m_stringValues[property] = v;
emit QtVariantPropertyManager::valueChanged(property, qVariantFromValue(v));
emit propertyChanged(property);
return;
} else if (m_keySequenceValues.contains(property)) {
if (value.userType() != designerKeySequenceTypeId())
return;
const PropertySheetKeySequenceValue v = qVariantValue<PropertySheetKeySequenceValue>(value);
const PropertySheetKeySequenceValue val = m_keySequenceValues.value(property);
if (val == v)
return;
QtVariantProperty *comment = variantProperty(m_keySequenceToComment.value(property));
QtVariantProperty *translatable = variantProperty(m_keySequenceToTranslatable.value(property));
QtVariantProperty *disambiguation = variantProperty(m_keySequenceToDisambiguation.value(property));
if (comment)
comment->setValue(v.comment());
if (translatable)
translatable->setValue(v.translatable());
if (disambiguation)
disambiguation->setValue(v.disambiguation());
m_keySequenceValues[property] = v;
emit QtVariantPropertyManager::valueChanged(property, qVariantFromValue(v));
emit propertyChanged(property);
return;
} else if (m_paletteValues.contains(property)) {
if (value.type() != QVariant::Palette && !value.canConvert(QVariant::Palette))
return;
QPalette p = qVariantValue<QPalette>(value);
PaletteData data = m_paletteValues.value(property);
const uint mask = p.resolve();
p = p.resolve(data.superPalette);
p.resolve(mask);
if (data.val == p && data.val.resolve() == p.resolve())
return;
data.val = p;
m_paletteValues[property] = data;
emit QtVariantPropertyManager::valueChanged(property, data.val);
emit propertyChanged(property);
return;
} else if (m_iconValues.contains(property)) {
if (value.userType() != designerIconTypeId())
return;
const PropertySheetIconValue icon = qVariantValue<PropertySheetIconValue>(value);
const PropertySheetIconValue oldIcon = m_iconValues.value(property);
if (icon == oldIcon)
return;
m_iconValues[property] = icon;
QIcon defaultIcon = m_defaultIcons.value(property);
if (!icon.paths().isEmpty()) {
QDesignerFormWindowInterface *formWindow = QDesignerFormWindowInterface::findFormWindow(m_object);
qdesigner_internal::FormWindowBase *fwb = qobject_cast<qdesigner_internal::FormWindowBase *>(formWindow);
if (fwb)
defaultIcon = fwb->iconCache()->icon(icon);
}
QMap<QPair<QIcon::Mode, QIcon::State>, PropertySheetPixmapValue> iconPaths = icon.paths();
QMap<QPair<QIcon::Mode, QIcon::State>, QtProperty *> subProperties = m_propertyToIconSubProperties.value(property);
QMapIterator<QPair<QIcon::Mode, QIcon::State>, QtProperty *> itSub(subProperties);
while (itSub.hasNext()) {
const QPair<QIcon::Mode, QIcon::State> pair = itSub.next().key();
QtVariantProperty *subProperty = variantProperty(itSub.value());
bool hasPath = iconPaths.contains(pair);
subProperty->setModified(hasPath);
subProperty->setValue(qVariantFromValue(iconPaths.value(pair)));
subProperty->setAttribute(QLatin1String(defaultResourceAttributeC),
defaultIcon.pixmap(16, 16, pair.first, pair.second));
}
emit QtVariantPropertyManager::valueChanged(property, qVariantFromValue(icon));
emit propertyChanged(property);
QString toolTip;
const QMap<QPair<QIcon::Mode, QIcon::State>, PropertySheetPixmapValue>::ConstIterator itNormalOff =
iconPaths.constFind(qMakePair(QIcon::Normal, QIcon::Off));
if (itNormalOff != iconPaths.constEnd())
toolTip = itNormalOff.value().path();
property->setToolTip(toolTip);
return;
} else if (m_pixmapValues.contains(property)) {
if (value.userType() != designerPixmapTypeId())
return;
const PropertySheetPixmapValue pixmap = qVariantValue<PropertySheetPixmapValue>(value);
const PropertySheetPixmapValue oldPixmap = m_pixmapValues.value(property);
if (pixmap == oldPixmap)
return;
m_pixmapValues[property] = pixmap;
emit QtVariantPropertyManager::valueChanged(property, qVariantFromValue(pixmap));
emit propertyChanged(property);
property->setToolTip(pixmap.path());
return;
} else if (m_uintValues.contains(property)) {
if (value.type() != QVariant::UInt && !value.canConvert(QVariant::UInt))
return;
const uint v = value.toUInt(0);
const uint oldValue = m_uintValues.value(property);
if (v == oldValue)
return;
m_uintValues[property] = v;
emit QtVariantPropertyManager::valueChanged(property, v);
emit propertyChanged(property);
return;
} else if (m_longLongValues.contains(property)) {
if (value.type() != QVariant::LongLong && !value.canConvert(QVariant::LongLong))
return;
const qlonglong v = value.toLongLong(0);
const qlonglong oldValue = m_longLongValues.value(property);
if (v == oldValue)
return;
m_longLongValues[property] = v;
emit QtVariantPropertyManager::valueChanged(property, v);
emit propertyChanged(property);
return;
} else if (m_uLongLongValues.contains(property)) {
if (value.type() != QVariant::ULongLong && !value.canConvert(QVariant::ULongLong))
return;
qulonglong v = value.toULongLong(0);
qulonglong oldValue = m_uLongLongValues.value(property);
if (v == oldValue)
return;
m_uLongLongValues[property] = v;
emit QtVariantPropertyManager::valueChanged(property, v);
emit propertyChanged(property);
return;
} else if (m_urlValues.contains(property)) {
if (value.type() != QVariant::Url && !value.canConvert(QVariant::Url))
return;
const QUrl v = value.toUrl();
const QUrl oldValue = m_urlValues.value(property);
if (v == oldValue)
return;
m_urlValues[property] = v;
emit QtVariantPropertyManager::valueChanged(property, v);
emit propertyChanged(property);
return;
} else if (m_byteArrayValues.contains(property)) {
if (value.type() != QVariant::ByteArray && !value.canConvert(QVariant::ByteArray))
return;
const QByteArray v = value.toByteArray();
const QByteArray oldValue = m_byteArrayValues.value(property);
if (v == oldValue)
return;
m_byteArrayValues[property] = v;
emit QtVariantPropertyManager::valueChanged(property, v);
emit propertyChanged(property);
return;
} else if (m_stringListValues.contains(property)) {
if (value.type() != QVariant::StringList && !value.canConvert(QVariant::StringList))
return;
const QStringList v = value.toStringList();
const QStringList oldValue = m_stringListValues.value(property);
if (v == oldValue)
return;
m_stringListValues[property] = v;
emit QtVariantPropertyManager::valueChanged(property, v);
emit propertyChanged(property);
return;
}
switch (m_brushManager.setValue(this, property, value)) {
case BrushPropertyManager::Unchanged:
return;
case BrushPropertyManager::Changed:
emit QtVariantPropertyManager::valueChanged(property, value);
emit propertyChanged(property);
return;
default:
break;
}
m_fontManager.setValue(this, property, value);
QtVariantPropertyManager::setValue(property, value);
if (QtVariantPropertyManager::valueType(property) == QVariant::String)
property->setToolTip(DesignerPropertyManager::value(property).toString());
else if (QtVariantPropertyManager::valueType(property) == designerStringTypeId())
property->setToolTip(qVariantValue<PropertySheetStringValue>(DesignerPropertyManager::value(property)).value());
else if (QtVariantPropertyManager::valueType(property) == designerKeySequenceTypeId())
property->setToolTip(qVariantValue<PropertySheetKeySequenceValue>(DesignerPropertyManager::value(property)).value());
else if (QtVariantPropertyManager::valueType(property) == QVariant::Bool)
property->setToolTip(QtVariantPropertyManager::valueText(property));
}
void DesignerPropertyManager::initializeProperty(QtProperty *property)
{
m_resetMap[property] = false;
const int type = propertyType(property);
m_fontManager.preInitializeProperty(property, type, m_resetMap);
switch (type) {
case QVariant::Palette:
m_paletteValues[property] = PaletteData();
break;
case QVariant::String:
m_stringAttributes[property] = ValidationSingleLine;
m_stringFontAttributes[property] = QApplication::font();
break;
case QVariant::UInt:
m_uintValues[property] = 0;
break;
case QVariant::LongLong:
m_longLongValues[property] = 0;
break;
case QVariant::ULongLong:
m_uLongLongValues[property] = 0;
break;
case QVariant::Url:
m_urlValues[property] = QUrl();
break;
case QVariant::ByteArray:
m_byteArrayValues[property] = 0;
break;
case QVariant::StringList:
m_stringListValues[property] = QStringList();
break;
case QVariant::Brush:
m_brushManager.initializeProperty(this, property, enumTypeId());
break;
default:
if (type == designerFlagTypeId()) {
m_flagValues[property] = FlagData();
m_propertyToFlags[property] = QList<QtProperty *>();
} else if (type == designerAlignmentTypeId()) {
const uint align = Qt::AlignLeft | Qt::AlignVCenter;
m_alignValues[property] = align;
QtVariantProperty *alignH = addProperty(enumTypeId(), tr("Horizontal"));
QStringList namesH;
namesH << indexHToString(0) << indexHToString(1) << indexHToString(2) << indexHToString(3);
alignH->setAttribute(QLatin1String("enumNames"), namesH);
alignH->setValue(alignToIndexH(align));
m_propertyToAlignH[property] = alignH;
m_alignHToProperty[alignH] = property;
property->addSubProperty(alignH);
QtVariantProperty *alignV = addProperty(enumTypeId(), tr("Vertical"));
QStringList namesV;
namesV << indexVToString(0) << indexVToString(1) << indexVToString(2);
alignV->setAttribute(QLatin1String("enumNames"), namesV);
alignV->setValue(alignToIndexV(align));
m_propertyToAlignV[property] = alignV;
m_alignVToProperty[alignV] = property;
property->addSubProperty(alignV);
} else if (type == designerPixmapTypeId()) {
m_pixmapValues[property] = PropertySheetPixmapValue();
m_defaultPixmaps[property] = QPixmap();
} else if (type == designerIconTypeId()) {
m_iconValues[property] = PropertySheetIconValue();
m_defaultIcons[property] = QIcon();
createIconSubProperty(property, QIcon::Normal, QIcon::Off, tr("Normal Off"));
createIconSubProperty(property, QIcon::Normal, QIcon::On, tr("Normal On"));
createIconSubProperty(property, QIcon::Disabled, QIcon::Off, tr("Disabled Off"));
createIconSubProperty(property, QIcon::Disabled, QIcon::On, tr("Disabled On"));
createIconSubProperty(property, QIcon::Active, QIcon::Off, tr("Active Off"));
createIconSubProperty(property, QIcon::Active, QIcon::On, tr("Active On"));
createIconSubProperty(property, QIcon::Selected, QIcon::Off, tr("Selected Off"));
createIconSubProperty(property, QIcon::Selected, QIcon::On, tr("Selected On"));
} else if (type == designerStringTypeId()) {
PropertySheetStringValue val;
m_stringValues[property] = val;
m_stringAttributes[property] = ValidationMultiLine;
m_stringFontAttributes[property] = QApplication::font();
QtVariantProperty *translatable = addProperty(QVariant::Bool, tr("translatable"));
translatable->setValue(val.translatable());
m_stringToTranslatable[property] = translatable;
m_translatableToString[translatable] = property;
property->addSubProperty(translatable);
QtVariantProperty *disambiguation = addProperty(QVariant::String, tr("disambiguation"));
disambiguation->setValue(val.disambiguation());
m_stringToDisambiguation[property] = disambiguation;
m_disambiguationToString[disambiguation] = property;
property->addSubProperty(disambiguation);
QtVariantProperty *comment = addProperty(QVariant::String, tr("comment"));
comment->setValue(val.comment());
m_stringToComment[property] = comment;
m_commentToString[comment] = property;
property->addSubProperty(comment);
} else if (type == designerKeySequenceTypeId()) {
PropertySheetKeySequenceValue val;
m_keySequenceValues[property] = val;
QtVariantProperty *translatable = addProperty(QVariant::Bool, tr("translatable"));
translatable->setValue(val.translatable());
m_keySequenceToTranslatable[property] = translatable;
m_translatableToKeySequence[translatable] = property;
property->addSubProperty(translatable);
QtVariantProperty *disambiguation = addProperty(QVariant::String, tr("disambiguation"));
disambiguation->setValue(val.disambiguation());
m_keySequenceToDisambiguation[property] = disambiguation;
m_disambiguationToKeySequence[disambiguation] = property;
property->addSubProperty(disambiguation);
QtVariantProperty *comment = addProperty(QVariant::String, tr("comment"));
comment->setValue(val.comment());
m_keySequenceToComment[property] = comment;
m_commentToKeySequence[comment] = property;
property->addSubProperty(comment);
}
}
QtVariantPropertyManager::initializeProperty(property);
m_fontManager.postInitializeProperty(this, property, type, DesignerPropertyManager::enumTypeId());
if (type == QVariant::Double)
setAttribute(property, QLatin1String("decimals"), 6);
}
void DesignerPropertyManager::createIconSubProperty(QtProperty *iconProperty, QIcon::Mode mode, QIcon::State state, const QString &subName)
{
QPair<QIcon::Mode, QIcon::State> pair = qMakePair(mode, state);
QtVariantProperty *subProp = addProperty(DesignerPropertyManager::designerPixmapTypeId(), subName);
m_propertyToIconSubProperties[iconProperty][pair] = subProp;
m_iconSubPropertyToState[subProp] = pair;
m_iconSubPropertyToProperty[subProp] = iconProperty;
m_resetMap[subProp] = true;
iconProperty->addSubProperty(subProp);
}
void DesignerPropertyManager::uninitializeProperty(QtProperty *property)
{
m_resetMap.remove(property);
QListIterator<QtProperty *> itProp(m_propertyToFlags[property]);
while (itProp.hasNext()) {
QtProperty *prop = itProp.next();
if (prop) {
delete prop;
m_flagToProperty.remove(prop);
}
}
m_propertyToFlags.remove(property);
m_flagValues.remove(property);
QtProperty *alignH = m_propertyToAlignH.value(property);
if (alignH) {
delete alignH;
m_alignHToProperty.remove(alignH);
}
QtProperty *alignV = m_propertyToAlignV.value(property);
if (alignV) {
delete alignV;
m_alignVToProperty.remove(alignV);
}
QtProperty *stringComment = m_stringToComment.value(property);
if (stringComment) {
delete stringComment;
m_stringToComment.remove(stringComment);
}
QtProperty *stringTranslatable = m_stringToTranslatable.value(property);
if (stringTranslatable) {
delete stringTranslatable;
m_stringToTranslatable.remove(stringTranslatable);
}
QtProperty *stringDisambiguation = m_stringToDisambiguation.value(property);
if (stringDisambiguation) {
delete stringDisambiguation;
m_stringToDisambiguation.remove(stringDisambiguation);
}
QtProperty *keySequenceComment = m_keySequenceToComment.value(property);
if (keySequenceComment) {
delete keySequenceComment;
m_keySequenceToComment.remove(keySequenceComment);
}
QtProperty *keySequenceTranslatable = m_keySequenceToTranslatable.value(property);
if (keySequenceTranslatable) {
delete keySequenceTranslatable;
m_keySequenceToTranslatable.remove(keySequenceTranslatable);
}
QtProperty *keySequenceDisambiguation = m_keySequenceToDisambiguation.value(property);
if (keySequenceDisambiguation) {
delete keySequenceDisambiguation;
m_keySequenceToDisambiguation.remove(keySequenceDisambiguation);
}
m_propertyToAlignH.remove(property);
m_propertyToAlignV.remove(property);
m_stringToComment.remove(property);
m_stringToTranslatable.remove(property);
m_stringToDisambiguation.remove(property);
m_stringValues.remove(property);
m_stringAttributes.remove(property);
m_stringFontAttributes.remove(property);
m_keySequenceToComment.remove(property);
m_keySequenceToTranslatable.remove(property);
m_keySequenceToDisambiguation.remove(property);
m_keySequenceValues.remove(property);
m_paletteValues.remove(property);
m_iconValues.remove(property);
m_defaultIcons.remove(property);
m_pixmapValues.remove(property);
m_defaultPixmaps.remove(property);
QMap<QPair<QIcon::Mode, QIcon::State>, QtProperty *> iconSubProperties = m_propertyToIconSubProperties.value(property);
QMapIterator<QPair<QIcon::Mode, QIcon::State>, QtProperty *> itIcon(iconSubProperties);
while (itIcon.hasNext()) {
QtProperty *subIcon = itIcon.next().value();
delete subIcon;
m_iconSubPropertyToState.remove(subIcon);
m_iconSubPropertyToProperty.remove(subIcon);
}
m_propertyToIconSubProperties.remove(property);
m_iconSubPropertyToState.remove(property);
m_iconSubPropertyToProperty.remove(property);
m_uintValues.remove(property);
m_longLongValues.remove(property);
m_uLongLongValues.remove(property);
m_urlValues.remove(property);
m_byteArrayValues.remove(property);
m_stringListValues.remove(property);
m_fontManager.uninitializeProperty(property);
m_brushManager.uninitializeProperty(property);
QtVariantPropertyManager::uninitializeProperty(property);
}
bool DesignerPropertyManager::resetFontSubProperty(QtProperty *property)
{
return m_fontManager.resetFontSubProperty(this, property);
}
bool DesignerPropertyManager::resetIconSubProperty(QtProperty *property)
{
if (!m_iconSubPropertyToProperty.contains(property))
return false;
if (!m_pixmapValues.contains(property))
return false;
QtVariantProperty *pixmapProperty = variantProperty(property);
pixmapProperty->setValue(qVariantFromValue(PropertySheetPixmapValue()));
return true;
}
// -------- DesignerEditorFactory
DesignerEditorFactory::DesignerEditorFactory(QDesignerFormEditorInterface *core, QObject *parent) :
QtVariantEditorFactory(parent),
m_resetDecorator(new ResetDecorator(this)),
m_changingPropertyValue(false),
m_core(core),
m_spacing(-1)
{
connect(m_resetDecorator, SIGNAL(resetProperty(QtProperty*)), this, SIGNAL(resetProperty(QtProperty*)));
}
DesignerEditorFactory::~DesignerEditorFactory()
{
}
void DesignerEditorFactory::setSpacing(int spacing)
{
m_spacing = spacing;
m_resetDecorator->setSpacing(spacing);
}
void DesignerEditorFactory::setFormWindowBase(qdesigner_internal::FormWindowBase *fwb)
{
m_fwb = fwb;
DesignerPixmapCache *cache = 0;
if (fwb)
cache = fwb->pixmapCache();
QMapIterator<PixmapEditor *, QtProperty *> itPixmapEditor(m_editorToPixmapProperty);
while (itPixmapEditor.hasNext()) {
PixmapEditor *pe = itPixmapEditor.next().key();
pe->setPixmapCache(cache);
}
QMapIterator<PixmapEditor *, QtProperty *> itIconEditor(m_editorToIconProperty);
while (itIconEditor.hasNext()) {
PixmapEditor *pe = itIconEditor.next().key();
pe->setPixmapCache(cache);
}
}
void DesignerEditorFactory::connectPropertyManager(QtVariantPropertyManager *manager)
{
m_resetDecorator->connectPropertyManager(manager);
connect(manager, SIGNAL(attributeChanged(QtProperty*,QString,QVariant)),
this, SLOT(slotAttributeChanged(QtProperty*,QString,QVariant)));
connect(manager, SIGNAL(valueChanged(QtProperty*,QVariant)),
this, SLOT(slotValueChanged(QtProperty*,QVariant)));
connect(manager, SIGNAL(propertyChanged(QtProperty*)),
this, SLOT(slotPropertyChanged(QtProperty*)));
QtVariantEditorFactory::connectPropertyManager(manager);
}
void DesignerEditorFactory::disconnectPropertyManager(QtVariantPropertyManager *manager)
{
m_resetDecorator->disconnectPropertyManager(manager);
disconnect(manager, SIGNAL(attributeChanged(QtProperty*,QString,QVariant)),
this, SLOT(slotAttributeChanged(QtProperty*,QString,QVariant)));
disconnect(manager, SIGNAL(valueChanged(QtProperty*,QVariant)),
this, SLOT(slotValueChanged(QtProperty*,QVariant)));
disconnect(manager, SIGNAL(propertyChanged(QtProperty*)),
this, SLOT(slotPropertyChanged(QtProperty*)));
QtVariantEditorFactory::disconnectPropertyManager(manager);
}
// A helper that calls a setter with a value on a pointer list of editor objects.
// Could use QList<Editor*> instead of EditorContainer/Editor, but that crashes VS 6.
template <class EditorContainer, class Editor, class SetterParameter, class Value>
static inline void applyToEditors(const EditorContainer &list, void (Editor::*setter)(SetterParameter), const Value &value)
{
typedef Q_TYPENAME EditorContainer::const_iterator ListIterator;
if (list.empty()) {
return;
}
const ListIterator end = list.constEnd();
for (ListIterator it = list.constBegin(); it != end; ++it) {
Editor &editor = *(*it);
(editor.*setter)(value);
}
}
void DesignerEditorFactory::slotAttributeChanged(QtProperty *property, const QString &attribute, const QVariant &value)
{
QtVariantPropertyManager *manager = propertyManager(property);
const int type = manager->propertyType(property);
if (type == DesignerPropertyManager::designerPixmapTypeId() && attribute == QLatin1String(defaultResourceAttributeC)) {
const QPixmap pixmap = qvariant_cast<QPixmap>(value);
applyToEditors(m_pixmapPropertyToEditors.value(property), &PixmapEditor::setDefaultPixmap, pixmap);
} else if (type == DesignerPropertyManager::designerStringTypeId() || type == QVariant::String) {
if (attribute == QLatin1String(validationModesAttributeC)) {
const TextPropertyValidationMode validationMode = static_cast<TextPropertyValidationMode>(value.toInt());
applyToEditors(m_stringPropertyToEditors.value(property), &TextEditor::setTextPropertyValidationMode, validationMode);
}
if (attribute == QLatin1String(fontAttributeC)) {
const QFont font = qvariant_cast<QFont>(value);
applyToEditors(m_stringPropertyToEditors.value(property), &TextEditor::setRichTextDefaultFont, font);
}
} else if (type == QVariant::Palette && attribute == QLatin1String(superPaletteAttributeC)) {
const QPalette palette = qvariant_cast<QPalette>(value);
applyToEditors(m_palettePropertyToEditors.value(property), &PaletteEditorButton::setSuperPalette, palette);
}
}
void DesignerEditorFactory::slotPropertyChanged(QtProperty *property)
{
QtVariantPropertyManager *manager = propertyManager(property);
const int type = manager->propertyType(property);
if (type == DesignerPropertyManager::designerIconTypeId()) {
QPixmap defaultPixmap;
if (!property->isModified())
defaultPixmap = qvariant_cast<QIcon>(manager->attributeValue(property, QLatin1String(defaultResourceAttributeC))).pixmap(16, 16);
else if (m_fwb)
defaultPixmap = m_fwb->iconCache()->icon(qVariantValue<PropertySheetIconValue>(manager->value(property))).pixmap(16, 16);
QList<PixmapEditor *> editors = m_iconPropertyToEditors.value(property);
QListIterator<PixmapEditor *> it(editors);
while (it.hasNext()) {
PixmapEditor *editor = it.next();
editor->setDefaultPixmap(defaultPixmap);
}
}
}
void DesignerEditorFactory::slotValueChanged(QtProperty *property, const QVariant &value)
{
if (m_changingPropertyValue)
return;
QtVariantPropertyManager *manager = propertyManager(property);
const int type = manager->propertyType(property);
switch (type) {
case QVariant::String:
applyToEditors(m_stringPropertyToEditors.value(property), &TextEditor::setText, value.toString());
break;
case QVariant::Palette:
applyToEditors(m_palettePropertyToEditors.value(property), &PaletteEditorButton::setPalette, qvariant_cast<QPalette>(value));
break;
case QVariant::UInt:
applyToEditors(m_uintPropertyToEditors.value(property), &QLineEdit::setText, QString::number(value.toUInt()));
break;
case QVariant::LongLong:
applyToEditors(m_longLongPropertyToEditors.value(property), &QLineEdit::setText, QString::number(value.toLongLong()));
break;
case QVariant::ULongLong:
applyToEditors(m_uLongLongPropertyToEditors.value(property), &QLineEdit::setText, QString::number(value.toULongLong()));
break;
case QVariant::Url:
applyToEditors(m_urlPropertyToEditors.value(property), &TextEditor::setText, value.toUrl().toString());
break;
case QVariant::ByteArray:
applyToEditors(m_byteArrayPropertyToEditors.value(property), &TextEditor::setText, QString::fromUtf8(value.toByteArray()));
break;
case QVariant::StringList:
applyToEditors(m_stringListPropertyToEditors.value(property), &StringListEditorButton::setStringList, value.toStringList());
break;
default:
if (type == DesignerPropertyManager::designerIconTypeId())
applyToEditors(m_iconPropertyToEditors.value(property), &PixmapEditor::setPath, qVariantValue<PropertySheetIconValue>(value).pixmap(QIcon::Normal, QIcon::Off).path());
else if (type == DesignerPropertyManager::designerPixmapTypeId())
applyToEditors(m_pixmapPropertyToEditors.value(property), &PixmapEditor::setPath, qVariantValue<PropertySheetPixmapValue>(value).path());
else if (type == DesignerPropertyManager::designerStringTypeId())
applyToEditors(m_stringPropertyToEditors.value(property), &TextEditor::setText, qVariantValue<PropertySheetStringValue>(value).value());
else if (type == DesignerPropertyManager::designerKeySequenceTypeId())
applyToEditors(m_keySequencePropertyToEditors.value(property), &QtKeySequenceEdit::setKeySequence, qVariantValue<PropertySheetKeySequenceValue>(value).value());
break;
}
}
TextEditor *DesignerEditorFactory::createTextEditor(QWidget *parent, TextPropertyValidationMode vm, const QString &value)
{
TextEditor *rc = new TextEditor(m_core, parent);
rc->setText(value);
rc->setSpacing(m_spacing);
rc->setTextPropertyValidationMode(vm);
connect(rc, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));
return rc;
}
QWidget *DesignerEditorFactory::createEditor(QtVariantPropertyManager *manager, QtProperty *property,
QWidget *parent)
{
QWidget *editor = 0;
const int type = manager->propertyType(property);
switch (type) {
case QVariant::Bool: {
editor = QtVariantEditorFactory::createEditor(manager, property, parent);
QtBoolEdit *boolEdit = qobject_cast<QtBoolEdit *>(editor);
if (boolEdit)
boolEdit->setTextVisible(false);
}
break;
case QVariant::String: {
const TextPropertyValidationMode tvm = static_cast<TextPropertyValidationMode>(manager->attributeValue(property, QLatin1String(validationModesAttributeC)).toInt());
TextEditor *ed = createTextEditor(parent, tvm, manager->value(property).toString());
const QVariant richTextDefaultFont = manager->attributeValue(property, QLatin1String(fontAttributeC));
if (richTextDefaultFont.type() == QVariant::Font)
ed->setRichTextDefaultFont(qvariant_cast<QFont>(richTextDefaultFont));
m_stringPropertyToEditors[property].append(ed);
m_editorToStringProperty[ed] = property;
connect(ed, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));
connect(ed, SIGNAL(textChanged(QString)), this, SLOT(slotStringTextChanged(QString)));
editor = ed;
}
break;
case QVariant::Palette: {
PaletteEditorButton *ed = new PaletteEditorButton(m_core, qvariant_cast<QPalette>(manager->value(property)), parent);
ed->setSuperPalette(qvariant_cast<QPalette>(manager->attributeValue(property, QLatin1String(superPaletteAttributeC))));
m_palettePropertyToEditors[property].append(ed);
m_editorToPaletteProperty[ed] = property;
connect(ed, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));
connect(ed, SIGNAL(paletteChanged(QPalette)), this, SLOT(slotPaletteChanged(QPalette)));
editor = ed;
}
break;
case QVariant::UInt: {
QLineEdit *ed = new QLineEdit(parent);
ed->setValidator(new QULongLongValidator(0, UINT_MAX, ed));
ed->setText(QString::number(manager->value(property).toUInt()));
m_uintPropertyToEditors[property].append(ed);
m_editorToUintProperty[ed] = property;
connect(ed, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));
connect(ed, SIGNAL(textChanged(QString)), this, SLOT(slotUintChanged(QString)));
editor = ed;
}
break;
case QVariant::LongLong: {
QLineEdit *ed = new QLineEdit(parent);
ed->setValidator(new QLongLongValidator(ed));
ed->setText(QString::number(manager->value(property).toLongLong()));
m_longLongPropertyToEditors[property].append(ed);
m_editorToLongLongProperty[ed] = property;
connect(ed, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));
connect(ed, SIGNAL(textChanged(QString)), this, SLOT(slotLongLongChanged(QString)));
editor = ed;
}
break;
case QVariant::ULongLong: {
QLineEdit *ed = new QLineEdit(parent);
ed->setValidator(new QULongLongValidator(ed));
ed->setText(QString::number(manager->value(property).toULongLong()));
m_uLongLongPropertyToEditors[property].append(ed);
m_editorToULongLongProperty[ed] = property;
connect(ed, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));
connect(ed, SIGNAL(textChanged(QString)), this, SLOT(slotULongLongChanged(QString)));
editor = ed;
}
break;
case QVariant::Url: {
TextEditor *ed = createTextEditor(parent, ValidationURL, manager->value(property).toUrl().toString());
ed->setUpdateMode(TextPropertyEditor::UpdateOnFinished);
m_urlPropertyToEditors[property].append(ed);
m_editorToUrlProperty[ed] = property;
connect(ed, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));
connect(ed, SIGNAL(textChanged(QString)), this, SLOT(slotUrlChanged(QString)));
editor = ed;
}
break;
case QVariant::ByteArray: {
TextEditor *ed = createTextEditor(parent, ValidationMultiLine, QString::fromUtf8(manager->value(property).toByteArray()));
m_byteArrayPropertyToEditors[property].append(ed);
m_editorToByteArrayProperty[ed] = property;
connect(ed, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));
connect(ed, SIGNAL(textChanged(QString)), this, SLOT(slotByteArrayChanged(QString)));
editor = ed;
}
break;
case QVariant::StringList: {
StringListEditorButton *ed = new StringListEditorButton(manager->value(property).toStringList(), parent);
m_stringListPropertyToEditors[property].append(ed);
m_editorToStringListProperty[ed] = property;
connect(ed, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));
connect(ed, SIGNAL(stringListChanged(QStringList)), this, SLOT(slotStringListChanged(QStringList)));
editor = ed;
}
break;
default:
if (type == DesignerPropertyManager::designerPixmapTypeId()) {
PixmapEditor *ed = new PixmapEditor(m_core, parent);
ed->setPixmapCache(m_fwb->pixmapCache());
ed->setPath(qvariant_cast<PropertySheetPixmapValue>(manager->value(property)).path());
ed->setDefaultPixmap(qvariant_cast<QPixmap>(manager->attributeValue(property, QLatin1String(defaultResourceAttributeC))));
ed->setSpacing(m_spacing);
m_pixmapPropertyToEditors[property].append(ed);
m_editorToPixmapProperty[ed] = property;
connect(ed, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));
connect(ed, SIGNAL(pathChanged(QString)), this, SLOT(slotPixmapChanged(QString)));
editor = ed;
} else if (type == DesignerPropertyManager::designerIconTypeId()) {
PixmapEditor *ed = new PixmapEditor(m_core, parent);
ed->setPixmapCache(m_fwb->pixmapCache());
PropertySheetIconValue value = qvariant_cast<PropertySheetIconValue>(manager->value(property));
ed->setPath(value.pixmap(QIcon::Normal, QIcon::Off).path());
QPixmap defaultPixmap;
if (!property->isModified())
defaultPixmap = qvariant_cast<QIcon>(manager->attributeValue(property, QLatin1String(defaultResourceAttributeC))).pixmap(16, 16);
else if (m_fwb)
defaultPixmap = m_fwb->iconCache()->icon(value).pixmap(16, 16);
ed->setDefaultPixmap(defaultPixmap);
ed->setSpacing(m_spacing);
m_iconPropertyToEditors[property].append(ed);
m_editorToIconProperty[ed] = property;
connect(ed, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));
connect(ed, SIGNAL(pathChanged(QString)), this, SLOT(slotIconChanged(QString)));
editor = ed;
} else if (type == DesignerPropertyManager::designerStringTypeId()) {
const TextPropertyValidationMode tvm = static_cast<TextPropertyValidationMode>(manager->attributeValue(property, QLatin1String(validationModesAttributeC)).toInt());
TextEditor *ed = createTextEditor(parent, tvm, qVariantValue<PropertySheetStringValue>(manager->value(property)).value());
const QVariant richTextDefaultFont = manager->attributeValue(property, QLatin1String(fontAttributeC));
if (richTextDefaultFont.type() == QVariant::Font)
ed->setRichTextDefaultFont(qvariant_cast<QFont>(richTextDefaultFont));
m_stringPropertyToEditors[property].append(ed);
m_editorToStringProperty[ed] = property;
connect(ed, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));
connect(ed, SIGNAL(textChanged(QString)), this, SLOT(slotStringTextChanged(QString)));
editor = ed;
} else if (type == DesignerPropertyManager::designerKeySequenceTypeId()) {
QtKeySequenceEdit *ed = new QtKeySequenceEdit(parent);
ed->setKeySequence(qVariantValue<PropertySheetKeySequenceValue>(manager->value(property)).value());
m_keySequencePropertyToEditors[property].append(ed);
m_editorToKeySequenceProperty[ed] = property;
connect(ed, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));
connect(ed, SIGNAL(keySequenceChanged(QKeySequence)), this, SLOT(slotKeySequenceChanged(QKeySequence)));
editor = ed;
} else {
editor = QtVariantEditorFactory::createEditor(manager, property, parent);
}
break;
}
return m_resetDecorator->editor(editor,
manager->variantProperty(property)->attributeValue(QLatin1String(resettableAttributeC)).toBool(),
manager, property, parent);
}
template <class Editor>
bool removeEditor(QObject *object,
QMap<QtProperty *, QList<Editor> > *propertyToEditors,
QMap<Editor, QtProperty *> *editorToProperty)
{
if (!propertyToEditors)
return false;
if (!editorToProperty)
return false;
QMapIterator<Editor, QtProperty *> it(*editorToProperty);
while (it.hasNext()) {
Editor editor = it.next().key();
if (editor == object) {
QtProperty *prop = it.value();
(*propertyToEditors)[prop].removeAll(editor);
if ((*propertyToEditors)[prop].count() == 0)
propertyToEditors->remove(prop);
editorToProperty->remove(editor);
return true;
}
}
return false;
}
void DesignerEditorFactory::slotEditorDestroyed(QObject *object)
{
if (removeEditor(object, &m_stringPropertyToEditors, &m_editorToStringProperty))
return;
if (removeEditor(object, &m_keySequencePropertyToEditors, &m_editorToKeySequenceProperty))
return;
if (removeEditor(object, &m_palettePropertyToEditors, &m_editorToPaletteProperty))
return;
if (removeEditor(object, &m_pixmapPropertyToEditors, &m_editorToPixmapProperty))
return;
if (removeEditor(object, &m_iconPropertyToEditors, &m_editorToIconProperty))
return;
if (removeEditor(object, &m_uintPropertyToEditors, &m_editorToUintProperty))
return;
if (removeEditor(object, &m_longLongPropertyToEditors, &m_editorToLongLongProperty))
return;
if (removeEditor(object, &m_uLongLongPropertyToEditors, &m_editorToULongLongProperty))
return;
if (removeEditor(object, &m_urlPropertyToEditors, &m_editorToUrlProperty))
return;
if (removeEditor(object, &m_byteArrayPropertyToEditors, &m_editorToByteArrayProperty))
return;
if (removeEditor(object, &m_stringListPropertyToEditors, &m_editorToStringListProperty))
return;
}
template<class Editor>
bool updateManager(QtVariantEditorFactory *factory, bool *changingPropertyValue,
const QMap<Editor, QtProperty *> &editorToProperty, QWidget *editor, const QVariant &value)
{
if (!editor)
return false;
QMapIterator<Editor, QtProperty *> it(editorToProperty);
while (it.hasNext()) {
if (it.next().key() == editor) {
QtProperty *prop = it.value();
QtVariantPropertyManager *manager = factory->propertyManager(prop);
*changingPropertyValue = true;
manager->variantProperty(prop)->setValue(value);
*changingPropertyValue = false;
return true;
}
}
return false;
}
void DesignerEditorFactory::slotUintChanged(const QString &value)
{
updateManager(this, &m_changingPropertyValue, m_editorToUintProperty, qobject_cast<QWidget *>(sender()), value.toUInt());
}
void DesignerEditorFactory::slotLongLongChanged(const QString &value)
{
updateManager(this, &m_changingPropertyValue, m_editorToLongLongProperty, qobject_cast<QWidget *>(sender()), value.toLongLong());
}
void DesignerEditorFactory::slotULongLongChanged(const QString &value)
{
updateManager(this, &m_changingPropertyValue, m_editorToULongLongProperty, qobject_cast<QWidget *>(sender()), value.toULongLong());
}
void DesignerEditorFactory::slotUrlChanged(const QString &value)
{
updateManager(this, &m_changingPropertyValue, m_editorToUrlProperty, qobject_cast<QWidget *>(sender()), QUrl(value));
}
void DesignerEditorFactory::slotByteArrayChanged(const QString &value)
{
updateManager(this, &m_changingPropertyValue, m_editorToByteArrayProperty, qobject_cast<QWidget *>(sender()), value.toUtf8());
}
void DesignerEditorFactory::slotStringTextChanged(const QString &value)
{
QMapIterator<TextEditor *, QtProperty *> it(m_editorToStringProperty);
while (it.hasNext()) {
if (it.next().key() == sender()) {
QtProperty *prop = it.value();
QtVariantPropertyManager *manager = propertyManager(prop);
QtVariantProperty *varProp = manager->variantProperty(prop);
QVariant val = varProp->value();
if (val.userType() == DesignerPropertyManager::designerStringTypeId()) {
PropertySheetStringValue strVal = qVariantValue<PropertySheetStringValue>(val);
strVal.setValue(value);
// Disable translation if no translation subproperties exist.
if (varProp->subProperties().empty())
strVal.setTranslatable(false);
val = qVariantFromValue(strVal);
} else {
val = QVariant(value);
}
m_changingPropertyValue = true;
manager->variantProperty(prop)->setValue(val);
m_changingPropertyValue = false;
}
}
}
void DesignerEditorFactory::slotKeySequenceChanged(const QKeySequence &value)
{
QMapIterator<QtKeySequenceEdit *, QtProperty *> it(m_editorToKeySequenceProperty);
while (it.hasNext()) {
if (it.next().key() == sender()) {
QtProperty *prop = it.value();
QtVariantPropertyManager *manager = propertyManager(prop);
QtVariantProperty *varProp = manager->variantProperty(prop);
QVariant val = varProp->value();
if (val.userType() == DesignerPropertyManager::designerKeySequenceTypeId()) {
PropertySheetKeySequenceValue keyVal = qVariantValue<PropertySheetKeySequenceValue>(val);
keyVal.setValue(value);
val = qVariantFromValue(keyVal);
} else {
val = qVariantFromValue(value);
}
m_changingPropertyValue = true;
manager->variantProperty(prop)->setValue(val);
m_changingPropertyValue = false;
}
}
}
void DesignerEditorFactory::slotPaletteChanged(const QPalette &value)
{
updateManager(this, &m_changingPropertyValue, m_editorToPaletteProperty, qobject_cast<QWidget *>(sender()), qVariantFromValue(value));
}
void DesignerEditorFactory::slotPixmapChanged(const QString &value)
{
updateManager(this, &m_changingPropertyValue, m_editorToPixmapProperty, qobject_cast<QWidget *>(sender()),
qVariantFromValue(PropertySheetPixmapValue(value)));
}
void DesignerEditorFactory::slotIconChanged(const QString &value)
{
updateManager(this, &m_changingPropertyValue, m_editorToIconProperty, qobject_cast<QWidget *>(sender()),
qVariantFromValue(PropertySheetIconValue(PropertySheetPixmapValue(value))));
}
void DesignerEditorFactory::slotStringListChanged(const QStringList &value)
{
updateManager(this, &m_changingPropertyValue, m_editorToStringListProperty, qobject_cast<QWidget *>(sender()), qVariantFromValue(value));
}
ResetDecorator::~ResetDecorator()
{
QList<ResetWidget *> editors = m_resetWidgetToProperty.keys();
QListIterator<ResetWidget *> it(editors);
while (it.hasNext())
delete it.next();
}
void ResetDecorator::connectPropertyManager(QtAbstractPropertyManager *manager)
{
connect(manager, SIGNAL(propertyChanged(QtProperty*)),
this, SLOT(slotPropertyChanged(QtProperty*)));
}
void ResetDecorator::disconnectPropertyManager(QtAbstractPropertyManager *manager)
{
disconnect(manager, SIGNAL(propertyChanged(QtProperty*)),
this, SLOT(slotPropertyChanged(QtProperty*)));
}
void ResetDecorator::setSpacing(int spacing)
{
m_spacing = spacing;
}
QWidget *ResetDecorator::editor(QWidget *subEditor, bool resettable, QtAbstractPropertyManager *manager, QtProperty *property,
QWidget *parent)
{
Q_UNUSED(manager)
ResetWidget *resetWidget = 0;
if (resettable) {
resetWidget = new ResetWidget(property, parent);
resetWidget->setSpacing(m_spacing);
resetWidget->setResetEnabled(property->isModified());
resetWidget->setValueText(property->valueText());
resetWidget->setValueIcon(property->valueIcon());
resetWidget->setAutoFillBackground(true);
connect(resetWidget, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));
connect(resetWidget, SIGNAL(resetProperty(QtProperty*)), this, SIGNAL(resetProperty(QtProperty*)));
m_createdResetWidgets[property].append(resetWidget);
m_resetWidgetToProperty[resetWidget] = property;
}
if (subEditor) {
if (resetWidget) {
subEditor->setParent(resetWidget);
resetWidget->setWidget(subEditor);
}
}
if (resetWidget)
return resetWidget;
return subEditor;
}
void ResetDecorator::slotPropertyChanged(QtProperty *property)
{
QMap<QtProperty *, QList<ResetWidget *> >::ConstIterator prIt = m_createdResetWidgets.constFind(property);
if (prIt == m_createdResetWidgets.constEnd())
return;
const QList<ResetWidget *> editors = prIt.value();
const QList<ResetWidget *>::ConstIterator cend = editors.constEnd();
for (QList<ResetWidget *>::ConstIterator itEditor = editors.constBegin(); itEditor != cend; ++itEditor) {
ResetWidget *widget = *itEditor;
widget->setResetEnabled(property->isModified());
widget->setValueText(property->valueText());
widget->setValueIcon(property->valueIcon());
}
}
void ResetDecorator::slotEditorDestroyed(QObject *object)
{
const QMap<ResetWidget *, QtProperty *>::ConstIterator rcend = m_resetWidgetToProperty.constEnd();
for (QMap<ResetWidget *, QtProperty *>::ConstIterator itEditor = m_resetWidgetToProperty.constBegin(); itEditor != rcend; ++itEditor) {
if (itEditor.key() == object) {
ResetWidget *editor = itEditor.key();
QtProperty *property = itEditor.value();
m_resetWidgetToProperty.remove(editor);
m_createdResetWidgets[property].removeAll(editor);
if (m_createdResetWidgets[property].isEmpty())
m_createdResetWidgets.remove(property);
return;
}
}
}
}
QT_END_NAMESPACE
#include "designerpropertymanager.moc"