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 "iconselector_p.h"

    43 #include "qdesigner_utils_p.h"

    44 #include "qtresourcemodel_p.h"

    45 #include "qtresourceview_p.h"

    46 #include "iconloader_p.h"

    47 #include "qdesigner_integration_p.h"

    48 #include "formwindowbase_p.h"

    49 

    50 #include <abstractdialoggui_p.h>

    51 #include <qdesigner_integration_p.h>

    52 #include <QtDesigner/QDesignerFormEditorInterface>

    53 #include <QtDesigner/QDesignerResourceBrowserInterface>

    54 #include <QtDesigner/QDesignerLanguageExtension>

    55 #include <QtDesigner/QExtensionManager>

    56 

    57 #include <QtGui/QToolButton>

    58 #include <QtCore/QSignalMapper>

    59 #include <QtGui/QComboBox>

    60 #include <QtGui/QAction>

    61 #include <QtGui/QDialogButtonBox>

    62 #include <QtGui/QPushButton>

    63 #include <QtGui/QDialog>

    64 #include <QtGui/QMenu>

    65 #include <QtGui/QApplication>

    66 #include <QtGui/QVBoxLayout>

    67 #include <QtGui/QImageReader>

    68 #include <QtGui/QDialogButtonBox>

    69 #include <QtGui/QVBoxLayout>

    70 #include <QtCore/QDebug>

    71 

    72 QT_BEGIN_NAMESPACE

    73 

    74 namespace qdesigner_internal {

    75 

    76 // -------------------- LanguageResourceDialogPrivate

    77 class LanguageResourceDialogPrivate {

    78     LanguageResourceDialog *q_ptr;

    79     Q_DECLARE_PUBLIC(LanguageResourceDialog)

    80 

    81 public:

    82     LanguageResourceDialogPrivate(QDesignerResourceBrowserInterface *rb);

    83     void init(LanguageResourceDialog *p);

    84 

    85     void setCurrentPath(const QString &filePath);

    86     QString currentPath() const;

    87 

    88     void slotAccepted();

    89     void slotPathChanged(const QString &);

    90 

    91 private:

    92     void setOkButtonEnabled(bool v)         { m_dialogButtonBox->button(QDialogButtonBox::Ok)->setEnabled(v); }

    93     static bool checkPath(const QString &p);

    94 

    95     QDesignerResourceBrowserInterface *m_browser;

    96     QDialogButtonBox *m_dialogButtonBox;

    97 };

    98 

    99 LanguageResourceDialogPrivate::LanguageResourceDialogPrivate(QDesignerResourceBrowserInterface *rb) :

   100     q_ptr(0),

   101     m_browser(rb),

   102     m_dialogButtonBox(new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel))

   103 {

   104      setOkButtonEnabled(false);

   105 }

   106 

   107 void LanguageResourceDialogPrivate::init(LanguageResourceDialog *p)

   108 {

   109     q_ptr = p;

   110     QLayout *layout = new QVBoxLayout(p);

   111     layout->addWidget(m_browser);

   112     layout->addWidget(m_dialogButtonBox);

   113     QObject::connect(m_dialogButtonBox, SIGNAL(accepted()), p, SLOT(slotAccepted()));

   114     QObject::connect(m_dialogButtonBox, SIGNAL(rejected()), p, SLOT(reject()));

   115     QObject::connect(m_browser, SIGNAL(currentPathChanged(QString)), p, SLOT(slotPathChanged(QString)));

   116     QObject::connect(m_browser, SIGNAL(pathActivated(QString)), p, SLOT(slotAccepted()));

   117     p->setModal(true);

   118     p->setWindowTitle(LanguageResourceDialog::tr("Choose Resource"));

   119     p->setWindowFlags(p->windowFlags() & ~Qt::WindowContextHelpButtonHint);

   120     setOkButtonEnabled(false);

   121 }

   122 

   123 void LanguageResourceDialogPrivate::setCurrentPath(const QString &filePath)

   124 {

   125     m_browser->setCurrentPath(filePath);

   126     setOkButtonEnabled(checkPath(filePath));

   127 }

   128 

   129 QString LanguageResourceDialogPrivate::currentPath() const

   130 {

   131     return m_browser->currentPath();

   132 }

   133 

   134 bool LanguageResourceDialogPrivate::checkPath(const QString &p)

   135 {

   136     return p.isEmpty() ? false : IconSelector::checkPixmap(p, IconSelector::CheckFast);

   137 }

   138 

   139 void LanguageResourceDialogPrivate::slotAccepted()

   140 {

   141     if (checkPath(currentPath()))

   142         q_ptr->accept();

   143 }

   144 

   145 void LanguageResourceDialogPrivate::slotPathChanged(const QString &p)

   146 {

   147     setOkButtonEnabled(checkPath(p));

   148 }

   149 

   150 // ------------ LanguageResourceDialog

   151 LanguageResourceDialog::LanguageResourceDialog(QDesignerResourceBrowserInterface *rb, QWidget *parent) :

   152     QDialog(parent),

   153     d_ptr(new LanguageResourceDialogPrivate(rb))

   154 {

   155     d_ptr->init( this);

   156 }

   157 

   158 LanguageResourceDialog::~LanguageResourceDialog()

   159 {

   160 }

   161 

   162 void LanguageResourceDialog::setCurrentPath(const QString &filePath)

   163 {

   164     d_ptr->setCurrentPath(filePath);

   165 }

   166 

   167 QString LanguageResourceDialog::currentPath() const

   168 {

   169     return d_ptr->currentPath();

   170 }

   171 

   172 LanguageResourceDialog* LanguageResourceDialog::create(QDesignerFormEditorInterface *core, QWidget *parent)

   173 {

   174     if (QDesignerLanguageExtension *lang = qt_extension<QDesignerLanguageExtension *>(core->extensionManager(), core))

   175         if (QDesignerResourceBrowserInterface *rb = lang->createResourceBrowser(0))

   176             return new LanguageResourceDialog(rb, parent);

   177     if (QDesignerIntegration *di = qobject_cast<QDesignerIntegration*>(core->integration()))

   178         if (QDesignerResourceBrowserInterface *rb = di->createResourceBrowser(0))

   179             return new LanguageResourceDialog(rb, parent);

   180     return 0;

   181 }

   182 

   183 // ------------ IconSelectorPrivate

   184 class IconSelectorPrivate

   185 {

   186     IconSelector *q_ptr;

   187     Q_DECLARE_PUBLIC(IconSelector)

   188 public:

   189     IconSelectorPrivate();

   190 

   191     void slotStateActivated();

   192     void slotSetActivated();

   193     void slotSetResourceActivated();

   194     void slotSetFileActivated();

   195     void slotResetActivated();

   196     void slotResetAllActivated();

   197     void slotUpdate();

   198 

   199     QList<QPair<QPair<QIcon::Mode, QIcon::State>, QString> > m_stateToName; // could be static map

   200 

   201     QMap<QPair<QIcon::Mode, QIcon::State>, int>  m_stateToIndex;

   202     QMap<int, QPair<QIcon::Mode, QIcon::State> > m_indexToState;

   203 

   204     QIcon m_emptyIcon;

   205     QComboBox *m_stateComboBox;

   206     QToolButton *m_iconButton;

   207     QAction *m_resetAction;

   208     QAction *m_resetAllAction;

   209     PropertySheetIconValue m_icon;

   210     DesignerIconCache *m_iconCache;

   211     DesignerPixmapCache *m_pixmapCache;

   212     QtResourceModel *m_resourceModel;

   213     QDesignerFormEditorInterface *m_core;

   214 };

   215 

   216 IconSelectorPrivate::IconSelectorPrivate() :

   217     q_ptr(0),

   218     m_stateComboBox(0),

   219     m_iconButton(0),

   220     m_resetAction(0),

   221     m_resetAllAction(0),

   222     m_iconCache(0),

   223     m_pixmapCache(0),

   224     m_resourceModel(0),

   225     m_core(0)

   226 {

   227 }

   228 void IconSelectorPrivate::slotUpdate()

   229 {

   230     QIcon icon;

   231     if (m_iconCache)

   232         icon = m_iconCache->icon(m_icon);

   233 

   234     QMap<QPair<QIcon::Mode, QIcon::State>, PropertySheetPixmapValue> paths = m_icon.paths();

   235     QMapIterator<QPair<QIcon::Mode, QIcon::State>, int> itIndex(m_stateToIndex);

   236     while (itIndex.hasNext()) {

   237         const QPair<QIcon::Mode, QIcon::State> state = itIndex.next().key();

   238         const PropertySheetPixmapValue pixmap = paths.value(state);

   239         const int index = itIndex.value();

   240 

   241         QIcon pixmapIcon = QIcon(icon.pixmap(16, 16, state.first, state.second));

   242         if (pixmapIcon.isNull())

   243             pixmapIcon = m_emptyIcon;

   244         m_stateComboBox->setItemIcon(index, pixmapIcon);

   245         QFont font = q_ptr->font();

   246         if (!pixmap.path().isEmpty())

   247             font.setBold(true);

   248         m_stateComboBox->setItemData(index, font, Qt::FontRole);

   249     }

   250 

   251     QPair<QIcon::Mode, QIcon::State> state = m_indexToState.value(m_stateComboBox->currentIndex());

   252     PropertySheetPixmapValue currentPixmap = paths.value(state);

   253     m_resetAction->setEnabled(!currentPixmap.path().isEmpty());

   254     m_resetAllAction->setEnabled(!paths.isEmpty());

   255     m_stateComboBox->update();

   256 }

   257 

   258 void IconSelectorPrivate::slotStateActivated()

   259 {

   260     slotUpdate();

   261 }

   262 

   263 void IconSelectorPrivate::slotSetActivated()

   264 {

   265     QPair<QIcon::Mode, QIcon::State> state = m_indexToState.value(m_stateComboBox->currentIndex());

   266     const PropertySheetPixmapValue pixmap = m_icon.pixmap(state.first, state.second);

   267     // Default to resource

   268     const PropertySheetPixmapValue::PixmapSource ps = pixmap.path().isEmpty() ? PropertySheetPixmapValue::ResourcePixmap : pixmap.pixmapSource(m_core);

   269     switch (ps) {

   270     case PropertySheetPixmapValue::LanguageResourcePixmap:

   271     case PropertySheetPixmapValue::ResourcePixmap:

   272         slotSetResourceActivated();

   273         break;

   274     case PropertySheetPixmapValue::FilePixmap:

   275         slotSetFileActivated();

   276         break;

   277     }

   278 }

   279 

   280 // Choose a pixmap from resource; use language-dependent resource browser if present

   281 QString IconSelector::choosePixmapResource(QDesignerFormEditorInterface *core, QtResourceModel *resourceModel, const QString &oldPath, QWidget *parent)

   282 {

   283     Q_UNUSED(resourceModel)

   284     QString rc;

   285 

   286     if (LanguageResourceDialog* ldlg = LanguageResourceDialog::create(core, parent)) {

   287         ldlg->setCurrentPath(oldPath);

   288         if (ldlg->exec() == QDialog::Accepted)

   289             rc = ldlg->currentPath();

   290         delete ldlg;

   291     } else {

   292         QtResourceViewDialog dlg(core, parent);

   293 

   294         QDesignerIntegration *designerIntegration = qobject_cast<QDesignerIntegration *>(core->integration());

   295         if (designerIntegration)

   296             dlg.setResourceEditingEnabled(designerIntegration->isResourceEditingEnabled());

   297 

   298         dlg.selectResource(oldPath);

   299         if (dlg.exec() == QDialog::Accepted)

   300             rc = dlg.selectedResource();

   301     }

   302     return rc;

   303 }

   304 

   305 void IconSelectorPrivate::slotSetResourceActivated()

   306 {

   307     const QPair<QIcon::Mode, QIcon::State> state = m_indexToState.value(m_stateComboBox->currentIndex());

   308 

   309     PropertySheetPixmapValue pixmap = m_icon.pixmap(state.first, state.second);

   310     const QString oldPath = pixmap.path();

   311     const QString newPath = IconSelector::choosePixmapResource(m_core, m_resourceModel, oldPath, q_ptr);

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

   313         return;

   314     const PropertySheetPixmapValue newPixmap = PropertySheetPixmapValue(newPath);

   315     if (newPixmap != pixmap) {

   316         m_icon.setPixmap(state.first, state.second, newPixmap);

   317         slotUpdate();

   318         emit q_ptr->iconChanged(m_icon);

   319     }

   320 }

   321 

   322 // Helpers for choosing image files: Check for valid image.

   323 bool IconSelector::checkPixmap(const QString &fileName, CheckMode cm, QString *errorMessage)

   324 {

   325     const QFileInfo fi(fileName);

   326     if (!fi.exists() || !fi.isFile() || !fi.isReadable()) {

   327         if (errorMessage)

   328             *errorMessage = tr("The pixmap file '%1' cannot be read.").arg(fileName);

   329         return false;

   330     }

   331     QImageReader reader(fileName);

   332     if (!reader.canRead()) {

   333         if (errorMessage)

   334             *errorMessage = tr("The file '%1' does not appear to be a valid pixmap file: %2").arg(fileName).arg(reader.errorString());

   335         return false;

   336     }

   337     if (cm == CheckFast)

   338         return true;

   339 

   340     const QImage image = reader.read();

   341     if (image.isNull()) {

   342         if (errorMessage)

   343             *errorMessage = tr("The file '%1' could not be read: %2").arg(fileName).arg(reader.errorString());

   344         return false;

   345     }

   346     return true;

   347 }

   348 

   349 // Helpers for choosing image files: Return an image filter for QFileDialog, courtesy of StyledButton

   350 static QString imageFilter()

   351 {

   352     QString filter = QApplication::translate("IconSelector", "All Pixmaps (");

   353     const QList<QByteArray> supportedImageFormats = QImageReader::supportedImageFormats();

   354     const QString jpeg = QLatin1String("JPEG");

   355     const int count = supportedImageFormats.count();

   356     for (int i = 0; i< count; ++i) {

   357         if (i)

   358             filter += QLatin1Char(' ');

   359         filter += QLatin1String("*.");

   360         const QString outputFormat = QString::fromUtf8(supportedImageFormats.at(i));

   361         if (outputFormat != jpeg)

   362             filter += outputFormat.toLower();

   363         else

   364             filter += QLatin1String("jpg *.jpeg");

   365     }

   366     filter += QLatin1Char(')');

   367     return filter;

   368 }

   369 

   370 // Helpers for choosing image files: Choose a file

   371 QString IconSelector::choosePixmapFile(const QString &directory, QDesignerDialogGuiInterface *dlgGui,QWidget *parent)

   372 {

   373     QString errorMessage;

   374     QString newPath;

   375     do {

   376         const QString title = tr("Choose a Pixmap");

   377         static const  QString filter = imageFilter();

   378         newPath =  dlgGui->getOpenImageFileName(parent, title, directory, filter);

   379         if (newPath.isEmpty())

   380             break;

   381         if (checkPixmap(newPath, CheckFully, &errorMessage))

   382             break;

   383         dlgGui->message(parent, QDesignerDialogGuiInterface::ResourceEditorMessage, QMessageBox::Warning, tr("Pixmap Read Error"), errorMessage);

   384     } while(true);

   385     return  newPath;

   386 }

   387 

   388 void IconSelectorPrivate::slotSetFileActivated()

   389 {

   390     QPair<QIcon::Mode, QIcon::State> state = m_indexToState.value(m_stateComboBox->currentIndex());

   391 

   392     PropertySheetPixmapValue pixmap = m_icon.pixmap(state.first, state.second);

   393     const QString newPath = IconSelector::choosePixmapFile(pixmap.path(), m_core->dialogGui(), q_ptr);

   394     if (!newPath.isEmpty()) {

   395         const PropertySheetPixmapValue newPixmap = PropertySheetPixmapValue(newPath);

   396         if (!(newPixmap == pixmap)) {

   397             m_icon.setPixmap(state.first, state.second, newPixmap);

   398             slotUpdate();

   399             emit q_ptr->iconChanged(m_icon);

   400         }

   401     }

   402 }

   403 

   404 void IconSelectorPrivate::slotResetActivated()

   405 {

   406     QPair<QIcon::Mode, QIcon::State> state = m_indexToState.value(m_stateComboBox->currentIndex());

   407 

   408     PropertySheetPixmapValue pixmap = m_icon.pixmap(state.first, state.second);

   409     const PropertySheetPixmapValue newPixmap;

   410     if (!(newPixmap == pixmap)) {

   411         m_icon.setPixmap(state.first, state.second, newPixmap);

   412         slotUpdate();

   413         emit q_ptr->iconChanged(m_icon);

   414     }

   415 }

   416 

   417 void IconSelectorPrivate::slotResetAllActivated()

   418 {

   419     const PropertySheetIconValue newIcon;

   420     if (!(m_icon == newIcon)) {

   421         m_icon = newIcon;

   422         slotUpdate();

   423         emit q_ptr->iconChanged(m_icon);

   424     }

   425 }

   426 

   427 // ------------- IconSelector

   428 IconSelector::IconSelector(QWidget *parent) :

   429     QWidget(parent), d_ptr(new IconSelectorPrivate())

   430 {

   431     d_ptr->q_ptr = this;

   432 

   433     d_ptr->m_stateComboBox = new QComboBox(this);

   434 

   435     QHBoxLayout *l = new QHBoxLayout(this);

   436     d_ptr->m_iconButton = new QToolButton(this);

   437     d_ptr->m_iconButton->setText(tr("..."));

   438     d_ptr->m_iconButton->setPopupMode(QToolButton::MenuButtonPopup);

   439     l->addWidget(d_ptr->m_stateComboBox);

   440     l->addWidget(d_ptr->m_iconButton);

   441     l->setMargin(0);

   442 

   443     d_ptr->m_stateToName << qMakePair(qMakePair(QIcon::Normal,   QIcon::Off), tr("Normal Off")   );

   444     d_ptr->m_stateToName << qMakePair(qMakePair(QIcon::Normal,   QIcon::On),  tr("Normal On")    );

   445     d_ptr->m_stateToName << qMakePair(qMakePair(QIcon::Disabled, QIcon::Off), tr("Disabled Off") );

   446     d_ptr->m_stateToName << qMakePair(qMakePair(QIcon::Disabled, QIcon::On),  tr("Disabled On")  );

   447     d_ptr->m_stateToName << qMakePair(qMakePair(QIcon::Active,   QIcon::Off), tr("Active Off")   );

   448     d_ptr->m_stateToName << qMakePair(qMakePair(QIcon::Active,   QIcon::On),  tr("Active On")    );

   449     d_ptr->m_stateToName << qMakePair(qMakePair(QIcon::Selected, QIcon::Off), tr("Selected Off") );

   450     d_ptr->m_stateToName << qMakePair(qMakePair(QIcon::Selected, QIcon::On),  tr("Selected On")  );

   451 

   452     QImage img(16, 16, QImage::Format_ARGB32_Premultiplied);

   453     img.fill(0);

   454     d_ptr->m_emptyIcon = QIcon(QPixmap::fromImage(img));

   455 

   456     QMenu *setMenu = new QMenu(this);

   457 

   458     QAction *setResourceAction = new QAction(tr("Choose Resource..."), this);

   459     QAction *setFileAction = new QAction(tr("Choose File..."), this);

   460     d_ptr->m_resetAction = new QAction(tr("Reset"), this);

   461     d_ptr->m_resetAllAction = new QAction(tr("Reset All"), this);

   462     d_ptr->m_resetAction->setEnabled(false);

   463     d_ptr->m_resetAllAction->setEnabled(false);

   464     //d_ptr->m_resetAction->setIcon(createIconSet(QString::fromUtf8("resetproperty.png")));

   465 

   466     setMenu->addAction(setResourceAction);

   467     setMenu->addAction(setFileAction);

   468     setMenu->addSeparator();

   469     setMenu->addAction(d_ptr->m_resetAction);

   470     setMenu->addAction(d_ptr->m_resetAllAction);

   471 

   472     int index = 0;

   473     QStringList items;

   474     QListIterator<QPair<QPair<QIcon::Mode, QIcon::State>, QString> > itName(d_ptr->m_stateToName);

   475     while (itName.hasNext()) {

   476         QPair<QPair<QIcon::Mode, QIcon::State>, QString> item = itName.next();

   477         const QPair<QIcon::Mode, QIcon::State> state = item.first;

   478         const QString name = item.second;

   479 

   480         items.append(name);

   481         d_ptr->m_stateToIndex[state] = index;

   482         d_ptr->m_indexToState[index] = state;

   483         index++;

   484     }

   485     d_ptr->m_stateComboBox->addItems(items);

   486 

   487     d_ptr->m_iconButton->setMenu(setMenu);

   488 

   489     connect(d_ptr->m_stateComboBox, SIGNAL(activated(int)), this, SLOT(slotStateActivated()));

   490     connect(d_ptr->m_iconButton, SIGNAL(clicked()), this, SLOT(slotSetActivated()));

   491     connect(setResourceAction, SIGNAL(triggered()), this, SLOT(slotSetResourceActivated()));

   492     connect(setFileAction, SIGNAL(triggered()), this, SLOT(slotSetFileActivated()));

   493     connect(d_ptr->m_resetAction, SIGNAL(triggered()), this, SLOT(slotResetActivated()));

   494     connect(d_ptr->m_resetAllAction, SIGNAL(triggered()), this, SLOT(slotResetAllActivated()));

   495 

   496     d_ptr->slotUpdate();

   497 }

   498 

   499 IconSelector::~IconSelector()

   500 {

   501 }

   502 

   503 void IconSelector::setIcon(const PropertySheetIconValue &icon)

   504 {

   505     if (d_ptr->m_icon == icon)

   506         return;

   507 

   508     d_ptr->m_icon = icon;

   509     d_ptr->slotUpdate();

   510 }

   511 

   512 PropertySheetIconValue IconSelector::icon() const

   513 {

   514     return d_ptr->m_icon;

   515 }

   516 

   517 void IconSelector::setFormEditor(QDesignerFormEditorInterface *core)

   518 {

   519     d_ptr->m_core = core;

   520     d_ptr->m_resourceModel = core->resourceModel();

   521     d_ptr->slotUpdate();

   522 }

   523 

   524 void IconSelector::setIconCache(DesignerIconCache *iconCache)

   525 {

   526     d_ptr->m_iconCache = iconCache;

   527     connect(iconCache, SIGNAL(reloaded()), this, SLOT(slotUpdate()));

   528     d_ptr->slotUpdate();

   529 }

   530 

   531 void IconSelector::setPixmapCache(DesignerPixmapCache *pixmapCache)

   532 {

   533     d_ptr->m_pixmapCache = pixmapCache;

   534     connect(pixmapCache, SIGNAL(reloaded()), this, SLOT(slotUpdate()));

   535     d_ptr->slotUpdate();

   536 }

   537 

   538 } // qdesigner_internal

   539 

   540 QT_END_NAMESPACE

   541 

   542 #include "moc_iconselector_p.cpp"

   543