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

**

** 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 "qttreepropertybrowser.h"

#include <QtCore/QSet>

#include <QtGui/QIcon>

#include <QtGui/QTreeWidget>

#include <QtGui/QItemDelegate>

#include <QtGui/QHBoxLayout>

#include <QtGui/QHeaderView>

#include <QtGui/QPainter>

#include <QtGui/QApplication>

#include <QtGui/QFocusEvent>

#include <QtGui/QStyle>

#include <QtGui/QPalette>

QT_BEGIN_NAMESPACE

class QtPropertyEditorView;

class QtTreePropertyBrowserPrivate

{

    QtTreePropertyBrowser *q_ptr;

    Q_DECLARE_PUBLIC(QtTreePropertyBrowser)

public:

    QtTreePropertyBrowserPrivate();

    void init(QWidget *parent);

    void propertyInserted(QtBrowserItem *index, QtBrowserItem *afterIndex);

    void propertyRemoved(QtBrowserItem *index);

    void propertyChanged(QtBrowserItem *index);

    QWidget *createEditor(QtProperty *property, QWidget *parent) const

        { return q_ptr->createEditor(property, parent); }

    QtProperty *indexToProperty(const QModelIndex &index) const;

    QTreeWidgetItem *indexToItem(const QModelIndex &index) const;

    QtBrowserItem *indexToBrowserItem(const QModelIndex &index) const;

    bool lastColumn(int column) const;

    void disableItem(QTreeWidgetItem *item) const;

    void enableItem(QTreeWidgetItem *item) const;

    bool hasValue(QTreeWidgetItem *item) const;

    void slotCollapsed(const QModelIndex &index);

    void slotExpanded(const QModelIndex &index);

    QColor calculatedBackgroundColor(QtBrowserItem *item) const;

    QtPropertyEditorView *treeWidget() const { return m_treeWidget; }

    bool markPropertiesWithoutValue() const { return m_markPropertiesWithoutValue; }

    QtBrowserItem *currentItem() const;

    void setCurrentItem(QtBrowserItem *browserItem, bool block);

    void editItem(QtBrowserItem *browserItem);

    void slotCurrentBrowserItemChanged(QtBrowserItem *item);

    void slotCurrentTreeItemChanged(QTreeWidgetItem *newItem, QTreeWidgetItem *);

    QTreeWidgetItem *editedItem() const;

private:

    void updateItem(QTreeWidgetItem *item);

    QMap<QtBrowserItem *, QTreeWidgetItem *> m_indexToItem;

    QMap<QTreeWidgetItem *, QtBrowserItem *> m_itemToIndex;

    QMap<QtBrowserItem *, QColor> m_indexToBackgroundColor;

    QtPropertyEditorView *m_treeWidget;

    bool m_headerVisible;

    QtTreePropertyBrowser::ResizeMode m_resizeMode;

    class QtPropertyEditorDelegate *m_delegate;

    bool m_markPropertiesWithoutValue;

    bool m_browserChangedBlocked;

    QIcon m_expandIcon;

};

// ------------ QtPropertyEditorView

class QtPropertyEditorView : public QTreeWidget

{

    Q_OBJECT

public:

    QtPropertyEditorView(QWidget *parent = 0);

    void setEditorPrivate(QtTreePropertyBrowserPrivate *editorPrivate)

        { m_editorPrivate = editorPrivate; }

    QTreeWidgetItem *indexToItem(const QModelIndex &index) const

        { return itemFromIndex(index); }

protected:

    void keyPressEvent(QKeyEvent *event);

    void mousePressEvent(QMouseEvent *event);

    void drawRow(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const;

private:

    QtTreePropertyBrowserPrivate *m_editorPrivate;

};

QtPropertyEditorView::QtPropertyEditorView(QWidget *parent) :

    QTreeWidget(parent),

