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

**

** 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 tools applications 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 "qteditorfactory.h"

#include "qtpropertybrowserutils_p.h"

#include <QtGui/QSpinBox>

#include <QtGui/QScrollBar>

#include <QtGui/QComboBox>

#include <QtGui/QAbstractItemView>

#include <QtGui/QLineEdit>

#include <QtGui/QDateTimeEdit>

#include <QtGui/QHBoxLayout>

#include <QtGui/QMenu>

#include <QtGui/QKeyEvent>

#include <QtGui/QApplication>

#include <QtGui/QLabel>

#include <QtGui/QToolButton>

#include <QtGui/QColorDialog>

#include <QtGui/QFontDialog>

#include <QtGui/QSpacerItem>

#include <QtCore/QMap>

#if defined(Q_CC_MSVC)

#    pragma warning(disable: 4786) /* MS VS 6: truncating debug info after 255 characters */

#endif

QT_BEGIN_NAMESPACE

// Set a hard coded left margin to account for the indentation

// of the tree view icon when switching to an editor

static inline void setupTreeViewEditorMargin(QLayout *lt)

{

    enum { DecorationMargin = 4 };

    if (QApplication::layoutDirection() == Qt::LeftToRight)

        lt->setContentsMargins(DecorationMargin, 0, 0, 0);

    else

        lt->setContentsMargins(0, 0, DecorationMargin, 0);

}

// ---------- EditorFactoryPrivate :

// Base class for editor factory private classes. Manages mapping of properties to editors and vice versa.

template <class Editor>

class EditorFactoryPrivate

{

public:

    typedef QList<Editor *> EditorList;

    typedef QMap<QtProperty *, EditorList> PropertyToEditorListMap;

    typedef QMap<Editor *, QtProperty *> EditorToPropertyMap;

    Editor *createEditor(QtProperty *property, QWidget *parent);

    void initializeEditor(QtProperty *property, Editor *e);

    void slotEditorDestroyed(QObject *object);

    PropertyToEditorListMap  m_createdEditors;

    EditorToPropertyMap m_editorToProperty;

};

template <class Editor>

Editor *EditorFactoryPrivate<Editor>::createEditor(QtProperty *property, QWidget *parent)

{

    Editor *editor = new Editor(parent);

    initializeEditor(property, editor);

    return editor;

}

template <class Editor>

void EditorFactoryPrivate<Editor>::initializeEditor(QtProperty *property, Editor *editor)

{

    Q_TYPENAME PropertyToEditorListMap::iterator it = m_createdEditors.find(property);

    if (it == m_createdEditors.end())

        it = m_createdEditors.insert(property, EditorList());

    it.value().append(editor);

    m_editorToProperty.insert(editor, property);

}

template <class Editor>

void EditorFactoryPrivate<Editor>::slotEditorDestroyed(QObject *object)

{

    const Q_TYPENAME EditorToPropertyMap::iterator ecend = m_editorToProperty.end();

    for (Q_TYPENAME EditorToPropertyMap::iterator itEditor = m_editorToProperty.begin(); itEditor !=  ecend; ++itEditor) {

        if (itEditor.key() == object) {

            Editor *editor = itEditor.key();

            QtProperty *property = itEditor.value();

            const Q_TYPENAME PropertyToEditorListMap::iterator pit = m_createdEditors.find(property);

            if (pit != m_createdEditors.end()) {

                pit.value().removeAll(editor);

                if (pit.value().empty())

                    m_createdEditors.erase(pit);

            }

            m_editorToProperty.erase(itEditor);

            return;

        }

    }

}

// ------------ QtSpinBoxFactory

class QtSpinBoxFactoryPrivate : public EditorFactoryPrivate<QSpinBox>

{

    QtSpinBoxFactory *q_ptr;

    Q_DECLARE_PUBLIC(QtSpinBoxFactory)

public:

    void slotPropertyChanged(QtProperty *property, int value);

    void slotRangeChanged(QtProperty *property, int min, int max);

    void slotSingleStepChanged(QtProperty *property, int step);

    void slotSetValue(int value);

};

void QtSpinBoxFactoryPrivate::slotPropertyChanged(QtProperty *property, int value)

{

    if (!m_createdEditors.contains(property))

        return;

    QListIterator<QSpinBox *> itEditor(m_createdEditors[property]);

    while (itEditor.hasNext()) {

        QSpinBox *editor = itEditor.next();

        if (editor->value() != value) {

            editor->blockSignals(true);

            editor->setValue(value);

            editor->blockSignals(false);

        }

    }

}

void QtSpinBoxFactoryPrivate::slotRangeChanged(QtProperty *property, int min, int max)

{

    if (!m_createdEditors.contains(property))

        return;

    QtIntPropertyManager *manager = q_ptr->propertyManager(property);

    if (!manager)

        return;

    QListIterator<QSpinBox *> itEditor(m_createdEditors[property]);

    while (itEditor.hasNext()) {

        QSpinBox *editor = itEditor.next();

        editor->blockSignals(true);

        editor->setRange(min, max);

        editor->setValue(manager->value(property));

        editor->blockSignals(false);

    }

}

