/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2012-2013, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */
#ifndef TREE_TABLE_H
#define TREE_TABLE_H

#include <vector>

#include <ColumnTypes.h>
#include <Variant.h>

#include "table/AbstractTable.h"
#include "table/TableColumn.h"


class TreeTable;
class TreeTableModel;
class TreeTableNode;
class TreeTableRow;


class TreeTablePath {
public:
                                                                TreeTablePath();
                                                                TreeTablePath(const TreeTablePath& other);
                                                                TreeTablePath(const TreeTablePath& other,
                                                                        int32 childIndex);
                                                                ~TreeTablePath();

                bool                                    AddComponent(int32 childIndex);
                int32                                   RemoveLastComponent();
                void                                    Clear();

                int32                                   CountComponents() const;
                int32                                   ComponentAt(int32 index) const;

                TreeTablePath&                  operator=(const TreeTablePath& other);
                bool                                    operator==(const TreeTablePath& other) const;
                bool                                    operator!=(const TreeTablePath& other) const;

private:
                typedef std::vector<int32> ComponentVector;

private:
                ComponentVector                 fComponents;
};


class TreeTableModelListener {
public:
        virtual                                         ~TreeTableModelListener();

        virtual void                            TableNodesAdded(TreeTableModel* model,
                                                                        const TreeTablePath& path, int32 childIndex,
                                                                        int32 count);
        virtual void                            TableNodesRemoved(TreeTableModel* model,
                                                                        const TreeTablePath& path, int32 childIndex,
                                                                        int32 count);
        virtual void                            TableNodesChanged(TreeTableModel* model,
                                                                        const TreeTablePath& path, int32 childIndex,
                                                                        int32 count);
        virtual void                            TableModelReset(TreeTableModel* model);
};


class TreeTableModel : public AbstractTableModelBase {
public:
        virtual                                         ~TreeTableModel();

        virtual void*                           Root() const = 0;
                                                                        // the root itself isn't shown

        virtual int32                           CountChildren(void* parent) const = 0;
        virtual void*                           ChildAt(void* parent, int32 index) const = 0;

        virtual bool                            GetValueAt(void* object, int32 columnIndex,
                                                                        BVariant& value) = 0;

        virtual void*                           NodeForPath(const TreeTablePath& path) const;

        virtual bool                            AddListener(TreeTableModelListener* listener);
        virtual void                            RemoveListener(
                                                                        TreeTableModelListener* listener);

protected:
                        typedef BObjectList<TreeTableModelListener> ListenerList;

protected:
                        void                            NotifyNodesAdded(const TreeTablePath& path,
                                                                        int32 childIndex, int32 count);
                        void                            NotifyNodesRemoved(const TreeTablePath& path,
                                                                        int32 childIndex, int32 count);
                        void                            NotifyNodesChanged(const TreeTablePath& path,
                                                                        int32 childIndex, int32 count);
                        void                            NotifyTableModelReset();

protected:
                        ListenerList            fListeners;
};


class TreeTableSelectionModel {
public:
                                                                TreeTableSelectionModel(TreeTable* table);
                                                                ~TreeTableSelectionModel();

                        int32                           CountNodes();
                        void*                           NodeAt(int32 index);
                        bool                            GetPathAt(int32 index, TreeTablePath& _path);

private:
                        friend class TreeTable;

private:
                        void                            _SelectionChanged();
                        void                            _Update();
                        TreeTableNode*          _NodeAt(int32 index);

private:
                        TreeTable*                      fTreeTable;
                        TreeTableNode**         fNodes;
                        int32                           fNodeCount;
};


class TreeTableToolTipProvider {
public:
        virtual                                         ~TreeTableToolTipProvider();

        virtual bool                            GetToolTipForTablePath(
                                                                        const TreeTablePath& path,
                                                                        int32 columnIndex, BToolTip** _tip) = 0;
                                                                        // columnIndex can be -1, if not in a column
};


class TreeTableListener {
public:
        virtual                                         ~TreeTableListener();

        virtual void                            TreeTableSelectionChanged(TreeTable* table);
        virtual void                            TreeTableNodeInvoked(TreeTable* table,
                                                                        const TreeTablePath& path);
        virtual void                            TreeTableNodeExpandedChanged(TreeTable* table,
                                                                        const TreeTablePath& path, bool expanded);

