editoritem.cpp

/* This file is part of the KDE project
   Copyright (C) 2004 Cedric Pasteur <cedric.pasteur@free.fr>
   Copyright (C) 2004 Alexander Dymo <cloudtemple@mskat.net>
   Copyright (C) 2004-2006 Jaroslaw Staniek <js@iidea.pl>
 
   This library 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 library 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
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/
 
#include "editoritem.h"
#include "editor.h"
#include "property.h"
#include "widget.h"
#include "factory.h"
#include "utils.h"
 
#include <tqpainter.h>
#include <tqpixmap.h>
#include <tqheader.h>
#include <tqstyle.h>
#include <tqlabel.h>
#include <tqlayout.h>
 
#include <kdebug.h>
#include <kiconloader.h>
#include <tdestyle.h>
#include <tdepopupmenu.h>
#include <tdeapplication.h>
 
#define BRANCHBOX_SIZE 9
 
namespace KoProperty {
class EditorItemPrivate
{
    public:
        EditorItemPrivate()
        : property(0) {}
        ~EditorItemPrivate() {}
 
        Property  *property;
        Editor  *editor;
};

static void paintListViewExpander(TQPainter* p, TQWidget* w, int height, const TQColorGroup& cg, bool isOpen)
{
    const int marg = (height -2 - BRANCHBOX_SIZE) / 2;
    int xmarg = marg;
//      if (dynamic_cast<EditorGroupItem*>(item))
//              xmarg = xmarg * 10 / 14 -1;
#if 0 
    TDEStyle* tdestyle = dynamic_cast<TDEStyle*>(widget->style());
    if (tdestyle) {
        tdestyle->drawTDEStylePrimitive(
            TDEStyle::KPE_ListViewExpander, p, w, TQRect( xmarg, marg, BRANCHBOX_SIZE, BRANCHBOX_SIZE ), 
            cg, isOpen ? 0 : TQStyle::Style_On,
                TQStyleOption::Default);
    }
    else {
#endif
        Q_UNUSED(w);
        //draw by hand
        p->setPen( KPROPEDITOR_ITEM_BORDER_COLOR );
        p->drawRect(xmarg, marg, BRANCHBOX_SIZE, BRANCHBOX_SIZE);
        p->fillRect(xmarg+1, marg + 1, BRANCHBOX_SIZE-2, BRANCHBOX_SIZE-2,
//          item->listView()->paletteBackgroundColor());
            cg.base());
//      p->setPen( item->listView()->paletteForegroundColor() );
        p->setPen( cg.foreground() );
        p->drawLine(xmarg+2, marg+BRANCHBOX_SIZE/2, xmarg+BRANCHBOX_SIZE-3, marg+BRANCHBOX_SIZE/2);
        if(!isOpen) {
            p->drawLine(xmarg+BRANCHBOX_SIZE/2, marg+2,
                xmarg+BRANCHBOX_SIZE/2, marg+BRANCHBOX_SIZE-3);
        }
//  }
}

class GroupWidgetBase : public TQWidget
{
    public:
        GroupWidgetBase(TQWidget* parent)
        : TQWidget(parent)
        , m_isOpen(true)
        , m_mouseDown(false)
        {
            setSizePolicy(TQSizePolicy(TQSizePolicy::Preferred, TQSizePolicy::Fixed, 0, 1));
        }
 
        void setText( const TQString &text )
        {
            m_titleStr = text;
        }
 
        void setIcon( const TQPixmap &pix )
        {
            m_miniicon = pix;
        }
 
        virtual bool isOpen() const
        {
            return m_isOpen;
        }
 
        virtual void setOpen(bool set)
        {
            m_isOpen = set;
        }
 
        virtual TQSize sizeHint () const
        {
            TQSize s( TQWidget::sizeHint() );
            s.setHeight(fontMetrics().height()*2);
            return s;
        }
 
    protected:
        virtual void paintEvent(TQPaintEvent *) {
            TQRect r(rect());
            TQPainter p(this);
            TQStyle::StyleFlags flags = m_mouseDown ? TQStyle::Style_Down : TQStyle::Style_Default;
            kapp->style().drawPrimitive(TQStyle::PE_HeaderSection, &p, r, palette().active(), flags);
 
            paintListViewExpander(&p, this, r.height()+2, palette().active(), isOpen());
            if (!m_miniicon.isNull()) {
                p.drawPixmap(24, (r.height()-m_miniicon.height())/2, m_miniicon);
            }
 
            if (!m_titleStr.isNull())
            {
                int indent = 16 + (m_miniicon.isNull() ? 0 : (m_miniicon.width()+4));
                p.setPen(palette().active().text());
                TQFont f = p.font();
                f.setBold(true);
                p.setFont(f);
                p.drawText(indent+8, 0, width()-(indent+8),
                        height(), AlignLeft | AlignVCenter | SingleLine,
                        m_titleStr);
            }
//          p.setPen(palette().active().mid());
//          p.drawLine(0, 0, r.right(), 0);
        }
 
        virtual bool event( TQEvent * e ) {
            if (e->type()==TQEvent::MouseButtonPress || e->type()==TQEvent::MouseButtonRelease) {
                TQMouseEvent* me = static_cast<TQMouseEvent*>(e);
                if (me->button() == TQt::LeftButton) {
                    m_mouseDown = e->type()==TQEvent::MouseButtonPress;
                    update();
                }
            }
            return TQWidget::event(e);
        }
 
    protected:
        TQString m_titleStr;
        TQPixmap m_miniicon;
        bool m_isOpen : 1;
        bool m_mouseDown : 1;
};
 
class GroupWidget : public GroupWidgetBase
{
    public:
        GroupWidget(EditorGroupItem *parentItem)
        : GroupWidgetBase(parentItem->listView()->viewport())
        , m_parentItem(parentItem)
        {
        }
 
        virtual bool isOpen() const
        {
            return m_parentItem->isOpen();
        }
 
    protected:
        EditorGroupItem *m_parentItem;
};
 
class GroupContainer::Private
{
    public:
        Private() {}
        TQVBoxLayout* lyr;
        GroupWidgetBase *groupWidget;
        TQGuardedPtr<TQWidget> contents;
};
 
}//namespace
 
using namespace KoProperty;
 
GroupContainer::GroupContainer(const TQString& title, TQWidget* parent)
: TQWidget(parent)
, d(new Private())
{
    setSizePolicy(TQSizePolicy(TQSizePolicy::Preferred, TQSizePolicy::Fixed, 0, 1));
    d->lyr = new TQVBoxLayout(this);
    d->groupWidget = new GroupWidgetBase(this);
    d->groupWidget->setText( title );
    d->lyr->addWidget(d->groupWidget);
    d->lyr->addSpacing(4);
}
 
GroupContainer::~GroupContainer()
{
    delete d;
}
 
void GroupContainer::setContents( TQWidget* contents )
{
    if (d->contents) {
        d->contents->hide();
        d->lyr->remove(d->contents);
        delete d->contents;
    }
    d->contents = contents;
    if (d->contents) {
        d->lyr->addWidget(d->contents);
        d->contents->show();
    }
    update();
}
 
bool GroupContainer::event( TQEvent * e ) {
    if (e->type()==TQEvent::MouseButtonPress) {
        TQMouseEvent* me = static_cast<TQMouseEvent*>(e);
        if (me->button() == TQt::LeftButton && d->contents && d->groupWidget->rect().contains(me->pos())) {
            d->groupWidget->setOpen(!d->groupWidget->isOpen());
            if (d->groupWidget->isOpen())
                d->contents->show();
            else
                d->contents->hide();
            d->lyr->invalidate();
            update();
        }
    }
    return TQWidget::event(e);
}

 
EditorItem::EditorItem(Editor *editor, EditorItem *parent, Property *property, TQListViewItem *after)
 : TDEListViewItem(parent, after,
    property->captionForDisplaying().isEmpty() ? property->name() : property->captionForDisplaying())
{
    d = new EditorItemPrivate();
    d->property = property;
    d->editor = editor;
 
    setMultiLinesEnabled(true);
    //setHeight(static_cast<Editor*>(listView())->baseRowHeight()*3);
/*
    if (property && !property->caption().isEmpty()) {
            TQSimpleRichText srt(property->caption(), font());
            srt.setWidth(columnWidth(0)-KPROPEDITOR_ITEM_MARGIN*2-20+1);
            int oldHeight = it.current()->height();
            int textHeight = srt.height()+KPROPEDITOR_ITEM_MARGIN;
            int textLines = textHeight / d->baseRowHeight + (((textHeight % d->baseRowHeight) > 0) ? 1 : 0);
            kdDebug() << " textLines: " << textLines << endl;
            if (textLines != newNumLines) {
                dynamic_cast<EditorItem*>(it.current())->setHeight(newNumLines * d->baseRowHeight);
            }
            kdDebug() << it.current()->text(0) << ":  "  << oldHeight << " -> " << newHeight << endl;
        }
*/
}
 
