propertyeditor.cpp

/***************************************************************************
 *   Copyright (C) 2002-2004 by Alexander Dymo                             *
 *   cloudtemple@mskat.net                                                 *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Library General Public License as       *
 *   published by the Free Software Foundation; either version 2 of the    *
 *   License, or (at your option) any later version.                       *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this program; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.             *
 ***************************************************************************/
#include "propertyeditor.h"
 
#ifndef PURE_QT
#include <tdelocale.h>
#include <kdebug.h>
#include <kiconloader.h>
#else
#include "compat_tools.h"
#endif
 
#include <tqtable.h>
#include <tqlayout.h>
#include <tqpainter.h>
#include <tqptrlist.h>
#include <tqvaluelist.h>
#include <tqpushbutton.h>
 
#include "property.h"
#include "multiproperty.h"
#include "propertymachinefactory.h"
 
namespace PropertyLib{
 
class PropertyItem: public TDEListViewItem{
public:
    PropertyItem(PropertyEditor *parent, MultiProperty *property)
        :TDEListViewItem(parent, property->description()), m_editor(parent), m_property(property),
        m_changed(false)
    {
    }
 
    PropertyItem(PropertyEditor *editor, TDEListViewItem *parent, MultiProperty *property)
        :TDEListViewItem(parent, property->description()), m_editor(editor),
        m_property(property), m_changed(false)
    {
    }
 
/*    int type() const
    {
        return m_property->type();
    }
 
    TQString name() const
    {
        return m_property->name();
    }
        */
    MultiProperty *property() const
    {
        return m_property;
    }
 
    virtual void paintCell(TQPainter *p, const TQColorGroup &cg, int column, int width, int align)
    {
        if ((column == 0) && m_changed)
        {
            TQFont font;
            font.setBold(true);
            p->setFont(font);
            p->setBrush(cg.highlight());
            p->setPen(cg.highlightedText());
        }
        if (column == 1)
        {
            TQRect r(0, 0, m_editor->header()->sectionSize(1), height());
            //FIXME: this is ugly, but how else can we deal with ValueFromList properties?
            TQVariant valueToDraw;
            if (m_property->type() == Property::ValueFromList)
                valueToDraw = m_property->findValueDescription();
            else
                valueToDraw = m_property->value();
            TQColorGroup icg(cg);
#ifndef PURE_QT
            icg.setColor(TQColorGroup::Background, backgroundColor(column));
#else
            icg.setColor(TQColorGroup::Background, white);
#endif
            m_editor->machine(m_property)->propertyEditor->drawViewer(p, icg, r, valueToDraw);
            return;
        }
        TDEListViewItem::paintCell(p, cg, column, width, align);
    }
 
    virtual void setup()
    {
        TDEListViewItem::setup();
        setHeight(static_cast<int>(height()*1.5));
    }
 
    void setChanged(bool changed)
    {
        m_changed = changed;
    }
 
private:
    PropertyEditor *m_editor;
    MultiProperty *m_property;
    bool m_changed;
};
 
 
class PropertyGroupItem: public TDEListViewItem{
public:
    PropertyGroupItem(TDEListView *parent, const TQString &name)
        :TDEListViewItem(parent, name)
    {
        init();
    }
    PropertyGroupItem(TDEListViewItem *parent, const TQString &name)
        :TDEListViewItem(parent, name)
    {
        init();
    }
 
