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

---

TableDataSource.h

Go to the documentation of this file.

#ifndef VideoExcel_TableDataSource_h
#define VideoExcel_TableDataSource_h

#include "TableUpdateListener.h"
#include "Core/Array/Arrays.h"
#include "TableFilter.h"
#include "TableSourceColumnDescription.h"

namespace Impala {
namespace Application {
namespace VideoExcel {


// 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;
    }
    if (first.length()<second.length()) return true;
    else return false;
};

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

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

class TableDataSource : public TableFilterUpdateListener
{
public:
    typedef Impala::Core::Array::Array2dVec3UInt8 Array2dVec3UInt8;

    static const int TYPE_TEXT            = 1;
    static const int TYPE_NORMALIZEDVALUE = 2;
    static const int TYPE_IMAGE           = 3;
    static const int TYPE_INT             = 4;
    static const int TYPE_DOUBLE          = 5;

    TableDataSource()
    {
        mDisplayRows            = 50;
        mTotalRows              = 1000;
        mFilteredRows           = 1000;
        mStartRow               = 0;
        mDefaultRowHeight       = 20;
        mDefaultRowZoomHeight   = 80;
        mSortType               = 1;
        mZoomRow                = -1;
        mSortColumn             = "";
        mSortAscending          = true;
        mFiltersWorking         = false;
        mFiltersActive          = false;
    }

    int GetTotalRows()
    {
        return mTotalRows;
    }

    int GetFilteredRows()
    {
        return mFilteredRows;
    }

    void SetStartRow(int startrow)
    {
        if (startrow >= 0 && startrow < GetTotalRows() && startrow!=mStartRow)
        {
            mStartRow = startrow;
            DoUpdateRowsEvent();
        }
    }

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

    void SetNumberOfRowsInPixels(int pixels)
    {
        if (pixels <= 0)
            return;

        int yoff = 0;
        int rows = 0;
        for (int i=GetStartRow(); i<GetTotalRows(); i++)
        {
            if ((yoff += GetRowHeight(i)) > pixels)
                break;
            rows++;
        }
        if (rows != mDisplayRows)
        {
            ILOG_DEBUG("SetNumberOfRowsInPixels: " << pixels << " yields " <<
                       rows << " rows.");
            SetNumberOfRows(rows);
        }
    }

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

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

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