EditorItem::EditorItem(TDEListView *parent)
 : TDEListViewItem(parent)
{
    d = new EditorItemPrivate();
    d->property = 0;
    d->editor = 0;
    setMultiLinesEnabled(true);
}
 
EditorItem::EditorItem(EditorItem *parent, const TQString &text)
 : TDEListViewItem(parent, text)
{
    d = new EditorItemPrivate();
    d->property = 0;
    d->editor = 0;
    setMultiLinesEnabled(true);
}
 
EditorItem::EditorItem(EditorItem *parent, EditorItem *after, const TQString &text)
 : TDEListViewItem(parent, after, text)
{
    d = new EditorItemPrivate();
    d->property = 0;
    d->editor = 0;
    setMultiLinesEnabled(true);
}
 
EditorItem::~EditorItem()
{
    delete d;
}
 
Property*
EditorItem::property()
{
    return d->property;
}
 
void
EditorItem::paintCell(TQPainter *p, const TQColorGroup & cg, int column, int width, int align)
{
    //int margin = static_cast<Editor*>(listView())->itemMargin();
    if(!d->property)
        return;
 
    if(column == 0)
    {
        TQFont font = listView()->font();
        if(d->property->isModified())
            font.setBold(true);
        p->setFont(font);
        p->setBrush(cg.highlight());
        p->setPen(cg.highlightedText());
        TDEListViewItem::paintCell(p, cg, column, width, align);
        p->fillRect(parent() ? 0 : 50, 0, width, height()-1,
            TQBrush(isSelected() ? cg.highlight() : backgroundColor()));
        p->setPen(isSelected() ? cg.highlightedText() : cg.text());
        int delta = -20+KPROPEDITOR_ITEM_MARGIN;
        if ((firstChild() && dynamic_cast<EditorGroupItem*>(parent()))) {
            delta = -KPROPEDITOR_ITEM_MARGIN-1;
        }
        if (dynamic_cast<EditorDummyItem*>(parent())) {
            delta = KPROPEDITOR_ITEM_MARGIN*2;
        }
        else if (parent() && dynamic_cast<EditorDummyItem*>(parent()->parent())) {
            if (dynamic_cast<EditorGroupItem*>(parent()))
                delta += KPROPEDITOR_ITEM_MARGIN*2;
            else
                delta += KPROPEDITOR_ITEM_MARGIN*5;
        }
        p->drawText(
            TQRect(delta,2, width+listView()->columnWidth(1)-KPROPEDITOR_ITEM_MARGIN*2, height()),
            TQt::AlignLeft | TQt::AlignTop /*| TQt::SingleLine*/, text(0));
 
        p->setPen( KPROPEDITOR_ITEM_BORDER_COLOR );
        p->drawLine(width-1, 0, width-1, height()-1);
        p->drawLine(0, -1, width-1, -1);
 
        p->setPen( KPROPEDITOR_ITEM_BORDER_COLOR ); 
        if (dynamic_cast<EditorDummyItem*>(parent()))
            p->drawLine(0, 0, 0, height()-1 );
    }
    else if(column == 1)
    {
        TQColorGroup icg(cg);
        icg.setColor(TQColorGroup::Background, backgroundColor());
        p->setBackgroundColor(backgroundColor());
        Widget *widget = d->editor->createWidgetForProperty(d->property, false /*don't change Widget::property() */);
        if(widget) {
            TQRect r(0, 0, d->editor->header()->sectionSize(1), height() - (widget->hasBorders() ? 0 : 1));
            p->setClipRect(r, TQPainter::CoordPainter);
            p->setClipping(true);
            widget->drawViewer(p, icg, r, d->property->value());
            p->setClipping(false);
        }
    }
    p->setPen( KPROPEDITOR_ITEM_BORDER_COLOR ); 
    p->drawLine(0, height()-1, width, height()-1 );
}
 
