/****************************************************************************

**

** Copyright (C) 2009 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)

{