/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef TABLE_H
#define TABLE_H

#include <ColumnTypes.h>

#include <ObjectList.h>
#include <util/DoublyLinkedList.h>
#include <Variant.h>

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


class Table;
class TableModel;


class TableModelListener {
public:
        virtual                                         ~TableModelListener();

        virtual void                            TableRowsAdded(TableModel* model,
                                                                        int32 rowIndex, int32 count);
        virtual void                            TableRowsRemoved(TableModel* model,
                                                                        int32 rowIndex, int32 count);
        virtual void                            TableRowsChanged(TableModel* model,
                                                                        int32 rowIndex, int32 count);
        virtual void                            TableModelReset(TableModel* model);
};


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

        virtual int32                           CountRows() const = 0;

        virtual bool                            GetValueAt(int32 rowIndex, int32 columnIndex,
                                                                        BVariant& value) = 0;

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

protected:
                        typedef BObjectList<TableModelListener> ListenerList;

protected:
                        void                            NotifyRowsAdded(int32 rowIndex, int32 count);
                        void                            NotifyRowsRemoved(int32 rowIndex, int32 count);
                        void                            NotifyRowsChanged(int32 rowIndex, int32 count);
                        void                            NotifyTableModelReset();

protected:
                        ListenerList            fListeners;
};


class TableSelectionModel {
public:
                                                                TableSelectionModel(Table* table);
                                                                ~TableSelectionModel();

                        int32                           CountRows();
                        int32                           RowAt(int32 index);

private:
                        friend class Table;

private:
                        void                            _SelectionChanged();
                        void                            _Update();

private:
                        Table*                          fTable;
                        int32*                          fRows;
                        int32                           fRowCount;
};


class TableToolTipProvider {
public:
        virtual                                         ~TableToolTipProvider();

        virtual bool                            GetToolTipForTableCell(int32 rowIndex,
                                                                        int32 columnIndex, BToolTip** _tip) = 0;
                                                                        // columnIndex can be -1, if not in a column
};


class TableListener {
public:
        virtual                                         ~TableListener();

        virtual void                            TableSelectionChanged(Table* table);
        virtual void                            TableRowInvoked(Table* table, int32 rowIndex);

        virtual void                            TableCellMouseDown(Table* table, int32 rowIndex,
                                                                        int32 columnIndex, BPoint screenWhere,
                                                                        uint32 buttons);
        virtual void                            TableCellMouseUp(Table* table, int32 rowIndex,
                                                                        int32 columnIndex, BPoint screenWhere,
                                                                        uint32 buttons);
};


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

                        void                            SetTableModel(TableModel* model);
                        TableModel*                     GetTableModel() const   { return fModel; }

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

                        TableSelectionModel* SelectionModel();

                        void                            SelectRow(int32 rowIndex, bool extendSelection);
                        void                            DeselectRow(int32 rowIndex);
                        void                            DeselectAllRows();

                        bool                            AddTableListener(TableListener* listener);
                        void                            RemoveTableListener(TableListener* listener);

        virtual status_t                        GetCellRectAt(int32 rowIndex, 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                            TableRowsAdded(TableModel* model,
                                                                        int32 rowIndex, int32 count);
        virtual void                            TableRowsRemoved(TableModel* model,
                                                                        int32 rowIndex, int32 count);
        virtual void                            TableRowsChanged(TableModel* model,
                                                                        int32 rowIndex, int32 count);
        virtual void                            TableModelReset(TableModel* model);

private:
                        class Column;

                        friend class TableSelectionModel;

                        typedef BObjectList<TableListener>      ListenerList;
                        typedef BObjectList<BRow> RowList;

private:
        virtual void                            ItemInvoked();

                        void                            _UpdateRowIndices(int32 fromIndex);
                        int32                           _ModelIndexOfRow(BRow* row);

private:
                        TableModel*                     fModel;
                        TableToolTipProvider* fToolTipProvider;
                        RowList                         fRows;
                        TableSelectionModel     fSelectionModel;
                        ListenerList            fListeners;
                        int32                           fIgnoreSelectionChange;
};


#endif  // TABLE_H