1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Designer of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "designerpropertymanager.h"

    43 #include "qtpropertymanager.h"

    44 #include "paletteeditorbutton.h"

    45 #include "qlonglongvalidator.h"

    46 #include "stringlisteditorbutton.h"

    47 #include "qtresourceview_p.h"

    48 #include "qtpropertybrowserutils_p.h"

    49 

    50 #include <formwindowbase_p.h>

    51 #include <textpropertyeditor_p.h>

    52 #include <stylesheeteditor_p.h>

    53 #include <richtexteditor_p.h>

    54 #include <plaintexteditor_p.h>

    55 #include <iconloader_p.h>

    56 #include <iconselector_p.h>

    57 #include <abstractdialoggui_p.h>

    58 

    59 #include <QtDesigner/QDesignerIconCacheInterface>

    60 

    61 #include <QtGui/QLabel>

    62 #include <QtGui/QToolButton>

    63 #include <QtGui/QHBoxLayout>

    64 #include <QtCore/QFileInfo>

    65 #include <QtGui/QClipboard>

    66 #include <QtGui/QLineEdit>

    67 #include <QtGui/QDialogButtonBox>

    68 #include <QtGui/QPushButton>

    69 #include <QtGui/QFileDialog>

    70 #include <QtGui/QAction>

    71 #include <QtGui/QMenu>

    72 #include <QtGui/QContextMenuEvent>

    73 #include <QtGui/QApplication>

    74 #include <QtCore/QUrl>

    75 

    76 #include <QtCore/QDebug>

    77 

    78 QT_BEGIN_NAMESPACE

    79 

    80 static const char *resettableAttributeC = "resettable";

    81 static const char *flagsAttributeC = "flags";

    82 static const char *validationModesAttributeC = "validationMode";

    83 static const char *superPaletteAttributeC = "superPalette";

    84 static const char *defaultResourceAttributeC = "defaultResource";

    85 static const char *fontAttributeC = "font";

    86 

    87 class DesignerFlagPropertyType

    88 {

    89 };

    90 

    91 

    92 class DesignerAlignmentPropertyType

    93 {

    94 };

    95 

    96 QT_END_NAMESPACE

    97 

    98 Q_DECLARE_METATYPE(DesignerFlagPropertyType)

    99 Q_DECLARE_METATYPE(DesignerAlignmentPropertyType)

   100 

   101 QT_BEGIN_NAMESPACE

   102 

   103 namespace qdesigner_internal {

   104 

   105 // ------------ TextEditor

   106 class TextEditor : public QWidget

   107 {

   108     Q_OBJECT

   109 public:

   110     TextEditor(QDesignerFormEditorInterface *core, QWidget *parent);

   111 

   112     TextPropertyValidationMode textPropertyValidationMode() const;

   113     void setTextPropertyValidationMode(TextPropertyValidationMode vm);

   114 

   115     void setRichTextDefaultFont(const QFont &font) { m_richTextDefaultFont = font; }

   116     QFont richTextDefaultFont() const { return  m_richTextDefaultFont; }

   117 

   118     void setSpacing(int spacing);

   119 

   120     TextPropertyEditor::UpdateMode updateMode() const     { return m_editor->updateMode(); }

   121     void setUpdateMode(TextPropertyEditor::UpdateMode um) { m_editor->setUpdateMode(um); }

   122 

   123 public slots:

   124     void setText(const QString &text);

   125 

   126 signals:

   127     void textChanged(const QString &text);

   128 

   129 private slots:

   130     void buttonClicked();

   131     void resourceActionActivated();

   132     void fileActionActivated();

   133 private:

   134     TextPropertyEditor *m_editor;

   135     QFont m_richTextDefaultFont;

   136     QToolButton *m_button;

   137     QMenu *m_menu;

   138     QAction *m_resourceAction;

   139     QAction *m_fileAction;

   140     QHBoxLayout *m_layout;

   141     QDesignerFormEditorInterface *m_core;

   142 };

   143 

   144 TextEditor::TextEditor(QDesignerFormEditorInterface *core, QWidget *parent) :

   145     QWidget(parent),

   146     m_editor(new TextPropertyEditor(this)),

   147     m_richTextDefaultFont(QApplication::font()),

   148     m_button(new QToolButton(this)),

   149     m_menu(new QMenu(this)),

   150     m_resourceAction(new QAction(tr("Choose Resource..."), this)),

   151     m_fileAction(new QAction(tr("Choose File..."), this)),

   152     m_layout(new QHBoxLayout(this)),

   153     m_core(core)

   154 {

   155     m_layout->addWidget(m_editor);

   156     m_button->setText(tr("..."));

   157     m_button->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Ignored);

   158     m_button->setFixedWidth(20);

   159     m_layout->addWidget(m_button);

   160     m_layout->setMargin(0);

   161     m_layout->setSpacing(0);

   162 

   163     connect(m_resourceAction, SIGNAL(triggered()), this, SLOT(resourceActionActivated()));

   164     connect(m_fileAction, SIGNAL(triggered()), this, SLOT(fileActionActivated()));

   165     connect(m_editor, SIGNAL(textChanged(QString)), this, SIGNAL(textChanged(QString)));

   166     connect(m_button, SIGNAL(clicked()), this, SLOT(buttonClicked()));

   167     setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));

   168     m_button->setVisible(false);

   169     setFocusProxy(m_editor);

   170 

   171     m_menu->addAction(m_resourceAction);

   172     m_menu->addAction(m_fileAction);

   173 }

   174 

   175 void TextEditor::setSpacing(int spacing)

   176 {

   177     m_layout->setSpacing(spacing);

   178 }

   179 

   180 TextPropertyValidationMode TextEditor::textPropertyValidationMode() const

   181 {

   182     return m_editor->textPropertyValidationMode();

   183 }

   184 

   185 void TextEditor::setTextPropertyValidationMode(TextPropertyValidationMode vm)

   186 {

   187     m_editor->setTextPropertyValidationMode(vm);

   188     if (vm == ValidationURL) {

   189         m_button->setMenu(m_menu);

   190         m_button->setFixedWidth(30);

   191         m_button->setPopupMode(QToolButton::MenuButtonPopup);

   192     } else {

   193         m_button->setMenu(0);

   194         m_button->setFixedWidth(20);

   195         m_button->setPopupMode(QToolButton::DelayedPopup);

   196     }

   197     m_button->setVisible(vm == ValidationStyleSheet || vm == ValidationRichText || vm == ValidationMultiLine || vm == ValidationURL);

   198 }

   199 

   200 void TextEditor::setText(const QString &text)

   201 {

   202     m_editor->setText(text);

   203 }

   204 

   205 void TextEditor::buttonClicked()

   206 {

   207     const QString oldText = m_editor->text();

   208     QString newText;

   209     switch (textPropertyValidationMode()) {

   210     case ValidationStyleSheet: {

   211         StyleSheetEditorDialog dlg(m_core, this);

   212         dlg.setText(oldText);

   213         if (dlg.exec() != QDialog::Accepted)

   214             return;

   215         newText = dlg.text();

   216     }

   217         break;

   218     case ValidationRichText: {

   219         RichTextEditorDialog dlg(m_core, this);

   220         dlg.setDefaultFont(m_richTextDefaultFont);

   221         dlg.setText(oldText);

   222         if (dlg.showDialog() != QDialog::Accepted)

   223             return;

   224         newText = dlg.text(Qt::AutoText);

   225     }

   226         break;

   227     case ValidationMultiLine: {

   228         PlainTextEditorDialog dlg(m_core, this);

   229         dlg.setDefaultFont(m_richTextDefaultFont);

   230         dlg.setText(oldText);

   231         if (dlg.showDialog() != QDialog::Accepted)

   232             return;

   233         newText = dlg.text();

   234     }

   235         break;

   236     case ValidationURL: {

   237         QString oldPath = oldText;

   238         if (oldPath.isEmpty() || oldPath.startsWith(QLatin1String("qrc:")))

   239             resourceActionActivated();

   240         else

   241             fileActionActivated();

   242     }

   243         return;

   244     default:

   245         return;

   246     }

   247     if (newText != oldText) {

   248         m_editor->setText(newText);

   249         emit textChanged(newText);

   250     }

   251 }

   252 

   253 void TextEditor::resourceActionActivated()

   254 {

   255     QString oldPath = m_editor->text();

   256     if (oldPath.startsWith(QLatin1String("qrc:")))

   257         oldPath.remove(0, 4);

   258     // returns ':/file'

   259     QString newPath = IconSelector::choosePixmapResource(m_core, m_core->resourceModel(), oldPath, this);

   260     if (newPath.startsWith(QLatin1Char(':')))

   261          newPath.remove(0, 1);

   262     if (newPath.isEmpty() || newPath == oldPath)

   263         return;

   264     const QString newText = QLatin1String("qrc:") + newPath;

   265     m_editor->setText(newText);

   266     emit textChanged(newText);

   267 }

   268 

   269 void TextEditor::fileActionActivated()

   270 {

   271     QString oldPath = m_editor->text();

   272     if (oldPath.startsWith(QLatin1String("file:")))

   273         oldPath = oldPath.mid(5);

   274     const QString newPath = m_core->dialogGui()->getOpenFileName(this, tr("Choose a File"), oldPath);

   275     if (newPath.isEmpty() || newPath == oldPath)

   276         return;

   277     const QString newText = QUrl::fromLocalFile(newPath).toString();

   278     m_editor->setText(newText);

   279     emit textChanged(newText);

   280 }

   281 

   282 // ------------ PixmapEditor

   283 class PixmapEditor : public QWidget

   284 {

   285     Q_OBJECT

   286 public:

   287     PixmapEditor(QDesignerFormEditorInterface *core, QWidget *parent);

   288 

   289     void setSpacing(int spacing);

   290     void setPixmapCache(DesignerPixmapCache *cache);

   291 public slots:

   292     void setPath(const QString &path);

   293     void setDefaultPixmap(const QPixmap &pixmap);

   294 

   295 signals:

   296     void pathChanged(const QString &path);

   297 

   298 protected:

   299     void contextMenuEvent(QContextMenuEvent *event);

   300 

   301 private slots:

   302     void defaultActionActivated();

   303     void resourceActionActivated();

   304     void fileActionActivated();

   305     void copyActionActivated();

   306     void pasteActionActivated();

   307     void clipboardDataChanged();

   308 private:

   309     QDesignerFormEditorInterface *m_core;

   310     QLabel *m_pixmapLabel;

   311     QLabel *m_pathLabel;

   312     QToolButton *m_button;

   313     QAction *m_resourceAction;

   314     QAction *m_fileAction;

   315     QAction *m_copyAction;

   316     QAction *m_pasteAction;

   317     QHBoxLayout *m_layout;

   318     QPixmap m_defaultPixmap;

   319     QString m_path;

   320     DesignerPixmapCache *m_pixmapCache;

   321 };

   322 

   323 PixmapEditor::PixmapEditor(QDesignerFormEditorInterface *core, QWidget *parent) :

   324     QWidget(parent),

   325     m_core(core),

   326     m_pixmapLabel(new QLabel(this)),

   327     m_pathLabel(new QLabel(this)),

   328     m_button(new QToolButton(this)),

   329     m_resourceAction(new QAction(tr("Choose Resource..."), this)),

   330     m_fileAction(new QAction(tr("Choose File..."), this)),

   331     m_copyAction(new QAction(createIconSet(QLatin1String("editcopy.png")), tr("Copy Path"), this)),

   332     m_pasteAction(new QAction(createIconSet(QLatin1String("editpaste.png")), tr("Paste Path"), this)),

   333     m_layout(new QHBoxLayout(this)),

   334     m_pixmapCache(0)

   335 {

   336     m_layout->addWidget(m_pixmapLabel);

   337     m_layout->addWidget(m_pathLabel);

   338     m_button->setText(tr("..."));

   339     m_button->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Ignored);

   340     m_button->setFixedWidth(30);

   341     m_button->setPopupMode(QToolButton::MenuButtonPopup);

   342     m_layout->addWidget(m_button);

   343     m_layout->setMargin(0);

   344     m_layout->setSpacing(0);

   345     m_pixmapLabel->setFixedWidth(16);

   346     m_pixmapLabel->setAlignment(Qt::AlignCenter);

   347     m_pathLabel->setSizePolicy(QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed));

   348 

   349     QMenu *menu = new QMenu(this);

   350     menu->addAction(m_resourceAction);

   351     menu->addAction(m_fileAction);

   352 

   353     m_button->setMenu(menu);

   354     m_button->setText(tr("..."));

   355 

   356     connect(m_button, SIGNAL(clicked()), this, SLOT(defaultActionActivated()));

   357     connect(m_resourceAction, SIGNAL(triggered()), this, SLOT(resourceActionActivated()));

   358     connect(m_fileAction, SIGNAL(triggered()), this, SLOT(fileActionActivated()));

   359     connect(m_copyAction, SIGNAL(triggered()), this, SLOT(copyActionActivated()));

   360     connect(m_pasteAction, SIGNAL(triggered()), this, SLOT(pasteActionActivated()));

   361     setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Ignored));

   362     setFocusProxy(m_button);

   363 

   364     connect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(clipboardDataChanged()));

   365     clipboardDataChanged();

   366 }

   367 

   368 void PixmapEditor::setPixmapCache(DesignerPixmapCache *cache)

   369 {

   370     m_pixmapCache = cache;

   371 }

   372 

   373 void PixmapEditor::setSpacing(int spacing)

   374 {

   375     m_layout->setSpacing(spacing);

   376 }

   377 

   378 void PixmapEditor::setPath(const QString &path)

   379 {

   380     m_path = path;

   381     if (m_path.isEmpty()) {

   382         m_pathLabel->setText(path);

   383         m_pixmapLabel->setPixmap(m_defaultPixmap);

   384         m_copyAction->setEnabled(false);

   385     } else {

   386         m_pathLabel->setText(QFileInfo(m_path).fileName());

   387         if (m_pixmapCache)

   388             m_pixmapLabel->setPixmap(QIcon(m_pixmapCache->pixmap(PropertySheetPixmapValue(path))).pixmap(16, 16));

   389         m_copyAction->setEnabled(true);

   390     }

   391 }

   392 

   393 void PixmapEditor::setDefaultPixmap(const QPixmap &pixmap)

   394 {

   395     m_defaultPixmap = QIcon(pixmap).pixmap(16, 16);

   396     if (m_path.isEmpty())

   397         m_pixmapLabel->setPixmap(m_defaultPixmap);

   398 }

   399 

   400 void PixmapEditor::contextMenuEvent(QContextMenuEvent *event)

   401 {

   402     QMenu menu(this);

   403     menu.addAction(m_copyAction);

   404     menu.addAction(m_pasteAction);

   405     menu.exec(event->globalPos());

   406     event->accept();

   407 }

   408 

   409 void PixmapEditor::defaultActionActivated()

   410 {

   411     // Default to resource

   412     const PropertySheetPixmapValue::PixmapSource ps = m_path.isEmpty() ? PropertySheetPixmapValue::ResourcePixmap : PropertySheetPixmapValue::getPixmapSource(m_core, m_path);

   413     switch (ps) {

   414     case PropertySheetPixmapValue::LanguageResourcePixmap:

   415     case PropertySheetPixmapValue::ResourcePixmap:

   416         resourceActionActivated();

   417         break;

   418     case PropertySheetPixmapValue::FilePixmap:

   419         fileActionActivated();

   420         break;

   421     }

   422 }

   423 

   424 void PixmapEditor::resourceActionActivated()

   425 {

   426     const QString oldPath = m_path;

   427     const  QString newPath = IconSelector::choosePixmapResource(m_core, m_core->resourceModel(), oldPath, this);

   428     if (!newPath.isEmpty() &&  newPath != oldPath) {

   429         setPath(newPath);

   430         emit pathChanged(newPath);

   431     }

   432 }

   433 

   434 void PixmapEditor::fileActionActivated()

   435 {

   436     const QString newPath = IconSelector::choosePixmapFile(m_path, m_core->dialogGui(), this);

   437     if (!newPath.isEmpty() && newPath != m_path) {

   438         setPath(newPath);

   439         emit pathChanged(newPath);

   440     }

   441 }

   442 

   443 void PixmapEditor::copyActionActivated()

   444 {

   445     QClipboard *clipboard = QApplication::clipboard();

   446     clipboard->setText(m_path);

   447 }

   448 

   449 void PixmapEditor::pasteActionActivated()

   450 {

   451     QClipboard *clipboard = QApplication::clipboard();

   452     QString subtype = QLatin1String("plain");

   453     QString text = clipboard->text(subtype);

   454     if (!text.isNull()) {

   455         QStringList list = text.split(QLatin1Char('\n'));

   456         if (list.size() > 0) {

   457             text = list.at(0);

   458             setPath(text);

   459             emit pathChanged(text);

   460         }

   461     }

   462 }

   463 

   464 void PixmapEditor::clipboardDataChanged()

   465 {

   466     QClipboard *clipboard = QApplication::clipboard();

   467     QString subtype = QLatin1String("plain");

   468     const QString text = clipboard->text(subtype);

   469     m_pasteAction->setEnabled(!text.isNull());

   470 }

   471 

   472 // --------------- ResetWidget

   473 class ResetWidget : public QWidget

   474 {

   475     Q_OBJECT

   476 public:

   477     ResetWidget(QtProperty *property, QWidget *parent = 0);

   478 

   479     void setWidget(QWidget *widget);

   480     void setResetEnabled(bool enabled);

   481     void setValueText(const QString &text);

   482     void setValueIcon(const QIcon &icon);

   483     void setSpacing(int spacing);

   484 signals:

   485     void resetProperty(QtProperty *property);

   486 private slots:

   487     void slotClicked();

   488 private:

   489     QtProperty *m_property;

   490     QLabel *m_textLabel;

   491     QLabel *m_iconLabel;

   492     QToolButton *m_button;

   493     int m_spacing;

   494 };

   495 

   496 ResetWidget::ResetWidget(QtProperty *property, QWidget *parent) :

   497     QWidget(parent),

   498     m_property(property),

   499     m_textLabel(new QLabel(this)),

   500     m_iconLabel(new QLabel(this)),

   501     m_button(new QToolButton(this)),

   502     m_spacing(-1)

   503 {

   504     m_textLabel->setSizePolicy(QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed));

   505     m_iconLabel->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));

   506     m_button->setToolButtonStyle(Qt::ToolButtonIconOnly);

   507     m_button->setIcon(createIconSet(QLatin1String("resetproperty.png")));

   508     m_button->setIconSize(QSize(8,8));

   509     m_button->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::MinimumExpanding));

   510     connect(m_button, SIGNAL(clicked()), this, SLOT(slotClicked()));

   511     QLayout *layout = new QHBoxLayout(this);

   512     layout->setMargin(0);

   513     layout->setSpacing(m_spacing);

   514     layout->addWidget(m_iconLabel);

   515     layout->addWidget(m_textLabel);

   516     layout->addWidget(m_button);

   517     setFocusProxy(m_textLabel);

   518     setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));

   519 }

   520 

   521 void ResetWidget::setSpacing(int spacing)

   522 {

   523     m_spacing = spacing;

   524     layout()->setSpacing(m_spacing);

   525 }

   526 

   527 void ResetWidget::setWidget(QWidget *widget)

   528 {

   529     if (m_textLabel) {

   530         delete m_textLabel;

   531         m_textLabel = 0;

   532     }

   533     if (m_iconLabel) {

   534         delete m_iconLabel;

   535         m_iconLabel = 0;

   536     }

   537     delete layout();

   538     QLayout *layout = new QHBoxLayout(this);

   539     layout->setMargin(0);

   540     layout->setSpacing(m_spacing);

   541     layout->addWidget(widget);

   542     layout->addWidget(m_button);

   543     setFocusProxy(widget);

   544 }

   545 

   546 void ResetWidget::setResetEnabled(bool enabled)

   547 {

   548     m_button->setEnabled(enabled);

   549 }

   550 

   551 void ResetWidget::setValueText(const QString &text)

   552 {

   553     if (m_textLabel)

   554         m_textLabel->setText(text);

   555 }

   556 

   557 void ResetWidget::setValueIcon(const QIcon &icon)

   558 {

   559     QPixmap pix = icon.pixmap(QSize(16, 16));

   560     if (m_iconLabel) {

   561         m_iconLabel->setVisible(!pix.isNull());

   562         m_iconLabel->setPixmap(pix);

   563     }

   564 }

   565 

   566 void ResetWidget::slotClicked()

   567 {

   568     emit resetProperty(m_property);

   569 }

   570 

   571 

   572 // ------------ DesignerPropertyManager:

   573 

   574 DesignerPropertyManager::DesignerPropertyManager(QDesignerFormEditorInterface *core, QObject *parent) :

   575     QtVariantPropertyManager(parent),

   576     m_changingSubValue(false),

   577     m_core(core),

   578     m_sourceOfChange(0)

   579 {

   580     connect(this, SIGNAL(valueChanged(QtProperty*,QVariant)), this, SLOT(slotValueChanged(QtProperty*, QVariant)));

   581     connect(this, SIGNAL(propertyDestroyed(QtProperty*)), this, SLOT(slotPropertyDestroyed(QtProperty*)));

   582 }

   583 

   584 DesignerPropertyManager::~DesignerPropertyManager()

   585 {

   586     clear();

   587 }

   588 

   589 int DesignerPropertyManager::bitCount(int mask) const

   590 {

   591     int count = 0;

   592     for (; mask; count++)

   593         mask &= mask - 1; // clear the least significant bit set

   594     return count;

   595 }

   596 

   597 int DesignerPropertyManager::alignToIndexH(uint align) const

   598 {

   599     if (align & Qt::AlignLeft)

   600         return 0;

   601     if (align & Qt::AlignHCenter)

   602         return 1;

   603     if (align & Qt::AlignRight)

   604         return 2;

   605     if (align & Qt::AlignJustify)

   606         return 3;

   607     return 0;

   608 }

   609 

   610 int DesignerPropertyManager::alignToIndexV(uint align) const

   611 {

   612     if (align & Qt::AlignTop)

   613         return 0;

   614     if (align & Qt::AlignVCenter)

   615         return 1;

   616     if (align & Qt::AlignBottom)

   617         return 2;

   618     return 1;

   619 }

   620 

   621 uint DesignerPropertyManager::indexHToAlign(int idx) const

   622 {

   623     switch (idx) {

   624         case 0: return Qt::AlignLeft;

   625         case 1: return Qt::AlignHCenter;

   626         case 2: return Qt::AlignRight;

   627         case 3: return Qt::AlignJustify;

   628         default: break;

   629     }

   630     return Qt::AlignLeft;

   631 }

   632 

   633 uint DesignerPropertyManager::indexVToAlign(int idx) const

   634 {

   635     switch (idx) {

   636         case 0: return Qt::AlignTop;

   637         case 1: return Qt::AlignVCenter;

   638         case 2: return Qt::AlignBottom;

   639         default: break;

   640     }

   641     return Qt::AlignVCenter;

   642 }

   643 

   644 QString DesignerPropertyManager::indexHToString(int idx) const

   645 {

   646     switch (idx) {

   647         case 0: return tr("AlignLeft");

   648         case 1: return tr("AlignHCenter");

   649         case 2: return tr("AlignRight");

   650         case 3: return tr("AlignJustify");

   651         default: break;

   652     }

   653     return tr("AlignLeft");

   654 }

   655 

   656 QString DesignerPropertyManager::indexVToString(int idx) const

   657 {

   658     switch (idx) {

   659         case 0: return tr("AlignTop");

   660         case 1: return tr("AlignVCenter");

   661         case 2: return tr("AlignBottom");

   662         default: break;

   663     }

   664     return tr("AlignVCenter");

   665 }

   666 

   667 void DesignerPropertyManager::slotValueChanged(QtProperty *property, const QVariant &value)

   668 {

   669     if (m_changingSubValue)

   670         return;

   671     bool enableSubPropertyHandling = true;

   672 

   673     if (QtProperty *flagProperty = m_flagToProperty.value(property, 0)) {

   674         const QList<QtProperty *> subFlags = m_propertyToFlags.value(flagProperty);

   675         const int subFlagCount = subFlags.count();

   676         // flag changed

   677         const bool subValue = variantProperty(property)->value().toBool();

   678         const int subIndex = subFlags.indexOf(property);

   679         if (subIndex < 0)

   680             return;

   681 

   682         uint newValue = 0;

   683 

   684         m_changingSubValue = true;

   685 

   686         FlagData data = m_flagValues.value(flagProperty);

   687         const QList<uint> values = data.values;

   688         // Compute new value, without including (additional) supermasks

   689         if (values.at(subIndex) == 0) {

   690             for (int i = 0; i < subFlagCount; ++i) {

   691                 QtVariantProperty *subFlag = variantProperty(subFlags.at(i));

   692                 subFlag->setValue(i == subIndex);

   693             }

   694         } else {

   695             if (subValue)

   696                 newValue = values.at(subIndex); // value mask of subValue

   697             for (int i = 0; i < subFlagCount; ++i) {

   698                 QtVariantProperty *subFlag = variantProperty(subFlags.at(i));

   699                 if (subFlag->value().toBool() && bitCount(values.at(i)) == 1)

   700                     newValue |= values.at(i);

   701             }

   702             if (newValue == 0) {

   703                 // Uncheck all items except 0-mask

   704                 for (int i = 0; i < subFlagCount; ++i) {

   705                     QtVariantProperty *subFlag = variantProperty(subFlags.at(i));

   706                     subFlag->setValue(values.at(i) == 0);

   707                 }

   708             } else if (newValue == data.val) {

   709                 if (!subValue && bitCount(values.at(subIndex)) > 1) {

   710                     // We unchecked something, but the original value still holds

   711                     variantProperty(property)->setValue(true);

   712                 }

   713             } else {

   714                 // Make sure 0-mask is not selected

   715                 for (int i = 0; i < subFlagCount; ++i) {

   716                     QtVariantProperty *subFlag = variantProperty(subFlags.at(i));

   717                     if (values.at(i) == 0)

   718                         subFlag->setValue(false);

   719                 }

   720                 // Check/uncheck proper masks

   721                 if (subValue) {

   722                     // Make sure submasks and supermasks are selected

   723                     for (int i = 0; i < subFlagCount; ++i) {

   724                         QtVariantProperty *subFlag = variantProperty(subFlags.at(i));

   725                         const uint vi = values.at(i);

   726                         if ((vi != 0) && ((vi & newValue) == vi) && !subFlag->value().toBool())

   727                             subFlag->setValue(true);

   728                     }

   729                 } else {

   730                     // Make sure supermasks are not selected if they're no longer valid

   731                     for (int i = 0; i < subFlagCount; ++i) {

   732                         QtVariantProperty *subFlag = variantProperty(subFlags.at(i));

   733                         const uint vi = values.at(i);

   734                         if (subFlag->value().toBool() && ((vi & newValue) != vi))

   735                             subFlag->setValue(false);

   736                     }

   737                 }

   738             }

   739         }

   740         m_changingSubValue = false;

   741         data.val = newValue;

   742         QVariant v;

   743         qVariantSetValue(v, data.val);

   744         variantProperty(flagProperty)->setValue(v);

   745     } else if (QtProperty *alignProperty = m_alignHToProperty.value(property, 0)) {

   746         const uint v = m_alignValues.value(alignProperty);

   747         const uint newValue = indexHToAlign(value.toInt()) | indexVToAlign(alignToIndexV(v));

   748         if (v == newValue)

   749             return;

   750 

   751         variantProperty(alignProperty)->setValue(newValue);

   752     } else if (QtProperty *alignProperty = m_alignVToProperty.value(property, 0)) {

   753         const uint v = m_alignValues.value(alignProperty);

   754         const uint newValue = indexVToAlign(value.toInt()) | indexHToAlign(alignToIndexH(v));

   755         if (v == newValue)

   756             return;

   757 

   758         variantProperty(alignProperty)->setValue(newValue);

   759     } else if (QtProperty *stringProperty = m_commentToString.value(property, 0)) {

   760         const PropertySheetStringValue v = m_stringValues.value(stringProperty);

   761         PropertySheetStringValue newValue = v;

   762         newValue.setComment(value.toString());

   763         if (v == newValue)

   764             return;

   765 

   766         variantProperty(stringProperty)->setValue(qVariantFromValue(newValue));

   767     } else if (QtProperty *stringProperty = m_translatableToString.value(property, 0)) {

   768         const PropertySheetStringValue v = m_stringValues.value(stringProperty);

   769         PropertySheetStringValue newValue = v;

   770         newValue.setTranslatable(value.toBool());

   771         if (v == newValue)

   772             return;

   773 

   774         variantProperty(stringProperty)->setValue(qVariantFromValue(newValue));

   775     } else if (QtProperty *stringProperty = m_disambiguationToString.value(property, 0)) {

   776         const PropertySheetStringValue v = m_stringValues.value(stringProperty);

   777         PropertySheetStringValue newValue = v;

   778         newValue.setDisambiguation(value.toString());

   779         if (v == newValue)

   780             return;

   781 

   782         variantProperty(stringProperty)->setValue(qVariantFromValue(newValue));

   783     } else if (QtProperty *keySequenceProperty = m_commentToKeySequence.value(property, 0)) {

   784         const PropertySheetKeySequenceValue v = m_keySequenceValues.value(keySequenceProperty);

   785         PropertySheetKeySequenceValue newValue = v;

   786         newValue.setComment(value.toString());

   787         if (v == newValue)

   788             return;

   789 

   790         variantProperty(keySequenceProperty)->setValue(qVariantFromValue(newValue));

   791     } else if (QtProperty *keySequenceProperty = m_translatableToKeySequence.value(property, 0)) {

   792         const PropertySheetKeySequenceValue v = m_keySequenceValues.value(keySequenceProperty);

   793         PropertySheetKeySequenceValue newValue = v;

   794         newValue.setTranslatable(value.toBool());

   795         if (v == newValue)

   796             return;

   797 

   798         variantProperty(keySequenceProperty)->setValue(qVariantFromValue(newValue));

   799     } else if (QtProperty *keySequenceProperty = m_disambiguationToKeySequence.value(property, 0)) {

   800         const PropertySheetKeySequenceValue v = m_keySequenceValues.value(keySequenceProperty);

   801         PropertySheetKeySequenceValue newValue = v;

   802         newValue.setDisambiguation(value.toString());

   803         if (v == newValue)

   804             return;

   805 

   806         variantProperty(keySequenceProperty)->setValue(qVariantFromValue(newValue));

   807     } else if (QtProperty *iProperty = m_iconSubPropertyToProperty.value(property, 0)) {

   808         QtVariantProperty *iconProperty = variantProperty(iProperty);

   809         PropertySheetIconValue icon = qVariantValue<PropertySheetIconValue>(iconProperty->value());

   810         QPair<QIcon::Mode, QIcon::State> pair = m_iconSubPropertyToState.value(property);

   811         icon.setPixmap(pair.first, pair.second, qVariantValue<PropertySheetPixmapValue>(value));

   812         QtProperty *origSourceOfChange = m_sourceOfChange;

   813         if (!origSourceOfChange)

   814             m_sourceOfChange = property;

   815         iconProperty->setValue(qVariantFromValue(icon));

   816         if (!origSourceOfChange)

   817             m_sourceOfChange = origSourceOfChange;

   818     } else if (m_iconValues.contains(property)) {

   819         enableSubPropertyHandling = m_sourceOfChange;

   820     } else {

   821         if (m_brushManager.valueChanged(this, property, value) == BrushPropertyManager::Unchanged)

   822             return;

   823         if (m_fontManager.valueChanged(this, property, value) == FontPropertyManager::Unchanged)

   824             return;

   825     }

   826 

   827     emit valueChanged(property, value, enableSubPropertyHandling);

   828 }

   829 

   830 void DesignerPropertyManager::slotPropertyDestroyed(QtProperty *property)

   831 {

   832     if (QtProperty *flagProperty = m_flagToProperty.value(property, 0)) {

   833         PropertyToPropertyListMap::iterator it = m_propertyToFlags.find(flagProperty);

   834         QList<QtProperty *> &propertyList = it.value();

   835         propertyList.replace(propertyList.indexOf(property), 0);

   836         m_flagToProperty.remove(property);

   837     } else if (QtProperty *alignProperty = m_alignHToProperty.value(property, 0)) {

   838         m_propertyToAlignH.remove(alignProperty);

   839         m_alignHToProperty.remove(property);

   840     } else if (QtProperty *alignProperty = m_alignVToProperty.value(property, 0)) {

   841         m_propertyToAlignV.remove(alignProperty);

   842         m_alignVToProperty.remove(property);

   843     } else if (QtProperty *stringCommentProperty = m_commentToString.value(property, 0)) {

   844         m_stringToComment.remove(stringCommentProperty);

   845         m_commentToString.remove(property);

   846     } else if (QtProperty *stringTranslatableProperty = m_translatableToString.value(property, 0)) {

   847         m_stringToTranslatable.remove(stringTranslatableProperty);

   848         m_translatableToString.remove(property);

   849     } else if (QtProperty *stringDisambiguationProperty = m_disambiguationToString.value(property, 0)) {

   850         m_stringToDisambiguation.remove(stringDisambiguationProperty);

   851         m_disambiguationToString.remove(property);

   852     } else if (QtProperty *keySequenceCommentProperty = m_commentToKeySequence.value(property, 0)) {

   853         m_keySequenceToComment.remove(keySequenceCommentProperty);

   854         m_commentToKeySequence.remove(property);

   855     } else if (QtProperty *keySequenceTranslatableProperty = m_translatableToKeySequence.value(property, 0)) {

   856         m_keySequenceToTranslatable.remove(keySequenceTranslatableProperty);

   857         m_translatableToKeySequence.remove(property);

   858     } else if (QtProperty *keySequenceDisambiguationProperty = m_disambiguationToKeySequence.value(property, 0)) {

   859         m_keySequenceToDisambiguation.remove(keySequenceDisambiguationProperty);

   860         m_disambiguationToKeySequence.remove(property);

   861     } else if (QtProperty *iconProperty = m_iconSubPropertyToProperty.value(property, 0)) {

   862         QMap<QtProperty *, QMap<QPair<QIcon::Mode, QIcon::State>, QtProperty *> >::iterator it =

   863                     m_propertyToIconSubProperties.find(iconProperty);

   864         QPair<QIcon::Mode, QIcon::State> state = m_iconSubPropertyToState.value(property);

   865         QMap<QPair<QIcon::Mode, QIcon::State>, QtProperty *> &propertyList = it.value();

   866         propertyList.remove(state);

   867         m_iconSubPropertyToState.remove(property);

   868         m_iconSubPropertyToProperty.remove(property);

   869     } else {

   870         m_fontManager.slotPropertyDestroyed(property);

   871         m_brushManager.slotPropertyDestroyed(property);

   872     }

   873 }

   874 

   875 QStringList DesignerPropertyManager::attributes(int propertyType) const

   876 {

   877     if (!isPropertyTypeSupported(propertyType))

   878         return QStringList();

   879 

   880     QStringList list = QtVariantPropertyManager::attributes(propertyType);

   881     if (propertyType == designerFlagTypeId()) {

   882         list.append(QLatin1String(flagsAttributeC));

   883     } else if (propertyType == designerPixmapTypeId()) {

   884         list.append(QLatin1String(defaultResourceAttributeC));

   885     } else if (propertyType == designerIconTypeId()) {

   886         list.append(QLatin1String(defaultResourceAttributeC));

   887     } else if (propertyType == designerStringTypeId() || propertyType == QVariant::String) {

   888         list.append(QLatin1String(validationModesAttributeC));

   889         list.append(QLatin1String(fontAttributeC));

   890     } else if (propertyType == QVariant::Palette) {

   891         list.append(QLatin1String(superPaletteAttributeC));

   892     }

   893     list.append(QLatin1String(resettableAttributeC));

   894     return list;

   895 }

   896 

   897 int DesignerPropertyManager::attributeType(int propertyType, const QString &attribute) const

   898 {

   899     if (!isPropertyTypeSupported(propertyType))

   900         return 0;

   901 

   902     if (propertyType == designerFlagTypeId() && attribute == QLatin1String(flagsAttributeC))

   903         return designerFlagListTypeId();

   904     if (propertyType == designerPixmapTypeId() && attribute == QLatin1String(defaultResourceAttributeC))

   905         return QVariant::Pixmap;

   906     if (propertyType == designerIconTypeId() && attribute == QLatin1String(defaultResourceAttributeC))

   907         return QVariant::Icon;

   908     if (attribute == QLatin1String(resettableAttributeC))

   909         return QVariant::Bool;

   910     if (propertyType == designerStringTypeId() || propertyType == QVariant::String) {

   911         if (attribute == QLatin1String(validationModesAttributeC))

   912             return QVariant::Int;

   913         if (attribute == QLatin1String(fontAttributeC))

   914             return QVariant::Font;

   915     }

   916     if (propertyType == QVariant::Palette && attribute == QLatin1String(superPaletteAttributeC))

   917         return QVariant::Palette;

   918 

   919     return QtVariantPropertyManager::attributeType(propertyType, attribute);

   920 }

   921 

   922 QVariant DesignerPropertyManager::attributeValue(const QtProperty *property, const QString &attribute) const

   923 {

   924     QtProperty *prop = const_cast<QtProperty *>(property);

   925 

   926     if (attribute == QLatin1String(resettableAttributeC)) {

   927         const PropertyBoolMap::const_iterator it = m_resetMap.constFind(prop);

   928         if (it != m_resetMap.constEnd())

   929             return it.value();

   930     }

   931 

   932     if (attribute == QLatin1String(flagsAttributeC)) {

   933         PropertyFlagDataMap::const_iterator it = m_flagValues.constFind(prop);

   934         if (it != m_flagValues.constEnd()) {

   935             QVariant v;

   936             qVariantSetValue(v, it.value().flags);

   937             return v;

   938         }

   939     }

   940     if (attribute == QLatin1String(validationModesAttributeC)) {

   941         const PropertyIntMap::const_iterator it = m_stringAttributes.constFind(prop);

   942         if (it !=  m_stringAttributes.constEnd())

   943             return it.value();

   944     }

   945 

   946     if (attribute == QLatin1String(fontAttributeC)) {

   947         const PropertyFontMap::const_iterator it = m_stringFontAttributes.constFind(prop);

   948         if (it !=  m_stringFontAttributes.constEnd())

   949             return it.value();

   950     }

   951 

   952     if (attribute == QLatin1String(superPaletteAttributeC)) {

   953         PropertyPaletteDataMap::const_iterator it = m_paletteValues.constFind(prop);

   954         if (it !=  m_paletteValues.constEnd())

   955             return it.value().superPalette;

   956     }

   957 

   958     if (attribute == QLatin1String(defaultResourceAttributeC)) {

   959         QMap<QtProperty *, QPixmap>::const_iterator itPix = m_defaultPixmaps.constFind(prop);

   960         if (itPix != m_defaultPixmaps.constEnd())

   961             return itPix.value();

   962 

   963         QMap<QtProperty *, QIcon>::const_iterator itIcon = m_defaultIcons.constFind(prop);

   964         if (itIcon != m_defaultIcons.constEnd())

   965             return itIcon.value();

   966     }

   967 

   968     return QtVariantPropertyManager::attributeValue(property, attribute);

   969 }

   970 

   971 void DesignerPropertyManager::setAttribute(QtProperty *property,

   972             const QString &attribute, const QVariant &value)

   973 {

   974     if (attribute == QLatin1String(resettableAttributeC) && m_resetMap.contains(property)) {

   975         if (value.userType() != QVariant::Bool)

   976             return;

   977         const bool val = value.toBool();

   978         const PropertyBoolMap::iterator it = m_resetMap.find(property);

   979         if (it.value() == val)

   980             return;

   981         it.value() = val;

   982         emit attributeChanged(variantProperty(property), attribute, value);

   983         return;

   984     } else if (attribute == QLatin1String(flagsAttributeC) && m_flagValues.contains(property)) {

   985         if (value.userType() != designerFlagListTypeId())

   986             return;

   987 

   988         const DesignerFlagList flags = qVariantValue<DesignerFlagList>(value);

   989         PropertyFlagDataMap::iterator fit = m_flagValues.find(property);

   990         FlagData data = fit.value();

   991         if (data.flags == flags)

   992             return;

   993 

   994         PropertyToPropertyListMap::iterator pfit = m_propertyToFlags.find(property);

   995         QListIterator<QtProperty *> itProp(pfit.value());

   996         while (itProp.hasNext()) {

   997             if (QtProperty *prop = itProp.next()) {

   998                 delete prop;

   999                 m_flagToProperty.remove(prop);

  1000             }

  1001         }

  1002         pfit.value().clear();

  1003 

  1004         QList<uint> values;

  1005 

  1006         QListIterator<QPair<QString, uint> > itFlag(flags);

  1007         while (itFlag.hasNext()) {

  1008             const QPair<QString, uint> pair = itFlag.next();

  1009             const QString flagName = pair.first;

  1010             QtProperty *prop = addProperty(QVariant::Bool);

  1011             prop->setPropertyName(flagName);

  1012             property->addSubProperty(prop);

  1013             m_propertyToFlags[property].append(prop);

  1014             m_flagToProperty[prop] = property;

  1015             values.append(pair.second);

  1016         }

  1017 

  1018         data.val = 0;

  1019         data.flags = flags;

  1020         data.values = values;

  1021 

  1022         fit.value() = data;

  1023 

  1024         QVariant v;

  1025         qVariantSetValue(v, flags);

  1026         emit attributeChanged(property, attribute, v);

  1027 

  1028         emit propertyChanged(property);

  1029         emit QtVariantPropertyManager::valueChanged(property, data.val);

  1030     } else if (attribute == QLatin1String(validationModesAttributeC) && m_stringAttributes.contains(property)) {

  1031         if (value.userType() != QVariant::Int)

  1032             return;

  1033 

  1034         const PropertyIntMap::iterator it = m_stringAttributes.find(property);

  1035         const int oldValue = it.value();

  1036 

  1037         const int newValue = value.toInt();

  1038 

  1039         if (oldValue == newValue)

  1040             return;

  1041 

  1042         it.value() = newValue;

  1043 

  1044         emit attributeChanged(property, attribute, newValue);

  1045     } else if (attribute == QLatin1String(fontAttributeC) && m_stringFontAttributes.contains(property)) {

  1046         if (value.userType() != QVariant::Font)

  1047             return;

  1048 

  1049         const PropertyFontMap::iterator it = m_stringFontAttributes.find(property);

  1050         const QFont oldValue = it.value();

  1051 

  1052         const QFont newValue = qvariant_cast<QFont>(value);

  1053 

  1054         if (oldValue == newValue)

  1055             return;

  1056 

  1057         it.value() = newValue;

  1058 

  1059         emit attributeChanged(property, attribute, newValue);

  1060     } else if (attribute == QLatin1String(superPaletteAttributeC) && m_paletteValues.contains(property)) {

  1061         if (value.userType() != QVariant::Palette)

  1062             return;

  1063 

  1064         QPalette superPalette = qVariantValue<QPalette>(value);

  1065 

  1066         const PropertyPaletteDataMap::iterator it = m_paletteValues.find(property);

  1067         PaletteData data = it.value();

  1068         if (data.superPalette == superPalette)

  1069             return;

  1070 

  1071         data.superPalette = superPalette;

  1072         // resolve here

  1073         const uint mask = data.val.resolve();

  1074         data.val = data.val.resolve(superPalette);

  1075         data.val.resolve(mask);

  1076 

  1077         it.value() = data;

  1078 

  1079         QVariant v;

  1080         qVariantSetValue(v, superPalette);

  1081         emit attributeChanged(property, attribute, v);

  1082 

  1083         emit propertyChanged(property);

  1084         emit QtVariantPropertyManager::valueChanged(property, data.val); // if resolve was done, this is also for consistency

  1085     } else if (attribute == QLatin1String(defaultResourceAttributeC) && m_defaultPixmaps.contains(property)) {

  1086         if (value.userType() != QVariant::Pixmap)

  1087             return;

  1088 

  1089         QPixmap defaultPixmap = qVariantValue<QPixmap>(value);

  1090 

  1091         const QMap<QtProperty *, QPixmap>::iterator it = m_defaultPixmaps.find(property);

  1092         QPixmap oldDefaultPixmap = it.value();

  1093         if (defaultPixmap.cacheKey() == oldDefaultPixmap.cacheKey())

  1094             return;

  1095 

  1096         it.value() = defaultPixmap;

  1097 

  1098         QVariant v = qVariantFromValue(defaultPixmap);

  1099         emit attributeChanged(property, attribute, v);

  1100 

  1101         emit propertyChanged(property);

  1102     } else if (attribute == QLatin1String(defaultResourceAttributeC) && m_defaultIcons.contains(property)) {

  1103         if (value.userType() != QVariant::Icon)

  1104             return;

  1105 

  1106         QIcon defaultIcon = qVariantValue<QIcon>(value);

  1107 

  1108         const QMap<QtProperty *, QIcon>::iterator it = m_defaultIcons.find(property);

  1109         QIcon oldDefaultIcon = it.value();

  1110         if (defaultIcon.cacheKey() == oldDefaultIcon.cacheKey())

  1111             return;

  1112 

  1113         it.value() = defaultIcon;

  1114 

  1115         qdesigner_internal::PropertySheetIconValue icon = m_iconValues.value(property);

  1116         if (icon.paths().isEmpty()) {

  1117             QMap<QPair<QIcon::Mode, QIcon::State>, QtProperty *> subIconProperties = m_propertyToIconSubProperties.value(property);

  1118             QMapIterator<QPair<QIcon::Mode, QIcon::State>, QtProperty *> itSub(subIconProperties);

  1119             while (itSub.hasNext()) {

  1120                 QPair<QIcon::Mode, QIcon::State> pair = itSub.next().key();

  1121                 QtProperty *subProp = itSub.value();

  1122                 setAttribute(subProp, QLatin1String(defaultResourceAttributeC),

  1123                              defaultIcon.pixmap(16, 16, pair.first, pair.second));

  1124             }

  1125         }

  1126 

  1127         QVariant v = qVariantFromValue(defaultIcon);

  1128         emit attributeChanged(property, attribute, v);

  1129 

  1130         emit propertyChanged(property);

  1131     }

  1132     QtVariantPropertyManager::setAttribute(property, attribute, value);

  1133 }

  1134