void QtSpinBoxFactoryPrivate::slotSingleStepChanged(QtProperty *property, int step)

{

    if (!m_createdEditors.contains(property))

        return;

    QListIterator<QSpinBox *> itEditor(m_createdEditors[property]);

    while (itEditor.hasNext()) {

        QSpinBox *editor = itEditor.next();

        editor->blockSignals(true);

        editor->setSingleStep(step);

        editor->blockSignals(false);

    }

}

void QtSpinBoxFactoryPrivate::slotSetValue(int value)

{

    QObject *object = q_ptr->sender();

    const QMap<QSpinBox *, QtProperty *>::ConstIterator  ecend = m_editorToProperty.constEnd();

    for (QMap<QSpinBox *, QtProperty *>::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor !=  ecend; ++itEditor) {

        if (itEditor.key() == object) {

            QtProperty *property = itEditor.value();

            QtIntPropertyManager *manager = q_ptr->propertyManager(property);

            if (!manager)

                return;

            manager->setValue(property, value);

            return;

        }

    }

}

/*!

    \class QtSpinBoxFactory

    \internal

    \inmodule QtDesigner

    \since 4.4

    \brief The QtSpinBoxFactory class provides QSpinBox widgets for

    properties created by QtIntPropertyManager objects.

    \sa QtAbstractEditorFactory, QtIntPropertyManager

*/

/*!

    Creates a factory with the given \a parent.

*/

QtSpinBoxFactory::QtSpinBoxFactory(QObject *parent)

    : QtAbstractEditorFactory<QtIntPropertyManager>(parent), d_ptr(new QtSpinBoxFactoryPrivate())

{

    d_ptr->q_ptr = this;

}

/*!

    Destroys this factory, and all the widgets it has created.

*/

QtSpinBoxFactory::~QtSpinBoxFactory()

{

    qDeleteAll(d_ptr->m_editorToProperty.keys());

}

/*!

    \internal

    Reimplemented from the QtAbstractEditorFactory class.

*/

void QtSpinBoxFactory::connectPropertyManager(QtIntPropertyManager *manager)

{

}

/*!

    \internal

    Reimplemented from the QtAbstractEditorFactory class.

*/

QWidget *QtSpinBoxFactory::createEditor(QtIntPropertyManager *manager, QtProperty *property,

        QWidget *parent)

{

    QSpinBox *editor = d_ptr->createEditor(property, parent);

    editor->setSingleStep(manager->singleStep(property));

    editor->setRange(manager->minimum(property), manager->maximum(property));

    editor->setValue(manager->value(property));

    editor->setKeyboardTracking(false);

    connect(editor, SIGNAL(valueChanged(int)), this, SLOT(slotSetValue(int)));

    return editor;

}

/*!

    \internal

    Reimplemented from the QtAbstractEditorFactory class.

*/

void QtSpinBoxFactory::disconnectPropertyManager(QtIntPropertyManager *manager)

{

}

// QtSliderFactory

class QtSliderFactoryPrivate : public EditorFactoryPrivate<QSlider>

{

    QtSliderFactory *q_ptr;

    Q_DECLARE_PUBLIC(QtSliderFactory)

public:

    void slotPropertyChanged(QtProperty *property, int value);

    void slotRangeChanged(QtProperty *property, int min, int max);

    void slotSingleStepChanged(QtProperty *property, int step);

    void slotSetValue(int value);

};

void QtSliderFactoryPrivate::slotPropertyChanged(QtProperty *property, int value)

{

    if (!m_createdEditors.contains(property))

        return;

    QListIterator<QSlider *> itEditor(m_createdEditors[property]);

    while (itEditor.hasNext()) {

        QSlider *editor = itEditor.next();

        editor->blockSignals(true);

        editor->setValue(value);

        editor->blockSignals(false);

    }

}

void QtSliderFactoryPrivate::slotRangeChanged(QtProperty *property, int min, int max)

{

    if (!m_createdEditors.contains(property))

        return;

    QtIntPropertyManager *manager = q_ptr->propertyManager(property);

    if (!manager)

        return;

    QListIterator<QSlider *> itEditor(m_createdEditors[property]);

    while (itEditor.hasNext()) {

        QSlider *editor = itEditor.next();

        editor->blockSignals(true);

        editor->setRange(min, max);

        editor->setValue(manager->value(property));

        editor->blockSignals(false);

    }

}

void QtSliderFactoryPrivate::slotSingleStepChanged(QtProperty *property, int step)

{

    if (!m_createdEditors.contains(property))

        return;

    QListIterator<QSlider *> itEditor(m_createdEditors[property]);

    while (itEditor.hasNext()) {

        QSlider *editor = itEditor.next();

        editor->blockSignals(true);

        editor->setSingleStep(step);

        editor->blockSignals(false);

    }

}