void
EditorItem::paintBranches(TQPainter *p, const TQColorGroup &cg, int w, int y, int h)
{
    p->eraseRect(0,0,w,h);
    TDEListViewItem *item = static_cast<TDEListViewItem*>(firstChild());
    if(!item)
        return;
 
    TQColor backgroundColor;
    p->save();
    p->translate(0,y);
    TQFont font = listView()->font();
    while(item)
    {
        if(item->isSelected())
            backgroundColor = cg.highlight();
        else {
            if (dynamic_cast<EditorGroupItem*>(item))
                backgroundColor = cg.base();
            else
                backgroundColor = item->backgroundColor();
        }
//      p->fillRect(-50,0,50, item->height(), TQBrush(backgroundColor));
        p->save();
        p->setPen( KPROPEDITOR_ITEM_BORDER_COLOR );
        int delta = 0;
        int fillWidth = w;
        int x = 0;
        if (dynamic_cast<EditorGroupItem*>(item->parent())) {
            delta = 0;//-19;
            fillWidth += 19;
        }
        else {
            if (dynamic_cast<EditorGroupItem*>(item) || /*for flat mode*/ dynamic_cast<EditorDummyItem*>(item->parent()))
                x = 19;
            else
                x = -19;
            fillWidth += 19;
        }
        if (dynamic_cast<EditorDummyItem*>(item->parent())) {
            x = 19;
        }
        else if (item->parent() && dynamic_cast<EditorDummyItem*>(item->parent()->parent())) {
            x = 0;
        }
        p->fillRect(x+1, 0, fillWidth-1, item->height()-1, TQBrush(backgroundColor));
        p->drawLine(x, item->height()-1, w, item->height()-1 );
        if (!dynamic_cast<EditorGroupItem*>(item))
            p->drawLine(x, 0, x, item->height()-1 );
        p->restore();
 
//  for (int i=0; i<10000000; i++)
//      ;
//      if(item->isSelected())  {
//          p->fillRect(parent() ? 0 : 50, 0, w, item->height()-1, TQBrush(cg.highlight()));
//          p->fillRect(-50,0,50, item->height(), TQBrush(cg.highlight()));
//      }
 
        //sorry, but we need to draw text here again
        font.setBold( dynamic_cast<EditorGroupItem*>(item)
            || (static_cast<EditorItem*>(item)->property() && static_cast<EditorItem*>(item)->property()->isModified()) );
        p->setFont(font);
        p->setPen(item->isSelected() ? cg.highlightedText() : cg.text());
        if (item->firstChild() && dynamic_cast<EditorGroupItem*>(item->parent())) {
            delta = 19-KPROPEDITOR_ITEM_MARGIN-1;
        }
        else if (dynamic_cast<EditorDummyItem*>(item->parent())) {
            delta = 19;
        }
        if (item->parent() && dynamic_cast<EditorDummyItem*>(item->parent()->parent())) {
            if (dynamic_cast<EditorGroupItem*>(item->parent()))
                delta += KPROPEDITOR_ITEM_MARGIN*2;
            else
                delta += KPROPEDITOR_ITEM_MARGIN*5;
        }
 
        if (!dynamic_cast<EditorDummyItem*>(item->parent()))
            p->drawText(TQRect(delta+1,0, w+listView()->columnWidth(1), item->height()),
            TQt::AlignLeft | TQt::AlignVCenter /*| TQt::SingleLine*/, item->text(0));
 
        if(item->firstChild())  {
            paintListViewExpander(p, listView(), item->height(),
                cg, item->isOpen());
        }
 
        // draw icon (if there is one)
        EditorItem *editorItem = dynamic_cast<EditorItem*>(item);
        if (editorItem && editorItem->property() && !editorItem->property()->icon().isEmpty()) {
            //int margin = listView()->itemMargin();
            TQPixmap pix = SmallIcon(editorItem->property()->icon());
            if (!pix.isNull())
                p->drawPixmap(-19+(19-pix.width())/2, (item->height() - pix.height()) / 2, pix);
        }
 
        p->translate(0, item->totalHeight());
        item = (TDEListViewItem*)item->nextSibling();
    }
    p->restore();
}
 