    m_editorPrivate(0)

{

    connect(header(), SIGNAL(sectionDoubleClicked(int)), this, SLOT(resizeColumnToContents(int)));

}

void QtPropertyEditorView::drawRow(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const

{

    QStyleOptionViewItemV3 opt = option;

    bool hasValue = true;

    if (m_editorPrivate) {

        QtProperty *property = m_editorPrivate->indexToProperty(index);

        if (property)

            hasValue = property->hasValue();

    }

    if (!hasValue && m_editorPrivate->markPropertiesWithoutValue()) {

        const QColor c = option.palette.color(QPalette::Dark);

        painter->fillRect(option.rect, c);

        opt.palette.setColor(QPalette::AlternateBase, c);

    } else {

        const QColor c = m_editorPrivate->calculatedBackgroundColor(m_editorPrivate->indexToBrowserItem(index));

        if (c.isValid()) {

            painter->fillRect(option.rect, c);

            opt.palette.setColor(QPalette::AlternateBase, c.lighter(112));

        }

    }

    QTreeWidget::drawRow(painter, opt, index);

    QColor color = static_cast<QRgb>(QApplication::style()->styleHint(QStyle::SH_Table_GridLineColor, &opt));

    painter->save();

    painter->setPen(QPen(color));

    painter->drawLine(opt.rect.x(), opt.rect.bottom(), opt.rect.right(), opt.rect.bottom());

    painter->restore();

}

void QtPropertyEditorView::keyPressEvent(QKeyEvent *event)

{

    switch (event->key()) {

    case Qt::Key_Return:

    case Qt::Key_Enter:

    case Qt::Key_Space: // Trigger Edit

        if (!m_editorPrivate->editedItem())

            if (const QTreeWidgetItem *item = currentItem())

                if (item->columnCount() >= 2 && ((item->flags() & (Qt::ItemIsEditable | Qt::ItemIsEnabled)) == (Qt::ItemIsEditable | Qt::ItemIsEnabled))) {

                    event->accept();

                    // If the current position is at column 0, move to 1.

                    QModelIndex index = currentIndex();

                    if (index.column() == 0) {

                        index = index.sibling(index.row(), 1);

                        setCurrentIndex(index);

                    }

                    edit(index);

                    return;

                }

        break;

    default:

        break;

    }

    QTreeWidget::keyPressEvent(event);

}

void QtPropertyEditorView::mousePressEvent(QMouseEvent *event)

{

    QTreeWidget::mousePressEvent(event);

    QTreeWidgetItem *item = itemAt(event->pos());

    if (item) {

        if ((item != m_editorPrivate->editedItem()) && (event->button() == Qt::LeftButton)

                && (header()->logicalIndexAt(event->pos().x()) == 1)

                && ((item->flags() & (Qt::ItemIsEditable | Qt::ItemIsEnabled)) == (Qt::ItemIsEditable | Qt::ItemIsEnabled))) {

            editItem(item, 1);

        } else if (!m_editorPrivate->hasValue(item) && m_editorPrivate->markPropertiesWithoutValue() && !rootIsDecorated()) {

            if (event->pos().x() + header()->offset() < 20)

                item->setExpanded(!item->isExpanded());

        }

    }

}

// ------------ QtPropertyEditorDelegate

class QtPropertyEditorDelegate : public QItemDelegate

{

    Q_OBJECT

public:

    QtPropertyEditorDelegate(QObject *parent = 0)

        : QItemDelegate(parent), m_editorPrivate(0), m_editedItem(0), m_editedWidget(0)

        {}

    void setEditorPrivate(QtTreePropertyBrowserPrivate *editorPrivate)

        { m_editorPrivate = editorPrivate; }

    QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option,

            const QModelIndex &index) const;

    void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option,

            const QModelIndex &index) const;

    void paint(QPainter *painter, const QStyleOptionViewItem &option,

            const QModelIndex &index) const;

    QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const;

    void setModelData(QWidget *, QAbstractItemModel *,

            const QModelIndex &) const {}