    void
    MarkRow(int sortedrow, int markstate, bool mark=true, bool toggle=false)
    {
        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_DEBUG("Markrow: " << row << " state=" << markstate << " mark=" <<
        //           mark<<" toggle=" << toggle << " RES=" << mMarkedRows[row]);
    }

    void MarkVisibleRows(int markstate, bool mark=true)
    {
        MarkRange(GetStartRow(), GetEndRow(), markstate, mark);
    }

    void MarkAllRows(int markstate, bool mark=true)
    {
        MarkRange(0, GetTotalRows(), 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 >= GetEndRow()) stop = GetEndRow()-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;
                }
            }
        }
    }

    /* individual row zooming support ****/
    void SetZoomRow(int row)
    {
        if (row == mZoomRow)
            return;
        if (OutOfBounds(row))
            return;
        if (mZoomRow == -1)
            DoUpdateNumberOfRowsEvent();
        mZoomRow = row;
        DoUpdateRowsEvent();
    }

    void UnsetZoom()
    {
        if (mZoomRow == -1)
            return;
        mZoomRow = -1;
        DoUpdateNumberOfRowsEvent();
        DoUpdateRowsEvent();
    }

    void SetDefaultRowSizes(int unzoom, int zoom)
    {
        mDefaultRowHeight = unzoom;
        mDefaultRowZoomHeight = zoom;
        DoUpdateNumberOfRowsEvent();
        DoUpdateRowsEvent();
    }

    /* 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;
    }

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

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

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

    String GetSortColumn()
    {
        return mSortColumn;
    }

    bool GetSortAscending()
    {
        return mSortAscending;
    }

    /* returns a <ID, bool isvisible> map for all rows in the database
       todo: name clash: visible here means "not filtered"
    */
    std::map<int, bool>
    GetVisibleRowsMap()
    {
        return mVisibleRows;
    }

    void SortAndFilter()
    {
        ILOG_DEBUG("re-sorting to " << mSortColumn << "/" << mSortAscending);
        mVisibleRows.clear();
        if (mSortType == TYPE_TEXT)
        {
            std::list < std::pair <String, int> > sortthis;
            for (int i=0; i<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);
        }
        if (mSortType == TYPE_NORMALIZEDVALUE || mSortType == TYPE_DOUBLE)
        {
            std::list < std::pair <double, int> > sortthis;
            for (int i=0; i<GetTotalRows();i++)
            {
                if (!IsFiltered(i))
                {
                        double dVal;
                    if (mSortType == 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);

            if (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 == TYPE_INT)
        {
            std::list < std::pair <int, int> > sortthis;
            for (int i=0; i<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);
        }
        ILOG_DEBUG("sorting completed.");
        DoUpdateSortEvent();
        DoUpdateSelectionEvent();
        DoUpdateRowsEvent();
    }

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

    /* table listeners ******************************/
    void AddTableUpdateListener(TableUpdateListener* l)
    {
        mTableListeners.push_back(l);
    }

    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()
    {
        for (int i=0; i< mTableListeners.size(); i++)
            if (mTableListeners[i]->GetListenTableUpdates())
                mTableListeners[i]->UpdateScrollFromSourceEvent();
    }

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

    inline String
    GetSortedTextData(String column, int row)
    {
        if (column=="rank")
        {
            std::ostringstream s;
            s << row;
            return s.str();
        }
        return GetTextDataByID(column, mSortSequence[row]);
    }

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

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

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

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

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


    virtual int GetRowHeight(int row)
    {
        if (mZoomRow > -1)
        {
            int dist = abs((row) - mZoomRow);
            if (dist > 5) return mDefaultRowHeight;
            double div;
            if (dist == 0) div = 1.0;
            if (dist == 1) div = 0.45;
            if (dist == 2) div = 0.25;
            if (dist == 3) div = 0.15;
            if (dist == 4) div = 0.1;
            if (dist == 5) div = 0.05;
            return (int)(mDefaultRowZoomHeight*div+mDefaultRowHeight*(1.0-div));
        }
        return mDefaultRowHeight;
    }

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

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

    virtual String
    GetTextDataByID(String column, int row)
    {
        if (OutOfBounds(row))
            return "";
        std::ostringstream os;
        os << column << ":" << row;
        return os.str();
    }

    virtual Array2dVec3UInt8*
    GetImageDataByID(String column, int row)
    {
        return 0;
    }

    virtual Array2dVec3UInt8*
    GetVideoDataByID(String column, int row)
    {
        return 0;
    }

    virtual double
    GetNormalizedDataByID(String column, int row)
    {
        return row / (double)mTotalRows;
    }

    virtual int
    GetIntDataByID(String column, int row)
    {
        return 0;
    }

    virtual double
    GetDoubleDataByID(String column, int row)
    {
        return 0;
    }

public:
    // 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();
    }

    std::vector<TableSourceColumnDescription>
    GetColumns()
    {
        return mColumnNames;
    }

    std::vector<TableSourceColumnDescription>
    GetExtraColumns()
    {
        return mExtraColumnNames;
    }

    virtual void ApplyFilters()
    {
        SortAndFilter();
    }


protected:

    void AddStaticColumn(String name, int coltype, int width=120, int param=0)
    {
        TableSourceColumnDescription p(name, coltype, width, param);
        mColumnNames.push_back(p);
    }

    void AddColumn(String name, int coltype, int width=120, int param=0)
    {
        TableSourceColumnDescription p(name, coltype, width, param);
        mExtraColumnNames.push_back(p);
    }

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++)
        {
            if ((*it)->GetType() == TYPE_TEXT)
            {
                String txt = GetTextDataByID((*it)->GetColumn(), id);
                if ((*it)->IsFilteredByText(txt))
                    return true;
            }
            if ((*it)->GetType() == TYPE_NORMALIZEDVALUE)
            {
                double dVal = GetNormalizedDataByID((*it)->GetColumn(),id);
                if ((*it)->IsFilteredByValue(dVal))
                    return true;
            }
            if ((*it)->GetType() == TYPE_DOUBLE)
            {
                double dVal = GetDoubleDataByID((*it)->GetColumn(),id);
                if ((*it)->IsFilteredByValue(dVal))
                    return true;
            }
            if ((*it)->GetType() == TYPE_INT)
            {
                int iVal = GetIntDataByID((*it)->GetColumn(),id);
                // DO: Converts to double automatically? Is this right?
                if ((*it)->IsFilteredByValue(iVal))
                    return true;
            }
        }
        return false;
    }

protected:
    int             mTotalRows;
    int             mFilteredRows;

    int             mDefaultRowHeight;
    int             mDefaultRowZoomHeight;
    int             mZoomRow;

private:
    bool            mFiltersActive;
    bool            mFiltersWorking;
    bool            mSortAscending;

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

    String          mSortColumn;

    std::vector<TableUpdateListener*>           mTableListeners;
    std::list<TableFilter*>                     mFilters;
    std::vector<int>                            mSortSequence;
    std::map<int, int>                          mMarkedRows;
    std::map<int, bool>                         mVisibleRows;

    // self description of data columns:
    std::vector<TableSourceColumnDescription>   mColumnNames;
    std::vector<TableSourceColumnDescription>   mExtraColumnNames;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(TableDataSource, Application.VideoExcel);

} // namespace VideoExcel
} // namespace Application
} // namespace Impala

#endif // TableDataSource_h

---