        virtual void                            TreeTableCellMouseDown(TreeTable* table,
                                                                        const TreeTablePath& path,
                                                                        int32 columnIndex, BPoint screenWhere,
                                                                        uint32 buttons);
        virtual void                            TreeTableCellMouseUp(TreeTable* table,
                                                                        const TreeTablePath& path,
                                                                        int32 columnIndex, BPoint screenWhere,
                                                                        uint32 buttons);
};


class TreeTable : public AbstractTable, private TreeTableModelListener {
public:
                                                                TreeTable(const char* name, uint32 flags,
                                                                        border_style borderStyle = B_NO_BORDER,
                                                                        bool showHorizontalScrollbar = true);
                                                                TreeTable(TreeTableModel* model,
                                                                        const char* name, uint32 flags,
                                                                        border_style borderStyle = B_NO_BORDER,
                                                                        bool showHorizontalScrollbar = true);
        virtual                                         ~TreeTable();

                        bool                            SetTreeTableModel(TreeTableModel* model);
                        TreeTableModel*         GetTreeTableModel() const       { return fModel; }

                        void                            SetToolTipProvider(
                                                                        TreeTableToolTipProvider* toolTipProvider);
                        TreeTableToolTipProvider* ToolTipProvider() const
                                                                        { return fToolTipProvider; }

                        TreeTableSelectionModel* SelectionModel();

                        void                            SelectNode(const TreeTablePath& path,
                                                                        bool extendSelection);
                        void                            DeselectNode(const TreeTablePath& path);
                        void                            DeselectAllNodes();

                        bool                            IsNodeExpanded(const TreeTablePath& path) const;
                        void                            SetNodeExpanded(const TreeTablePath& path,
                                                                        bool expanded,
                                                                        bool expandAncestors = false);

                        void                            ScrollToNode(const TreeTablePath& path);

                        bool                            AddTreeTableListener(
                                                                        TreeTableListener* listener);
                        void                            RemoveTreeTableListener(
                                                                        TreeTableListener* listener);

        virtual status_t                        GetCellRectAt(const TreeTablePath& path,
                                                                        int32 colIndex, BRect& _output) const;

protected:
        virtual bool                            GetToolTipAt(BPoint point, BToolTip** _tip);

        virtual void                            SelectionChanged();

        virtual AbstractColumn*         CreateColumn(TableColumn* column);

        virtual void                            ColumnMouseDown(AbstractColumn* column,
                                                                        BRow* row, BField* field,
                                                                        BPoint screenWhere, uint32 buttons);
        virtual void                            ColumnMouseUp(AbstractColumn* column,
                                                                        BRow* row, BField* field,
                                                                        BPoint screenWhere, uint32 buttons);

private:
        virtual void                            TableNodesAdded(TreeTableModel* model,
                                                                        const TreeTablePath& path, int32 childIndex,
                                                                        int32 count);
        virtual void                            TableNodesRemoved(TreeTableModel* model,
                                                                        const TreeTablePath& path, int32 childIndex,
                                                                        int32 count);
        virtual void                            TableNodesChanged(TreeTableModel* model,
                                                                        const TreeTablePath& path, int32 childIndex,
                                                                        int32 count);
        virtual void                            TableModelReset(TreeTableModel* model);

private:
                        class Column;

                        friend class TreeTableSelectionModel;

                        typedef BObjectList<TreeTableListener>  ListenerList;

private:
        virtual void                            ExpandOrCollapse(BRow* row, bool expand);
        virtual void                            ItemInvoked();

                        bool                            _AddChildRows(TreeTableNode* parentNode,
                                                                        int32 childIndex, int32 count,
                                                                        int32 columnCount);
                        void                            _RemoveChildRows(TreeTableNode* parentNode,
                                                                        int32 childIndex, int32 count);

                        void                            _SetNodeExpanded(TreeTableNode* node,
                                                                        bool expanded,
                                                                        bool expandAncestors = false);

                        TreeTableNode*          _NodeForPath(const TreeTablePath& path) const;
                        void                            _GetPathForNode(TreeTableNode* node,
                                                                        TreeTablePath& _path) const;

private:
                        TreeTableModel*         fModel;
                        TreeTableToolTipProvider* fToolTipProvider;
                        TreeTableNode*          fRootNode;
                        TreeTableSelectionModel fSelectionModel;
                        ListenerList            fListeners;
                        int32                           fIgnoreSelectionChange;
};


#endif  // TREE_TABLE_H