|| || || || || || || ||

---

TableDataView.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
#ifndef MediaTable_TableDataView_h
#define MediaTable_TableDataView_h

#include "TableColumn.h"
#include "TableDataSourceListener.h"
#include "TableDataViewListener.h"
#include "Core/Array/Arrays.h"
#include "TableFilter.h"

#include "TableDataSource.h"

namespace Impala {
namespace Application {
namespace MediaTable {

// comparison, not case sensitive.
bool compare_string_nocase (std::pair<String, int> a, std::pair<String, int> b)
{
    unsigned int i=0;
    String first = a.first;
    String second = b.first;
    while ( (i < first.length()) && (i < second.length()) )
    {
        if (tolower(first[i])<tolower(second[i]))
            return true;
        else if (tolower(first[i])>tolower(second[i]))
            return false;
        ++i;
    }
    return first.length() < second.length();
};

// comparison, double.
bool compare_double (std::pair<double, int> a, std::pair<double, int> b)
{
    return a.first < b.first;
};

// comparison, int.
bool compare_int (std::pair<int, int> a, std::pair<int, int> b)
{
    return a.first < b.first;
};

class TableDataView :   public TableFilterUpdateListener,
                        public TableDataSourceListener
{
    typedef Impala::Core::Array::Array2dVec3UInt8       Array2dVec3UInt8;
    typedef std::vector<TableColumn*>                   TableColumnVector;

public:
    TableDataView()
    {
        TableDataView(0);
    }

    TableDataView(TableDataSource* table)
    {
        mTableDataSource                = table;
        // TODO: Cleanup unused variables
        mDisplayRows            = 50;
        mFilteredRows           = 1000;
        mStartRow               = 0;
        mSortType               = 1;
        mSortColumn             = "";
        mSortAscending          = true;
        mFiltersWorking         = false;
        mFiltersActive          = false;
        mFilterByMark                   = -1;

        // Set default sorting
        TableColumnVector::iterator it;

        if(mTableDataSource)
        {
                mTableDataSource->AddTableDataSourceListener(this);
                TableColumnVector columns =
                mTableDataSource->GetColumns(true, false);
                for ( it = columns.begin() ; it < columns.end(); it++ )
            {
                                if((*it)->GetType() != TableDataSource::TYPE_FLAG_IMAGE)
                {
                                        SetSortColumn((*it)->GetName());
                                        break;
                                }
                }
        }
    }

    virtual void UpdateRowsEvent()
    {
        ILOG_DEBUG("TableDataView: UpdateRowsEvent");
        if (GetListenTableUpdates())
                DoUpdateRowsEvent();
    }

    virtual void UpdateNumberOfRowsEvent()
    {
        DoUpdateNumberOfRowsEvent();
    }

    int GetTotalRows()
    {
        return mTableDataSource->GetTotalRows();
    }

    int GetFilteredRows()
    {
        // TODO: Implement?
        return mFilteredRows;
    }

    /* return row indices of currently displayed data window ****/
    int GetStartRow()
    {
        return mStartRow;
    }

    int GetEndRow()
    {
        return GetStartRow() + GetNumberOfRows();
    }

    int GetNumberOfRows()
    {
        if (mDisplayRows > mFilteredRows - GetStartRow())
            return mFilteredRows - GetStartRow();
        return mDisplayRows;
    }

    /* mark/unmark support **************************************/

    inline int GetMark(int sortedrow)
    {
        int row = mSortSequence[sortedrow];
        if(mMarkedRows.find(row) != mMarkedRows.end())
            return mMarkedRows[row];
        return 0;
    }
        
        inline int GetMarkById(int id)
        {
        if(mMarkedRows.find(id) != mMarkedRows.end())
            return mMarkedRows[id];
        return 0;
        }

    inline void SetMark(int sortedrow, int mark)
    {
        mMarkedRows[mSortSequence[sortedrow]] = mark;
    }

        inline void SetMarkById(int id, int mark)
        {
                mMarkedRows[id] = mark;
        }
        
    inline void MarkAllRows(int mask, bool mark=true)
    {
                for(int id=0; id < GetTotalRows(); id++)
                {
                        if (mark)
                                SetMarkById(id, GetMarkById(id) | mask);
                        else
                                SetMarkById(id, GetMarkById(id) & ~mask);
                }
    }   

    /* returns a <ID, mark> map for all rows in the database */
    inline std::map<int, int>
    GetMarkedRowsMap()
    {
        return mMarkedRows;
    }

    void
    MarkRow(int sortedrow, int markstate, bool mark=true, bool toggle=false)
    {
                if(sortedrow >= mSortSequence.size())
                        return;
        int row = mSortSequence[sortedrow];
        if (row < 0 || row > GetTotalRows())
            return;
        if (mark)
        {
            if(mMarkedRows.find(row) == mMarkedRows.end())
                mMarkedRows[row] = markstate;
            else if (toggle)
                mMarkedRows[row] = mMarkedRows[row] ^ markstate;
            else
                mMarkedRows[row] = mMarkedRows[row] | markstate;
        }
        else if(mMarkedRows.find(row) != mMarkedRows.end())
            mMarkedRows[row] = mMarkedRows[row] & ~markstate;

        //ILOG_SYSTEM("Markrow: " << row << " state=" << markstate << " mark=" <<
        //           mark<<" toggle=" << toggle << " RES=" << mMarkedRows[row]);
    }

    inline void MarkAllFilteredRows(int markstate, bool mark=true)
    {
        MarkRange(0, GetFilteredRows()-1, markstate, mark);
    }

    void MarkRange(int start, int stop, int markstate, bool mark=true)
    {
        if (stop <= start)
        {
            int t = stop;
            stop  = start;
            start = t;
        }
        if (start < 0)
            start = 0;

        if (stop >= GetFilteredRows())
            stop = GetFilteredRows()-1;

        for (int i=start; i<=stop; i++)
            MarkRow(i, markstate, mark);
    }

    void TransformMarkedTo(int sourcemask, int targetmask)
    {
        for (int i=0; i<GetTotalRows(); i++)
        {
            if(mMarkedRows.find(i) != mMarkedRows.end())
            {
                if (mMarkedRows[i] & sourcemask)
                {
                    mMarkedRows[i] = mMarkedRows[i] & ~sourcemask;
                    mMarkedRows[i] = mMarkedRows[i] | targetmask;
                }
            }
        }
    }
        
        void SetStartRowToFirstMarked(int mark)
        {
                for(int row=0; row < GetFilteredRows(); row++)
                {
                        if(GetMark(row) & mark)
                        {
                                SetStartRow(row);
                                return;
                        }
                }
        }       

    /* range selecting *********************************/

    void SetStartRow(int startrow)
    {
        if (startrow >= 0 && startrow < GetTotalRows() && startrow != mStartRow)
        {
            ILOG_DEBUG("SetStartRow( " << startrow << ")");
            mStartRow = startrow;
                        DoUpdateScrollFromSourceEvent();
            DoUpdateRowsEvent();
        }
    }
        
    void SetNumberOfRows(int number)
    {
        if (number > 0 && number != mDisplayRows)
        {
            ILOG_DEBUG("SetNumberOfRows(" << number << ")");
            mDisplayRows = number;
            DoUpdateRowsEvent();
        }
    }

    bool OutOfBounds(int row)
    {
        if (row < GetStartRow() || row >= GetStartRow() + GetNumberOfRows())
            return true;
        return false;
    }

    bool OutOfBoundsByID(int id)
    {
        return OutOfBounds(GetRowForID(id));
    }

        bool OutOfBoundsByQuid(unsigned long long quid)
        {
                return OutOfBoundsByID(mTableDataSource->GetIDForQuid(quid));
        }

    /* column sorting ********************************************/

    String GetSortColumn()
    {
        return mSortColumn;
    }

    bool GetSortAscending()
    {
        return mSortAscending;
    }

    /* returns a <ID, bool isvisible> map for all rows in the database
    */
    std::map<int, bool>
    GetUnfilteredRowsMap()
    {
        return mVisibleRows;
    }

        virtual void ApplyFilters()
        {
                SortAndFilter();
        }
        
    virtual void SortAndFilter()
    {
        ILOG_DEBUG("re-sorting to " << mSortColumn << "/" << mSortAscending);
        mVisibleRows.clear();
                mSortType = GetColumn(mSortColumn)->GetType();
                if (mSortType == TableDataSource::TYPE_TEXT)
            SortAndFilterText();
        if (mSortType & TableDataSource::TYPE_FLAG_FLOAT)
            SortAndFilterFloat();
        if (mSortType == TableDataSource::TYPE_INT)
            SortAndFilterInt();
        ILOG_DEBUG("sorting completed.");
        DoUpdateSortEvent();
        DoUpdateSelectionEvent();
        DoUpdateRowsEvent();
    }

/* RvB: OLD
    virtual void SortAndFilter()
    {
        ILOG_DEBUG("re-sorting to " << mSortColumn << "/" << mSortAscending);
        mVisibleRows.clear();
                mSortType = GetColumn(mSortColumn)->GetType();
                if (mSortType == TableDataSource::TYPE_TEXT)
        {
            std::list < std::pair <String, int> > sortthis;
            for (int i=0; i<mTableDataSource->GetTotalRows(); i++)
            {
                if (!IsFiltered(i))
                {
                    String txt =
                        mTableDataSource->GetTextDataByID(mSortColumn, i);
                    sortthis.push_back( std::make_pair(txt, i) );
                    mVisibleRows[i] = true;
                }
                else
                    mVisibleRows[i] = false;
            }
            mFilteredRows = sortthis.size();
            sortthis.sort(compare_string_nocase);
            ILOG_DEBUG("filtered # of rows: " << mFilteredRows);

            if (!mSortAscending)
                sortthis.reverse();
            mSortSequence.clear();

            std::list<std::pair <String, int> >::iterator it;
            for (it=sortthis.begin(); it!=sortthis.end(); ++it)
                mSortSequence.push_back(it->second);
        }
        if (mSortType & TableDataSource::TYPE_FLAG_FLOAT)
        {
            std::list < std::pair <double, int> > sortthis;
            for (int i=0; i<mTableDataSource->GetTotalRows(); i++)
            {
                if (!IsFiltered(i))
                {
                        double dVal;
                    if (mSortType == TableDataSource::TYPE_NORMALIZEDVALUE)
                        dVal = mTableDataSource->GetNormalizedDataByID(mSortColumn, i);
                    else
                        dVal = mTableDataSource->GetDoubleDataByID(mSortColumn, i);
                    sortthis.push_back( std::make_pair(dVal, i) );
                    mVisibleRows[i] = true;
                }
                else
                    mVisibleRows[i] = false;
            }
            mFilteredRows = sortthis.size();
            sortthis.sort(compare_double);
            ILOG_DEBUG("filtered # of rows: " << mFilteredRows);

            if (mSortType == TableDataSource::TYPE_NORMALIZEDVALUE && mSortAscending ||
                mSortType == TableDataSource::TYPE_DOUBLE                 && !mSortAscending)
                sortthis.reverse();
            mSortSequence.clear();

            std::list<std::pair <double, int> >::iterator it;
            for (it=sortthis.begin(); it!=sortthis.end(); ++it)
                mSortSequence.push_back(it->second);
        }
        if (mSortType == TableDataSource::TYPE_INT)
        {
            std::list < std::pair <int, int> > sortthis;
            for (int i=0; i<mTableDataSource->GetTotalRows();i++)
            {
                if (!IsFiltered(i))
                {
                    int iVal = mTableDataSource->GetIntDataByID(mSortColumn, i);
                    sortthis.push_back( std::make_pair(iVal, i) );
                    mVisibleRows[i] = true;
                }
                else
                    mVisibleRows[i] = false;
            }
            mFilteredRows = sortthis.size();
            sortthis.sort(compare_int);
            ILOG_DEBUG("filtered # of rows: " << mFilteredRows);

            if (!mSortAscending)
                sortthis.reverse();
            mSortSequence.clear();

            std::list<std::pair <int, int> >::iterator it;
            for (it=sortthis.begin(); it!=sortthis.end(); ++it)
                mSortSequence.push_back(it->second);
        }
        ILOG_DEBUG("sorting completed.");
        DoUpdateSortEvent();
        DoUpdateSelectionEvent();
        DoUpdateRowsEvent();
    }
*/

    void SetSortColumn(String column, bool ascending=true)
    {
        if (mSortColumn != column || mSortAscending != ascending)
        {
            mSortColumn = column;
            mSortAscending = ascending;
            SortAndFilter();
        }
    }

    /* table listeners ******************************/
    void AddTableDataViewListener(TableDataViewListener* l)
    {
        mTableListeners.push_back(l);
    }

    // TODO: Name might not be correct.
    // Fired when startrow and endrow are updated
    void DoUpdateRowsEvent()
    {
        for (int i=0; i< mTableListeners.size(); i++)
            if (mTableListeners[i]->GetListenTableUpdates())
                mTableListeners[i]->UpdateRowsEvent();
    }

    void DoUpdateNumberOfRowsEvent()
    {
        for (int i=0; i< mTableListeners.size(); i++)
            if (mTableListeners[i]->GetListenTableUpdates())
                mTableListeners[i]->UpdateNumberOfRowsEvent();
    }

    void DoUpdateSelectionEvent()
    {
        for (int i=0; i< mTableListeners.size(); i++)
            if (mTableListeners[i]->GetListenTableUpdates())
                mTableListeners[i]->UpdateSelectionEvent();
    }


    void DoUpdateSortEvent()
    {
        for (int i=0; i< mTableListeners.size(); i++)
            if (mTableListeners[i]->GetListenTableUpdates())
                mTableListeners[i]->UpdateSortEvent(mSortColumn,mSortAscending);
    }

    void DoUpdateScrollFromSourceEvent()
    {
        ILOG_DEBUG("DoUpdateScrollFromSourceEvent");
        for (int i=0; i< mTableListeners.size(); i++)
            if (mTableListeners[i]->GetListenTableUpdates())
                mTableListeners[i]->UpdateScrollFromSourceEvent();
    }

    /* get individual row characteristics ************************/

    inline double
    GetNormalizedDataByID(String column, int id)
    {
        return mTableDataSource->GetNormalizedDataByID(column, id);
    }

    inline int
    GetIntDataByID(String column, int id)
    {
        return mTableDataSource->GetIntDataByID(column, id);
    }

    inline String
    GetTextDataByID(String column, int id)
    {
        return mTableDataSource->GetTextDataByID(column, id);
    }

    inline double
    GetDoubleDataByID(String column, int id)
    {
        return mTableDataSource->GetDoubleDataByID(column, id);
    }

    inline String
    GetSortedTextData(String column, int row)
    {
        return mTableDataSource->GetTextDataByID(column, mSortSequence[row]);
    }

    inline double
    GetSortedNormalizedData(String column, int row)
    {
        return mTableDataSource->
            GetNormalizedDataByID(column, mSortSequence[row]);
    }

    inline Array2dVec3UInt8*
    GetSortedImageData(String column, int row)
    {
        return mTableDataSource->GetImageDataByID(column, mSortSequence[row]);
    }

    inline Array2dVec3UInt8*
    GetSortedVideoData(String column, int row)
    {
        return mTableDataSource->GetVideoDataByID(column, mSortSequence[row]);
    }

    inline int
    GetSortedIntData(String column, int row)
    {
        return mTableDataSource->GetIntDataByID(column, mSortSequence[row]);
    }

    inline double
    GetSortedDoubleData(String column, int row)
    {
        return mTableDataSource->GetDoubleDataByID(column, mSortSequence[row]);
    }

    inline unsigned long long
    GetSortedQuid(String column, int row) {
        return mTableDataSource->GetQuid(column, mSortSequence[row]);
    }

    int GetID(int row)
    {
        if (row >= 0 && row < GetTotalRows() && row < mSortSequence.size())
            return mSortSequence[row];
        else
            return -1;
    }

    int GetRowForID(int id)
    {
        int size = mSortSequence.size();
        for (int i=0; i<GetTotalRows() && i<size; i++)
            if (mSortSequence[i] == id)
                return i;
        return -1;
    }

    // RvB: Not used yet, but contains a BUG
    void RemoveFilter(String column)
    {
        std::list<TableFilter*>::iterator it;
        for (it=mFilters.begin(); it!=mFilters.end(); it++)
        {
            if ((*it)->GetColumn() == column)
                mFilters.erase(it); //delete *it;

            if (mFilters.size() == 0)
                mFiltersActive = false;

            // RvB: Below is a BUG!!! Not used yet but needs to be solved
            if (!mFiltersWorking)
                ApplyFilters();
                break;
        }
    }

    void RegisterFilter(TableFilter *t)
    {
        mFiltersWorking = true;
        RemoveFilter(t->GetColumn());
        mFiltersWorking = false;
        mFilters.push_back(t);
        mFiltersActive = true;
        //ApplyFilters();
    }

    void EnableFilterByMark(int mark)
    {
        ILOG_DEBUG("Enable filter by mark for mark=" << mark);
        mFilterByMark = mark;
        ApplyFilters();
    }

    int GetMarkFilter()
    {
        return mFilterByMark;
    }

    int GetMarkFilterForEverything()
    {
        return 4|8|16|32|64|128;
    }

    void DisableFilterByMark()
    {
        ILOG_DEBUG("Filter by mark disabled");
        mFilterByMark = -1;
        ApplyFilters();
    }

    TableColumnVector
    GetColumns(bool StaticColumns=true, bool ExtraColumns=false)
    {
        return mTableDataSource->GetColumns(StaticColumns, ExtraColumns);
    }

    TableColumn* GetColumn(std::string column)
    {
        return mTableDataSource->GetColumn(column);
    }

private:

    bool IsFiltered(int id)
    {
        // filter by marked state:
        if (mFilterByMark > -1)
        {
            if (mMarkedRows.find(id) != mMarkedRows.end())
            {
                if (!(mMarkedRows[id] & mFilterByMark))
                    return true;
            }
            else if (mFilterByMark != 0)
                return true;
        }

        // filter by columns:
        if (!mFiltersActive)
            return false;

        std::list<TableFilter*>::iterator it;
        for (it=mFilters.begin(); it!=mFilters.end(); it++)
        {
                
                        /* BUG: the types below DO NOT CORRESPOND with TableDataSource types
                                this needs to be verified and fixed. -Ork
                        */
                        
            if ((*it)->GetType() == 1)
            {
                String txt = GetTextDataByID((*it)->GetColumn(), id);
                if ((*it)->IsFilteredByText(txt))
                    return true;
            }
                        else if ((*it)->GetType() == 2)
                        {
                                switch(GetColumn((*it)->GetColumn())->GetType())
                                {
                                        double dVal;
                                        case TableDataSource::TYPE_NORMALIZEDVALUE:
                                                dVal = GetNormalizedDataByID((*it)->GetColumn(),id);
                                                if ((*it)->IsFilteredByValue(dVal))
                                                        return true;
                                                break;
                                        case TableDataSource::TYPE_DOUBLE:
                                                dVal = GetDoubleDataByID((*it)->GetColumn(),id);
                                                if ((*it)->IsFilteredByValue(dVal))
                                                        return true;
                                                break;
                                        case TableDataSource::TYPE_INT:
                                                int iVal = GetIntDataByID((*it)->GetColumn(),id);
                                                // DO: Converts to double automatically? Is this right?
                                                if ((*it)->IsFilteredByValue(iVal))
                                                        return true;
                                                break;
                                }
                        }
        }
        return false;
    }

protected:
    void SortAndFilterText()
    {
        std::list < std::pair <String, int> > sortthis;
        for (int i=0; i<mTableDataSource->GetTotalRows(); i++)
        {
            if (!IsFiltered(i))
            {
                String txt = GetTextDataByID(mSortColumn, i);
                sortthis.push_back( std::make_pair(txt, i) );
                mVisibleRows[i] = true;
            }
            else
                mVisibleRows[i] = false;
        }
        mFilteredRows = sortthis.size();
        sortthis.sort(compare_string_nocase);
        ILOG_DEBUG("filtered # of rows: " << mFilteredRows);

        if (!mSortAscending)
            sortthis.reverse();
        mSortSequence.clear();

        std::list<std::pair <String, int> >::iterator it;
        for (it=sortthis.begin(); it!=sortthis.end(); ++it)
            mSortSequence.push_back(it->second);
    }

    void SortAndFilterFloat()
    {
        std::list < std::pair <double, int> > sortthis;
        for (int i=0; i<mTableDataSource->GetTotalRows(); i++)
        {
            if (!IsFiltered(i))
            {
                    double dVal;
                if (mSortType == TableDataSource::TYPE_NORMALIZEDVALUE)
                    dVal = GetNormalizedDataByID(mSortColumn,i);
                else
                    dVal = GetDoubleDataByID(mSortColumn, i);
                sortthis.push_back( std::make_pair(dVal, i) );
                mVisibleRows[i] = true;
            }
            else
                mVisibleRows[i] = false;
        }
        mFilteredRows = sortthis.size();
        sortthis.sort(compare_double);
        ILOG_DEBUG("filtered # of rows: " << mFilteredRows);

        bool normType = (mSortType == TableDataSource::TYPE_NORMALIZEDVALUE);
        bool dblType  = (mSortType == TableDataSource::TYPE_DOUBLE);
        if ((normType && mSortAscending) || (dblType && !mSortAscending))
            sortthis.reverse();
        mSortSequence.clear();

        std::list<std::pair <double, int> >::iterator it;
        for (it=sortthis.begin(); it!=sortthis.end(); ++it)
            mSortSequence.push_back(it->second);
    }

    void SortAndFilterInt()
    {
        std::list < std::pair <int, int> > sortthis;
        for (int i=0; i<mTableDataSource->GetTotalRows();i++)
        {
            if (!IsFiltered(i))
            {
                int iVal = GetIntDataByID(mSortColumn, i);
                sortthis.push_back( std::make_pair(iVal, i) );
                mVisibleRows[i] = true;
            }
            else
                mVisibleRows[i] = false;
        }
        mFilteredRows = sortthis.size();
        sortthis.sort(compare_int);
        ILOG_DEBUG("filtered # of rows: " << mFilteredRows);

        if (!mSortAscending)
            sortthis.reverse();
        mSortSequence.clear();

        std::list<std::pair <int, int> >::iterator it;
        for (it=sortthis.begin(); it!=sortthis.end(); ++it)
            mSortSequence.push_back(it->second);
    }

    int             mFilteredRows;

private:
    bool            mFiltersActive;
    bool            mFiltersWorking;
    bool            mSortAscending;

    int             mStartRow;
    int             mDisplayRows;
    int             mSortType; // Needs to be removed and nicified
    int             mFilterByMark;

    String          mSortColumn;

        TableDataSource*                                                        mTableDataSource;
    std::vector<TableDataViewListener*>         mTableListeners;
    std::list<TableFilter*>                     mFilters;
    std::vector<int>                            mSortSequence;

     // TODO: Move to TableDataSource?
    std::map<int, int>                          mMarkedRows;
    std::map<int, bool>                         mVisibleRows;

    ILOG_VAR_DEC;
};

/*class TableDataViewIter {
    const TableDataView &view;
    int index;
  public:
    TableDataViewIter(const TableDataView &v): view(v)
    {
        index = 0;
    }
    void operator++()
    {
        index++;
    }
    bool operator()()
    {
        return index != view.GetTotalRowCount() + 1;
    }
    int operator *()
    {
        return view[index];
    }
};*/


ILOG_VAR_INIT(TableDataView, Application.MediaTable);

} // namespace MediaTable
} // namespace Application
} // namespace Impala

#endif // TableDataView_h

---