    virtual void paintCell(TQPainter *p, const TQColorGroup &cg, int column, int width, int align)
    {
        if (column == 0)
        {
            TQFont font;
            font.setBold(true);
            p->setFont(font);
            p->setBrush(cg.highlight());
            p->setPen(cg.highlightedText());
        }
        TDEListViewItem::paintCell(p, cg, column, width, align);
    }
    virtual void setup()
    {
        TDEListViewItem::setup();
        setHeight(static_cast<int>(height()*1.4));
    }
 
private:
    void init()
    {
        setOpen(true);
    }
};
 
class SeparatorItem: public TDEListViewItem{
public:
    SeparatorItem(TDEListView *parent)
        :TDEListViewItem(parent)
    {
        setSelectable(false);
    }
};
PropertyEditor::PropertyEditor(TQWidget *parent, const char *name)
    :TDEListView(parent, name)
{
    setSorting(-1);
 
    addColumn(i18n("Name"));
    addColumn(i18n("Value"));
    setAllColumnsShowFocus(true);
    setColumnWidthMode(0, TQListView::Maximum);
    setResizeMode(TQListView::LastColumn);
 
    header()->setClickEnabled(false);
 
    connect(header(), TQ_SIGNAL(sizeChange(int, int, int)),
        this, TQ_SLOT(updateEditorSize()));
    connect(this, TQ_SIGNAL(currentChanged(TQListViewItem*)),
        this, TQ_SLOT(slotClicked(TQListViewItem*)));
 
    m_currentEditItem = 0;
    m_doubleClickForEdit = true;
    m_lastClickedItem = 0;
    m_currentEditWidget = 0;
    m_list = 0;
 
    m_currentEditArea = new TQWidget(viewport());
    m_currentEditArea->hide();
    m_undoButton = new TQPushButton(m_currentEditArea);
#ifndef PURE_QT
    m_undoButton->setPixmap(SmallIcon("edit-undo"));
#else
    m_undoButton->setPixmap( TQPixmap("undo.xpm") );
#endif
    m_undoButton->setSizePolicy(TQSizePolicy::Maximum, TQSizePolicy::MinimumExpanding);
    m_undoButton->resize(m_undoButton->height(), m_undoButton->height());
    m_undoButton->hide();
    connect(m_undoButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(undo()));
    m_currentEditLayout = new TQGridLayout(m_currentEditArea, 1, 2, 0, 0);
//    m_currentEditLayout->addWidget(m_undoButton, 0, 1);
}
 
PropertyEditor::~PropertyEditor()
{
    clearMachineCache();
}
 
void PropertyEditor::populateProperties(PropertyList *list)
{
    if (list == 0)
        return;
    m_list = list;
    connect(m_list, TQ_SIGNAL(propertyValueChanged(Property*)), this, TQ_SLOT(propertyValueChanged(Property*)));
    const TQValueList<TQPair<TQString, TQValueList<TQString> > >& groups = m_list->propertiesOfGroup();
    for (TQValueList<TQPair<TQString, TQValueList<TQString> > >::const_iterator it = groups.begin();
        it != groups.end(); ++it)
    {
//        tqWarning("PropertyEditor::populateProperties:    adding group %s", (*it).first.ascii());
        PropertyGroupItem *group = 0;
        if ( (!(*it).first.isEmpty()) && ((*it).second.count() > 0) )
            group = new PropertyGroupItem(this, (*it).first);
        const TQValueList<TQString> &properties = (*it).second;
        for (TQValueList<TQString>::const_iterator it2 = properties.begin(); it2 != properties.end(); ++it2)
        {
//            tqWarning("PropertyEditor::populateProperties:    adding property %s", (*it2).ascii());
            if (group)
                addProperty(group, *it2);
            else
                addProperty(*it2);
        }
    }
    if (firstChild())
    {
        setCurrentItem(firstChild());
        setSelected(firstChild(), true);
        slotClicked(firstChild());
    }
}
 
void PropertyEditor::addProperty(PropertyGroupItem *group, const TQString &name)
{
    if ((*m_list)[name] == 0)
        return;
//        tqWarning("%s = name : object null ", name.ascii());
    PropertyItem *pitem = new PropertyItem(this, group, (*m_list)[name]);
    addChildProperties(pitem);
}
 
void PropertyEditor::addProperty(const TQString &name)
{
    if ((*m_list)[name] == 0)
        return;
//        tqWarning("%s = name : object null ", name.ascii());
    PropertyItem *pitem = new PropertyItem(this, (*m_list)[name]);
    addChildProperties(pitem);
}
 
void PropertyEditor::addChildProperties(PropertyItem *parent)
{
    MultiProperty *prop = parent->property();
    //force machine creation to get detailed properties appended to current multiproperty
    if ( !m_registeredForType.contains(prop->name())
        && (PropertyMachineFactory::getInstance()->hasDetailedEditors(prop->type())) )
    {
        //FIXME: find better solution
        machine(prop);
    }
 
//     tqWarning("seeking children: count: %d", prop->details.count());
 
    parent->setOpen(true);
    for (TQValueList<ChildProperty>::iterator it = prop->details.begin(); it != prop->details.end(); ++it)
    {
//         tqWarning("found child %s", (*it).name().ascii());
        new PropertyItem(this, parent, new MultiProperty(&m_detailedList, &(*it)));
    }
}
 
void PropertyEditor::clearProperties()
{
    m_detailedList.clear();
    if (!m_list)
        return;
 
    hideEditor();
 
    disconnect(m_list, TQ_SIGNAL(propertyValueChanged(Property*)), this, TQ_SLOT(propertyValueChanged(Property*)));
    clear();
    delete m_list;
    m_list = 0;
}
 
void PropertyEditor::propertyValueChanged(Property *property)
{
//     tqWarning("PropertyEditor::propertyValueChanged");
    if (m_currentEditWidget->propertyName() == property->name())
        m_currentEditWidget->setValue(property->value(), false);
    else
    {
//        repaint all items
        TQListViewItemIterator it(this);
        while (it.current())
        {
            repaintItem(it.current());
            ++it;
        }
    }
}
 
void PropertyEditor::propertyChanged(MultiProperty *property, const TQVariant &value)
{
    if (!property)
        return;
 
    tqWarning("editor: assign %s to %s", property->name().latin1(), value.toString().latin1());
    property->setValue(value, false);
 
    //highlight changed properties
    if (m_currentEditItem && (m_currentEditItem->property() == property))
    {
        m_currentEditItem->setChanged(true);
        repaintItem(m_currentEditItem);
    }
 
    emit changed();
 
/*    if (m_list->contains(name))
    {
        (*m_list)[name]->setValue(value, false);
//    else if (m_detailedList->contains(*/
}
 
void PropertyEditor::hideEditor()
{
    m_lastClickedItem = 0;
    m_currentEditItem = 0;
    if (m_currentEditWidget)
    {
        m_currentEditLayout->remove(m_currentEditWidget);
        m_currentEditWidget->hide();
    }
    m_currentEditLayout->remove(m_undoButton);
    m_undoButton->hide();
    m_currentEditArea->hide();
    m_currentEditWidget = 0;
}
 
void PropertyEditor::showEditor(PropertyItem *item)
{
    m_currentEditItem = item;
    placeEditor(item);
    m_currentEditWidget->show();
    m_undoButton->show();
    m_currentEditArea->show();
}
 
void PropertyEditor::placeEditor(PropertyItem *item)
{
    TQRect r = itemRect(item);
    if (!r.size().isValid())
    {
        ensureItemVisible(item);
        r = itemRect(item);
    }
 
    r.setX(header()->sectionPos(1));
    r.setWidth(header()->sectionSize(1));
 
    // check if the column is fully visible
    if (visibleWidth() < r.right())
        r.setRight(visibleWidth());
 
    r = TQRect(viewportToContents(r.topLeft()), r.size());
 
    if (item->pixmap(1))
    {
        r.setX(r.x() + item->pixmap(1)->width());
    }
 
    if (PropertyWidget* editor = prepareEditor(item))
    {
        m_currentEditLayout->addWidget(editor, 0, 0);
        m_currentEditLayout->addWidget(m_undoButton, 0, 1);
        m_currentEditArea->resize(r.size());
//        m_currentEditLayout->invalidate();
        moveChild(m_currentEditArea, r.x(), r.y());
        m_currentEditWidget = editor;
    }
}
 
PropertyWidget* PropertyEditor::prepareEditor(PropertyItem *item)
{
    PropertyWidget *editorWidget = 0;
/*    if (item->depth() >= 2)
    {
        editorWidget = machine(item->name())->propertyEditor;
        editorWidget->setValue(m_accessor->value(item->name()), false);
    }
    else
    {*/
    editorWidget = machine(item->property())->propertyEditor;
    editorWidget->setProperty(item->property());
    if (item->property()->type() == Property::ValueFromList)
        editorWidget->setValueList(item->property()->valueList());
    editorWidget->setValue(item->property()->value(), false);
    //}
    return editorWidget;
}
 
void PropertyEditor::updateEditorSize()
{
    if (m_currentEditItem)
        placeEditor(m_currentEditItem);
}
 
void PropertyEditor::slotClicked(TQListViewItem *item)
{
    if (item == 0)
    {
        hideEditor();
        return;
    }
    if (item != m_lastClickedItem)
    {
        hideEditor();
        PropertyItem *it = dynamic_cast<PropertyItem*>(item);
        if (it)
        {
            showEditor(it);
        }
    }
 
    m_lastClickedItem = item;
}
 
Machine *PropertyEditor::machine(MultiProperty *property)
{
//    int type = property->type();
    TQString name = property->name();
    TQStringVariantMap values = property->valueList();
    if (m_registeredForType[name] == 0)
    {
        m_registeredForType[name] = PropertyMachineFactory::getInstance()->machineForProperty(property);
        connect(m_registeredForType[name]->propertyEditor, TQ_SIGNAL(propertyChanged(MultiProperty*, const TQVariant&)),
        this, TQ_SLOT(propertyChanged(MultiProperty*, const TQVariant&)));
        m_registeredForType[name]->propertyEditor->reparent(m_currentEditArea, 0, m_currentEditArea->childrenRect().topLeft());
        m_registeredForType[name]->propertyEditor->hide();
    }
    return m_registeredForType[name];
}
 
void PropertyEditor::clearMachineCache()
{
    for (TQMap<TQString, Machine* >::iterator it = m_registeredForType.begin(); it != m_registeredForType.end(); ++it)
    {
        delete it.data();
    }
    m_registeredForType.clear();
}
 
void PropertyEditor::undo()
{
    if ((m_currentEditItem == 0) || (m_currentEditWidget == 0)
        || (!m_currentEditWidget->isVisible()))
        return;
 
    m_currentEditWidget->undo();
    m_currentEditItem->setChanged(false);
    repaintItem(m_currentEditItem);
}
 
}
 
#ifndef PURE_QT
#include "propertyeditor.moc"
#endif