void QtSliderFactoryPrivate::slotSetValue(int value)

{

    QObject *object = q_ptr->sender();

    const QMap<QSlider *, QtProperty *>::ConstIterator ecend = m_editorToProperty.constEnd();

    for (QMap<QSlider *, QtProperty *>::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != ecend; ++itEditor ) {

        if (itEditor.key() == object) {

            QtProperty *property = itEditor.value();

            QtIntPropertyManager *manager = q_ptr->propertyManager(property);

            if (!manager)

                return;

            manager->setValue(property, value);

            return;

        }

    }

}

/*!

    \class QtSliderFactory

    \internal

    \inmodule QtDesigner

    \since 4.4

    \brief The QtSliderFactory class provides QSlider widgets for

    properties created by QtIntPropertyManager objects.

    \sa QtAbstractEditorFactory, QtIntPropertyManager

*/

/*!

    Creates a factory with the given \a parent.

*/

QtSliderFactory::QtSliderFactory(QObject *parent)

    : QtAbstractEditorFactory<QtIntPropertyManager>(parent), d_ptr(new QtSliderFactoryPrivate())

{

    d_ptr->q_ptr = this;

}

/*!

    Destroys this factory, and all the widgets it has created.

*/

QtSliderFactory::~QtSliderFactory()

{

    qDeleteAll(d_ptr->m_editorToProperty.keys());

}

/*!

    \internal

    Reimplemented from the QtAbstractEditorFactory class.

*/

void QtSliderFactory::connectPropertyManager(QtIntPropertyManager *manager)

{

}

/*!

    \internal

    Reimplemented from the QtAbstractEditorFactory class.

*/

QWidget *QtSliderFactory::createEditor(QtIntPropertyManager *manager, QtProperty *property,

        QWidget *parent)

{

    QSlider *editor = new QSlider(Qt::Horizontal, parent);

    d_ptr->initializeEditor(property, editor);

    editor->setSingleStep(manager->singleStep(property));

    editor->setRange(manager->minimum(property), manager->maximum(property));

    editor->setValue(manager->value(property));

    connect(editor, SIGNAL(valueChanged(int)), this, SLOT(slotSetValue(int)));

    return editor;

}

/*!

    \internal

    Reimplemented from the QtAbstractEditorFactory class.

*/

void QtSliderFactory::disconnectPropertyManager(QtIntPropertyManager *manager)

{

}

// QtSliderFactory

class QtScrollBarFactoryPrivate : public  EditorFactoryPrivate<QScrollBar>

{

    QtScrollBarFactory *q_ptr;

    Q_DECLARE_PUBLIC(QtScrollBarFactory)

public:

    void slotPropertyChanged(QtProperty *property, int value);

    void slotRangeChanged(QtProperty *property, int min, int max);

    void slotSingleStepChanged(QtProperty *property, int step);

    void slotSetValue(int value);

};

void QtScrollBarFactoryPrivate::slotPropertyChanged(QtProperty *property, int value)

{

    if (!m_createdEditors.contains(property))

        return;

    QListIterator<QScrollBar *> itEditor( m_createdEditors[property]);

    while (itEditor.hasNext()) {

        QScrollBar *editor = itEditor.next();

        editor->blockSignals(true);

        editor->setValue(value);

        editor->blockSignals(false);

    }

}

void QtScrollBarFactoryPrivate::slotRangeChanged(QtProperty *property, int min, int max)

{

    if (!m_createdEditors.contains(property))

        return;

    QtIntPropertyManager *manager = q_ptr->propertyManager(property);

    if (!manager)

        return;

    QListIterator<QScrollBar *> itEditor( m_createdEditors[property]);

    while (itEditor.hasNext()) {

        QScrollBar *editor = itEditor.next();

        editor->blockSignals(true);

        editor->setRange(min, max);

        editor->setValue(manager->value(property));

        editor->blockSignals(false);

    }

}

void QtScrollBarFactoryPrivate::slotSingleStepChanged(QtProperty *property, int step)

{

    if (!m_createdEditors.contains(property))

        return;

    QListIterator<QScrollBar *> itEditor(m_createdEditors[property]);

    while (itEditor.hasNext()) {

        QScrollBar *editor = itEditor.next();

        editor->blockSignals(true);

        editor->setSingleStep(step);

        editor->blockSignals(false);

    }

}

void QtScrollBarFactoryPrivate::slotSetValue(int value)

{

    QObject *object = q_ptr->sender();

    const QMap<QScrollBar *, QtProperty *>::ConstIterator ecend = m_editorToProperty.constEnd();

    for (QMap<QScrollBar *, QtProperty *>::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != ecend; ++itEditor)

        if (itEditor.key() == object) {

            QtProperty *property = itEditor.value();

            QtIntPropertyManager *manager = q_ptr->propertyManager(property);

            if (!manager)

                return;

            manager->setValue(property, value);

            return;

        }

}

/*!

    \class QtScrollBarFactory

    \internal

    \inmodule QtDesigner

    \since 4.4