faithui/faith/listview.h

Go to the documentation of this file.

#ifndef FAITH__LISTVIEW_H
#define FAITH__LISTVIEW_H

#include <faith/scrollview.h>
#include <list>
#include <faith/ui.h>


namespace Faith
{

class GListViewThing;
class GListView;

class FAITH_UI_EXPORT GItemView
{
public:
        GItemView();
        virtual ~GItemView();
        virtual void gInserted(void *item)=0;
        virtual void gRemoved(void *item)=0;
        virtual void gChanged()=0;

};

class FAITH_UI_EXPORT GListItemSet : public Faith::Object
{
        Q_OBJECT
        struct GListItemSetPrivate;
        GListItemSetPrivate *d;
        
        friend class GItemView;
        friend class GListView;
        
public:
        class GIterator
        {
                struct GListItemSetIteratorPrivate;
                GListItemSetIteratorPrivate *d;
                friend class GListItemSet;
        public:
                GIterator();
                GIterator(const GIterator &copy);
                ~GIterator();
                
                GIterator & operator=(const GIterator &copy);
                bool operator==(const GIterator &other) const;
                bool operator!=(const GIterator &other) const
                        { return !operator==(other); }
                
                GIterator &operator++();
                void *operator *();
        };
        
        GListItemSet(Faith::Object *parent, const char *name);
        ~GListItemSet();
        
protected:
        void gAppend(void *item);
        void gPrepend(void *item);
        void gInsert(const GIterator &before, void *item);
        void gRemove(void *item);
        void gChanged();
        
        GIterator gBegin();
        GIterator gEnd();
        
private:
        void addedTo(GItemView *);
        void removedFrom(GItemView *);
};

class FAITH_UI_EXPORT GListView : public Faith::ScrollView, public GItemView
{
        Q_OBJECT
        struct GListViewPrivate;
        GListViewPrivate *d;
        
        friend class GListItemSet;
        
public:
        GListView(GListItemSet *set, Widget *parent, const char *name);
        ~GListView();
        
protected:
        void gSetListItemSet(GListItemSet *set);
        GListItemSet *gListItemSet();

        std::list<void*> gSelectedItems();
        void *gCurrentItem();
        void *gFirstChild();
        void *gFirstChild(void *of);
        void *gNextSibling(void *after);
        void *gItemAt(const Faith::Point &pt);
        
        void gSetCurrent(void *g);
        
        void gSetSelected(void *item, bool sel);
        bool gIsSelected(const void *item) const;
        void gClearSelection();
        
        void gAddColumn(const Faith::String &name);
        
        void contentsPaintEvent(Faith::PaintEvent *e);
        void contentsMousePressEvent(Faith::MouseEvent *e);
        void contentsKeyPressEvent(Faith::KeyPressEvent *e);
        
        void gEnsureVisible(void *item);
        
        Faith::Rect itemRect(void *item);

private:
        virtual GListViewThing *thing()=0;
        
        void gInserted(void *item);
        void gRemoved(void *item);
        void gChanged();
        Faith::Size gCalculateSize();
        
        virtual void gCurrentChanged()=0;
        virtual void gSelectionChanged()=0;
};

class FAITH_UI_EXPORT GListViewThing
{
        GListView *mList;
public:
        GListViewThing();
        virtual ~GListViewThing() { }
        
        GListView *gList() { return mList; }
        void gSetList(GListView *list) { mList = list; }

        virtual void gPaint(void *item, Faith::Painter *p, unsigned int column)=0;
        virtual int gHeight(void *item) const=0;
        virtual int gWidth(void *item, unsigned int column) const=0;
};

class ListItem;

template <typename Item=ListItem>
class FAITH_UI_EXPORT ListItemSet : public GListItemSet
{
public:
        class Iterator;

        class ConstIterator : private GListItemSet::GIterator
        {
                inline ConstIterator() { }
                friend class ListItemSet;
                friend class Iterator;

                static ConstIterator fromG(const GListItemSet::GIterator &g) { ConstIterator x; x = g; return x; }

        public:
                ConstIterator(const ConstIterator &copy)
                        : GIterator(copy) { }

                ConstIterator & operator=(const ConstIterator &copy)
                        { GIterator::operator=(copy); return *this; }
                ConstIterator & operator=(const Iterator &copy)
                        { GIterator::operator=(copy); return *this; }
                        
                bool operator==(const ConstIterator &other) const
                        { return GIterator::operator==(other); }
                bool operator!=(const ConstIterator &other) const
                        { return GIterator::operator!=(other); }
                
                ConstIterator &operator++()
                        { GIterator::operator++(); return *this; }
                const Item *operator *() const
                        {
                                return static_cast<const Item*>(
                                                const_cast<ConstIterator*>(this)->GIterator::operator*()
                                        ); 
                        }

        };
        
        class Iterator : private GListItemSet::GIterator
        {
                inline Iterator() { }
                Iterator(const GIterator &copy)
                        : GIterator(copy) { }
                friend class ListItemSet;
                friend class ConstIterator;
        public:
                Iterator(const Iterator &copy)
                        : GIterator(copy) { }
                
                Iterator & operator=(const Iterator &copy)
                        { GIterator::operator=(copy); return *this; }
                        
                bool operator==(const Iterator &other) const
                        { return GIterator::operator==(other); }
                bool operator!=(const Iterator &other) const
                        { return GIterator::operator!=(other); }
                
                Iterator &operator++()
                        { GIterator::operator++(); return *this; }
                Item *operator *()
                        { return static_cast<Item*>(GIterator::operator*()); }
                        