void
EditorItem::paintFocus(TQPainter *, const TQColorGroup &, const TQRect & )
{
}
 
int
EditorItem::compare( TQListViewItem *i, int col, bool ascending ) const
{
    if (!ascending)
        return -TQListViewItem::key( col, ascending ).localeAwareCompare( i->key( col, ascending ) );
 
    if (d->property) {
//      kopropertydbg << d->property->name() << " " << d->property->sortingKey() << " | "
//          << static_cast<EditorItem*>(i)->property()->name() << " "
//          << static_cast<EditorItem*>(i)->property()->sortingKey() << endl;
        return d->property->sortingKey()
            - ((dynamic_cast<EditorItem*>(i) && dynamic_cast<EditorItem*>(i)->property()) 
                ? dynamic_cast<EditorItem*>(i)->property()->sortingKey() : 0);
    }
 
    return 0;
//  return d->order - static_cast<EditorItem*>(i)->d->order;
}
 
void
EditorItem::setHeight( int height )
{
    TDEListViewItem::setHeight(height);
}

 
EditorGroupItem::EditorGroupItem(EditorItem *parent, EditorItem *after, const TQString &text, const TQString &icon, int sortOrder)
 : EditorItem(parent, after, text)
 , m_label(0)
 , m_sortOrder(sortOrder)
{
    init(icon);
}
 