    void setEditorData(QWidget *, const QModelIndex &) const {}

    bool eventFilter(QObject *object, QEvent *event);

    void closeEditor(QtProperty *property);

    QTreeWidgetItem *editedItem() const { return m_editedItem; }

private slots:

    void slotEditorDestroyed(QObject *object);

private:

    int indentation(const QModelIndex &index) const;

    typedef QMap<QWidget *, QtProperty *> EditorToPropertyMap;

    mutable EditorToPropertyMap m_editorToProperty;

    typedef QMap<QtProperty *, QWidget *> PropertyToEditorMap;

    mutable PropertyToEditorMap m_propertyToEditor;

    QtTreePropertyBrowserPrivate *m_editorPrivate;

    mutable QTreeWidgetItem *m_editedItem;

    mutable QWidget *m_editedWidget;

};

int QtPropertyEditorDelegate::indentation(const QModelIndex &index) const

{

    if (!m_editorPrivate)

        return 0;

    QTreeWidgetItem *item = m_editorPrivate->indexToItem(index);

    int indent = 0;

    while (item->parent()) {

        item = item->parent();

        ++indent;

    }

    if (m_editorPrivate->treeWidget()->rootIsDecorated())

        ++indent;

    return indent * m_editorPrivate->treeWidget()->indentation();

}

void QtPropertyEditorDelegate::slotEditorDestroyed(QObject *object)

{

    if (QWidget *w = qobject_cast<QWidget *>(object)) {

        const EditorToPropertyMap::iterator it = m_editorToProperty.find(w);

        if (it != m_editorToProperty.end()) {

            m_propertyToEditor.remove(it.value());

            m_editorToProperty.erase(it);

        }

        if (m_editedWidget == w) {

            m_editedWidget = 0;

            m_editedItem = 0;

        }

    }

}

void QtPropertyEditorDelegate::closeEditor(QtProperty *property)

{

    if (QWidget *w = m_propertyToEditor.value(property, 0))

        w->deleteLater();

}

QWidget *QtPropertyEditorDelegate::createEditor(QWidget *parent,

        const QStyleOptionViewItem &, const QModelIndex &index) const

{

    if (index.column() == 1 && m_editorPrivate) {

        QtProperty *property = m_editorPrivate->indexToProperty(index);

        QTreeWidgetItem *item = m_editorPrivate->indexToItem(index);

        if (property && item && (item->flags() & Qt::ItemIsEnabled)) {

            QWidget *editor = m_editorPrivate->createEditor(property, parent);

            if (editor) {

                editor->setAutoFillBackground(true);

                editor->installEventFilter(const_cast<QtPropertyEditorDelegate *>(this));

                connect(editor, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));

                m_propertyToEditor[property] = editor;

                m_editorToProperty[editor] = property;

                m_editedItem = item;

                m_editedWidget = editor;

            }

            return editor;

        }

    }

    return 0;

}

void QtPropertyEditorDelegate::updateEditorGeometry(QWidget *editor,

        const QStyleOptionViewItem &option, const QModelIndex &index) const

{

    Q_UNUSED(index)

    editor->setGeometry(option.rect.adjusted(0, 0, 0, -1));

}

void QtPropertyEditorDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option,

            const QModelIndex &index) const