                operator ConstIterator () const { return ConstIterator::fromG(*this); }
        };
                

        ListItemSet(Faith::Object *parent, const char *name=0)
                : GListItemSet(parent, name)
        {
        }
        
        void append(Item *item)
        {
                gAppend(item);
        }
        
        void prepend(Item *item)
        {
                gPrepend(item);
        }
        
        void insert(const Iterator &before, Item *item)
        {
                gInsert(before, item);
        }
        
        void remove(Item *item)
        {
                gRemove(item);
        }
        
        void changed()
        {
                gChanged();
        }
        
        
        Iterator begin() { return Iterator(gBegin()); }
        Iterator end() { return Iterator(gEnd()); }
        
        ConstIterator begin() const { return ConstIterator(gBegin()); }
        ConstIterator end() const { return ConstIterator(gEnd()); }

};

template <typename Item=ListItem>
class FAITH_UI_EXPORT ListView : public GListView
{
        Q_OBJECT
        
public:
        ListView(Faith::Widget *parent, const char *name=0)
                : GListView(0, parent, name)
        {
        }
        
        ListView(ListItemSet<Item> *set, Faith::Widget *parent, const char *name=0)
                : GListView(set, parent, name)
        {
        }

        std::list<Item*> selectedItems()
        {
                std::list<Item*> l;
                std::list<void*> s = gSelectedItems();
                for (std::list<void*>::iterator i(s.begin()); i != s.end(); ++i)
                        l.push_back(static_cast<Item*>(*i));
                return l;
        }
        
        std::list<const Item*> selectedItems() const
        {
                std::list<const Item*> l;
                std::list<void*> s = const_cast<ListView*>(this)->gSelectedItems();
                for (std::list<void*>::iterator i(s.begin()); i != s.end(); ++i)
                        l.push_back(static_cast<Item*>(*i));
                return l;
        }
        
        void setSet(ListItemSet<Item> *set)
        {
                gSetListItemSet(set);
        }
        
        Item *currentItem()
        {
                return static_cast<Item*>(gCurrentItem());
        }
        
        const Item *currentItem() const
        {
                return static_cast<const Item*>(const_cast<ListView*>(this)->gCurrentItem());
        }

        Item *gItemAt(const Faith::Point &pt)
        {
                return static_cast<Item*>(gItemAt(pt));
        }
        
        const Item *gItemAt(const Faith::Point &pt) const
        {
                return static_cast<Item*>(const_cast<GListView*>(this)->gItemAt(pt));
        }
        
        void setCurrent(Item *g)
        {
                gSetCurrent(g);
        }
        
        void setSelected(Item *item, bool sel)
        {
                gSetSelected(item, sel);
        }
        
        bool isSelected(const Item *item) const
        {
                return gIsSelected(item);
        }
        
        void clearSelection()
        {
                gClearSelection();
        }

        Item *firstChild()
                { return static_cast<Item*>(gFirstChild()); } 
        Item *firstChild(Item *of)
                { return static_cast<Item*>(gFirstChild(of)); } 
        Item *nextSibling()
                { return static_cast<Item*>(gNextSibling()); } 

        void ensureVisible(Item *item)
                { gEnsureVisible(item); }

        void addColumn(const Faith::String &name)
        {
                gAddColumn(name);
        }

signals:
        void currentChanged();
        void selectionChanged();

private:
        GListViewThing *thing();
        
        virtual void gCurrentChanged()
        {
                emit currentChanged();
        }
        
        virtual void gSelectionChanged()
        {
                emit selectionChanged();
        }
        
};


template<class Item=ListItem>
class FAITH_UI_EXPORT ListViewThing : public GListViewThing
{
public:
        ListViewThing()
        {
        }
        
        virtual ~ListViewThing() { }
        
        ListView<Item> *list() { return static_cast<ListView<Item>*>(gList()); }
        const ListView<Item> *list() const
                { return const_cast<ListViewThing*>(this)->list(); }
        
        virtual void paint(Item *item, Faith::Painter *p, unsigned int column)=0;
        virtual int height(Item *item) const=0;
        virtual int width(Item *item, unsigned int column) const=0;

private:
        virtual void gPaint(void *item, Faith::Painter *p, unsigned int column)
        {
                return paint(static_cast<Item*>(item), p, column);
        }
        virtual int gHeight(void *item) const
        {
                return height(static_cast<Item*>(item));
        }
        virtual int gWidth(void *item, unsigned int column) const
        {
                return width(static_cast<Item*>(item), column);
        }

};


class FAITH_UI_EXPORT ListItem
{
        std::vector<Faith::String> mText;
        
public:
        ListItem(const Faith::String &text);
        ListItem(const std::vector<Faith::String> &text);
        virtual ~ListItem() { }
        
        Faith::String text(unsigned int c) const;
        void setText(unsigned int c, const Faith::String &);
        void setText(const std::vector<Faith::String> &text);

        class ListViewThing : public Faith::ListViewThing<ListItem>
        {
        public:
                ListViewThing();
                virtual void paint(ListItem *item, Faith::Painter *p, unsigned int column);
                virtual int height(ListItem *item) const;
                virtual int width(ListItem *item, unsigned int column) const;
        };
};

template<class Item>
inline GListViewThing* ListView<Item>::thing()
{
        GListViewThing *th = new typename ListItem::ListViewThing(); 
        th->gSetList(this);
        return th;
}

}

#include <faith/listview.magna.tcc>



#endif

---