EditorGroupItem::EditorGroupItem(EditorItem *parent, const TQString &text, const TQString &icon, int sortOrder)
 : EditorItem(parent, text)
 , m_label(0)
 , m_sortOrder(sortOrder)
{
    init(icon);
}
 
EditorGroupItem::~EditorGroupItem()
{
    delete m_label;
}
 
TQWidget* EditorGroupItem::label() const
{
    return m_label;
}
 
void EditorGroupItem::init(const TQString &icon)
{
    setOpen(true);
    setSelectable(false);
    m_label = new GroupWidget(this);
    m_label->setText(text(0)); //todo: icon?
    if (!icon.isEmpty())
        m_label->setIcon( SmallIcon(icon) );
    m_label->show();
}
 
void
EditorGroupItem::paintCell(TQPainter *p, const TQColorGroup & cg, int column, int width, int /*align*/)
{
    Q_UNUSED(p);
    Q_UNUSED(cg);
    Q_UNUSED(column);
    Q_UNUSED(width);
    //no need to draw anything since there's a label on top of it
//  p->fillRect(0, 0, width, height(), cg.base());
 
    //if(column == 1)
    //  return;
    /*p->setPen( KPROPEDITOR_ITEM_BORDER_COLOR ); //! \todo custom color?
 
    p->setClipRect(listView()->itemRect(this));
    if(column == 1)
        p->translate(-listView()->columnWidth(0) + 20, 0);
    int totalWidth = listView()->columnWidth(0) + listView()->columnWidth(1) - 20;
    p->eraseRect(TQRect(0,0, totalWidth,height()-1));
    p->drawLine(0, height()-1, totalWidth-1, height()-1);
 
    TQFont font = listView()->font();
    font.setBold(true);
    p->setFont(font);
    p->setBrush(cg.highlight());
    //p->setPen(cg.highlightedText());
    TDEListViewItem::paintCell(p, cg, column, width, align);
    p->setPen(cg.text());
    p->drawText(TQRect(0,0, totalWidth, height()),
        TQt::AlignLeft | TQt::AlignVCenter | TQt::SingleLine, text(0));*/
}
 
void
EditorGroupItem::setup()
{
    TDEListViewItem::setup();
    setHeight( height()+4 );
}
 
int
EditorGroupItem::compare( TQListViewItem *i, int col, bool ascending ) const
{
    Q_UNUSED(col);
    Q_UNUSED(ascending);
    if (dynamic_cast<EditorGroupItem*>(i)) {
        return m_sortOrder 
            - dynamic_cast<EditorGroupItem*>(i)->m_sortOrder;
    }
    return 0;
}

 
EditorDummyItem::EditorDummyItem(TDEListView *listview)
 : EditorItem(listview)
{
    setSelectable(false);
    setOpen(true);
}
 
EditorDummyItem::~EditorDummyItem()
{}
 
void
EditorDummyItem::setup()
{
    setHeight(0);
}