{

    bool hasValue = true;

    if (m_editorPrivate) {

        QtProperty *property = m_editorPrivate->indexToProperty(index);

        if (property)

            hasValue = property->hasValue();

    }

    QStyleOptionViewItemV3 opt = option;

    if ((m_editorPrivate && index.column() == 0) || !hasValue) {

        QtProperty *property = m_editorPrivate->indexToProperty(index);

        if (property && property->isModified()) {

            opt.font.setBold(true);

            opt.fontMetrics = QFontMetrics(opt.font);

        }

    }

    QColor c;

    if (!hasValue && m_editorPrivate->markPropertiesWithoutValue()) {

        c = opt.palette.color(QPalette::Dark);

        opt.palette.setColor(QPalette::Text, opt.palette.color(QPalette::BrightText));

    } else {

        c = m_editorPrivate->calculatedBackgroundColor(m_editorPrivate->indexToBrowserItem(index));

        if (c.isValid() && (opt.features & QStyleOptionViewItemV2::Alternate))

            c = c.lighter(112);

    }

    if (c.isValid())

        painter->fillRect(option.rect, c);

    opt.state &= ~QStyle::State_HasFocus;

    QItemDelegate::paint(painter, opt, index);

    opt.palette.setCurrentColorGroup(QPalette::Active);

    QColor color = static_cast<QRgb>(QApplication::style()->styleHint(QStyle::SH_Table_GridLineColor, &opt));

    painter->save();

    painter->setPen(QPen(color));

    if (!m_editorPrivate || (!m_editorPrivate->lastColumn(index.column()) && hasValue)) {

        int right = (option.direction == Qt::LeftToRight) ? option.rect.right() : option.rect.left();

        painter->drawLine(right, option.rect.y(), right, option.rect.bottom());

    }

    painter->restore();

}

QSize QtPropertyEditorDelegate::sizeHint(const QStyleOptionViewItem &option,

            const QModelIndex &index) const

{

    return QItemDelegate::sizeHint(option, index) + QSize(3, 4);

}

bool QtPropertyEditorDelegate::eventFilter(QObject *object, QEvent *event)

{

    if (event->type() == QEvent::FocusOut) {

        QFocusEvent *fe = static_cast<QFocusEvent *>(event);

        if (fe->reason() == Qt::ActiveWindowFocusReason)

            return false;

    }

    return QItemDelegate::eventFilter(object, event);

}

//  -------- QtTreePropertyBrowserPrivate implementation

QtTreePropertyBrowserPrivate::QtTreePropertyBrowserPrivate() :

    m_treeWidget(0),

    m_headerVisible(true),

    m_resizeMode(QtTreePropertyBrowser::Stretch),

    m_delegate(0),

    m_markPropertiesWithoutValue(false),

    m_browserChangedBlocked(false)

{

}

// Draw an icon indicating opened/closing branches

static QIcon drawIndicatorIcon(const QPalette &palette, QStyle *style)

{

    QPixmap pix(14, 14);

    pix.fill(Qt::transparent);

    QStyleOption branchOption;

    QRect r(QPoint(0, 0), pix.size());

    branchOption.rect = QRect(2, 2, 9, 9); // ### hardcoded in qcommonstyle.cpp

    branchOption.palette = palette;

    branchOption.state = QStyle::State_Children;

    QPainter p;

    // Draw closed state

    p.begin(&pix);

    style->drawPrimitive(QStyle::PE_IndicatorBranch, &branchOption, &p);

    p.end();

    QIcon rc = pix;

    rc.addPixmap(pix, QIcon::Selected, QIcon::Off);

    // Draw opened state

    branchOption.state |= QStyle::State_Open;

    pix.fill(Qt::transparent);

    p.begin(&pix);

    style->drawPrimitive(QStyle::PE_IndicatorBranch, &branchOption, &p);

    p.end();

    rc.addPixmap(pix, QIcon::Normal, QIcon::On);

    rc.addPixmap(pix, QIcon::Selected, QIcon::On);

    return rc;

}

void QtTreePropertyBrowserPrivate::init(QWidget *parent)

{

    QHBoxLayout *layout = new QHBoxLayout(parent);

    layout->setMargin(0);

    m_treeWidget = new QtPropertyEditorView(parent);

    m_treeWidget->setEditorPrivate(this);

    m_treeWidget->setIconSize(QSize(18, 18));

    layout->addWidget(m_treeWidget);

    m_treeWidget->setColumnCount(2);

    QStringList labels;

    labels.append(QApplication::translate("QtTreePropertyBrowser", "Property", 0, QApplication::UnicodeUTF8));

    labels.append(QApplication::translate("QtTreePropertyBrowser", "Value", 0, QApplication::UnicodeUTF8));

    m_treeWidget->setHeaderLabels(labels);

    m_treeWidget->setAlternatingRowColors(true);

    m_treeWidget->setEditTriggers(QAbstractItemView::EditKeyPressed);

    m_delegate = new QtPropertyEditorDelegate(parent);

    m_delegate->setEditorPrivate(this);

    m_treeWidget->setItemDelegate(m_delegate);

    m_treeWidget->header()->setMovable(false);

    m_treeWidget->header()->setResizeMode(QHeaderView::Stretch);

    m_expandIcon = drawIndicatorIcon(q_ptr->palette(), q_ptr->style());

    QObject::connect(m_treeWidget, SIGNAL(collapsed(QModelIndex)), q_ptr, SLOT(slotCollapsed(QModelIndex)));

    QObject::connect(m_treeWidget, SIGNAL(expanded(QModelIndex)), q_ptr, SLOT(slotExpanded(QModelIndex)));

    QObject::connect(m_treeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)), q_ptr, SLOT(slotCurrentTreeItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)));

}

QtBrowserItem *QtTreePropertyBrowserPrivate::currentItem() const

{

    if (QTreeWidgetItem *treeItem = m_treeWidget->currentItem())

        return m_itemToIndex.value(treeItem);

    return 0;

}

void QtTreePropertyBrowserPrivate::setCurrentItem(QtBrowserItem *browserItem, bool block)

{

    const bool blocked = block ? m_treeWidget->blockSignals(true) : false;

    if (browserItem == 0)

        m_treeWidget->setCurrentItem(0);

    else

        m_treeWidget->setCurrentItem(m_indexToItem.value(browserItem));

    if (block)

        m_treeWidget->blockSignals(blocked);

}

QtProperty *QtTreePropertyBrowserPrivate::indexToProperty(const QModelIndex &index) const

{

    QTreeWidgetItem *item = m_treeWidget->indexToItem(index);

    QtBrowserItem *idx = m_itemToIndex.value(item);

    if (idx)

        return idx->property();

    return 0;

}

QtBrowserItem *QtTreePropertyBrowserPrivate::indexToBrowserItem(const QModelIndex &index) const

{

    QTreeWidgetItem *item = m_treeWidget->indexToItem(index);

    return m_itemToIndex.value(item);

}

QTreeWidgetItem *QtTreePropertyBrowserPrivate::indexToItem(const QModelIndex &index) const

{

    return m_treeWidget->indexToItem(index);

}

bool QtTreePropertyBrowserPrivate::lastColumn(int column) const

{

    return m_treeWidget->header()->visualIndex(column) == m_treeWidget->columnCount() - 1;

}

void QtTreePropertyBrowserPrivate::disableItem(QTreeWidgetItem *item) const

{

    Qt::ItemFlags flags = item->flags();

    if (flags & Qt::ItemIsEnabled) {

        flags &= ~Qt::ItemIsEnabled;

        item->setFlags(flags);

        m_delegate->closeEditor(m_itemToIndex[item]->property());

        const int childCount = item->childCount();

        for (int i = 0; i < childCount; i++) {

            QTreeWidgetItem *child = item->child(i);

            disableItem(child);

        }

    }

}

void QtTreePropertyBrowserPrivate::enableItem(QTreeWidgetItem *item) const

{

    Qt::ItemFlags flags = item->flags();

    flags |= Qt::ItemIsEnabled;

    item->setFlags(flags);

    const int childCount = item->childCount();

    for (int i = 0; i < childCount; i++) {

        QTreeWidgetItem *child = item->child(i);

        QtProperty *property = m_itemToIndex[child]->property();

        if (property->isEnabled()) {

            enableItem(child);