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

---

StringColumns.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
// StringColumns.h
// NOTE: Work in progress. IMMATURE!!!
//
// Author: Richard van Balen
#ifndef OglGui_StringColumns_h
#define OglGui_StringColumns_h

#ifndef OglGui_Window_h
#include "OglGui/Window.h"
#endif

#ifndef OglGui_DocDimensions_h
#include "OglGui/DocDimensions.h"
#endif

namespace OglGui {

class StringColumns : public Window,
                      public DocDimensions
{
public:
    static const int    isShadowedBit      = 1;
    static const int    isSelectedBit      = 2;

    typedef std::vector<std::string>    StrVector;
    typedef std::vector<unsigned char>  StrOptions;
    typedef std::vector<ULONG>          StrColors;
         
    struct ColumnData {
        ColumnData(strconst label, StrVector& strV, int w=100, ULONG bg=0)
        {
            name        = label;
            strVector   = strV;
            width       = w;
            bgColor     = bg;
            marked      = 0;
        }
        std::string         name;
        StrVector           strVector;
        StrOptions          strOptions;
        StrColors           strColors;
        ULONG               bgColor;
        int                 width;
        int                 marked;
    };

    StringColumns(int x, int y, int w, int h) :
        Window(x, y, w, h)
    {
        Init(w,h);
    }

    StringColumns(Window* parent, int w, int h) :
        Window(parent, w, h)
    {
        Init(w,h);
    }

    StringColumns(Window* parent,int x,int y,int w,int h) :
        Window(parent, x, y, w, h)
    {
        Init(w,h);
    }

    void AddColumn(strconst colName, int colWidth=100, ULONG bg=0,
                   int insertAt=-1)
    {
        AddColumn(colName,&StrVector(),colWidth,bg,insertAt);
    }

    void AddColumn(strconst colName, StrVector* strVector, int colWidth=100,
                   ULONG bg=0, int insertAt=-1)
    {
        if (insertAt<-1) insertAt = 0;
        if (insertAt==-1 || insertAt>mColumns.size()-1)
            insertAt = mColumns.size();

        ColumnData colData    = ColumnData(colName,*strVector,colWidth,bg);

        StrOptions strOptions = StrOptions(strVector->size(),0);
        colData.strOptions    = strOptions;

        StrColors  strColors  = StrColors(strVector->size(),oglBLACK);
        colData.strColors     = strColors;

        mColumns.insert(mColumns.begin()+insertAt,colData);
        ComputeDocHeight();
    }

    void AddString(strconst str, int colIdx, ULONG col=oglBLACK,
                   int opts=0, int insertAt=-1)
    {
        if (colIdx<0 || colIdx>mColumns.size()-1)
            return;

        StrVector&  strVector  = mColumns[colIdx].strVector;
        StrOptions& strOptions = mColumns[colIdx].strOptions;
        StrColors&  strColors  = mColumns[colIdx].strColors;

        if (insertAt<-1) insertAt = 0;
        if (insertAt==-1 || insertAt>strVector.size()-1)
            insertAt = strVector.size();

        strVector.insert(strVector.begin()+insertAt,str);
        strOptions.insert(strOptions.begin()+insertAt,opts);
        strColors.insert(strColors.begin()+insertAt,col);
        ComputeDocHeight();
    }

    int GetColumnIdx(strconst name)
    {
        for (int i=0; i<mColumns.size(); i++)
            if (mColumns[i].name == name)
                return i;
        return -1;
    }

    ColumnData* GetColumnData(int colIdx)
    {
        if (colIdx<0 || colIdx>mColumns.size()-1)
            return 0;
        return &mColumns[colIdx];
    }

    ColumnData* GetColumnData(strconst name)
    {
        int colIdx = GetColumnIdx(name);
        return GetColumnData(colIdx);
    }

    void SelectRange(int col, int first, int last)
    {
        int start = (first<=last) ? first : last;
        int end   = (first<=last) ? last : first;
        if (col<0 || col>mColumns.size()-1)
            return;
        StrOptions& options = mColumns[col].strOptions;
        if (start<0 || end<0 || start>options.size()-1 || end>options.size()-1)
            return;
        for (int i=0; i<options.size(); i++)
        {
            if (i>=start && i<=end)
                options[i] |= isSelectedBit;
            else
                options[i] &= ~isSelectedBit;
        }
    }

    int FindColumn(int x)
    {
        int posX = 0;
        for (int i=0; i<mColumns.size(); i++)
        {
            if (x>posX && x<posX+mColumns[i].width)
                return i;
            posX += mColumns[i].width;
        }
        return -1;
    }

    int FindRow(int y)
    {
        return (mDocH + mDocY - y) / mItemHeight;
    }

    int FirstVisible()
    {
        return (mDocH + mDocY - H()) / mItemHeight;
    }

    int LastVisible()
    {
        return (mDocH + mDocY) / mItemHeight + 1;
    }

    virtual void DisplayFunc()
    {
        Window::DisplayFunc();

        int firstVis = FirstVisible();
        int lastVis  = LastVisible();
        int h0 = (mDocH + mDocY) - mItemHeight;
        int x = 0;

        for (int i=0; i<mColumns.size(); i++)
        {
            StrVector&  strVector = mColumns[i].strVector;
            int         width     = mColumns[i].width;
            ULONG       bg        = mColumns[i].bgColor;
            int         bInfo[3];

            oglSys.StartScissor(mOglWnd,x,0,width,H());
            oglSys.StartBlend(bInfo);
            SetSolidFillColor(bg);
            FillRectangle(x,0,width,H());

            for (int j=firstVis; j<lastVis && j<strVector.size(); j++)
                DrawItem(x, h0 - j*mItemHeight, mColumns[i], j);

            oglSys.EndBlend(bInfo);
            oglSys.EndScissor();
            x += width;
        }
    }

    virtual void MouseFunc(int msg, int btn, int state, int x, int y)
    {
        if (msg==oglMouseDown && btn==oglLeftButton)
        {
            int c = FindColumn(x);
            int r = FindRow(y);

            if (c!=-1 && r>0 && r<mColumns[c].strVector.size())
            {
                int marked = mColumns[c].marked;
                if (!(state & oglShift))
                    marked = r;
                if (!(state & oglControl))
                    SelectRange(c,marked,r);
                else
                    ToggleOptionsBit(mColumns[c].strOptions[r],isSelectedBit);
                mColumns[c].marked = marked;
            }
        }
        Window::MouseFunc(msg,btn,state,x,y);
    }

    virtual void ReshapeFunc(int w, int h)
    {
        Window::ReshapeFunc(w,h);

        // Anchor text at upper left corner
        mDocY += (h - mOldH);
        mOldH = h;
        if (mDocY < H() - mDocH)
            mDocY = H() - mDocH;
        if (mDocY > H() - mItemHeight)
            mDocY = H() - mItemHeight;
    }


protected:
    void ToggleOptionsBit(unsigned char& options, int bit)
    {
        options = (options&bit) ? (options & ~bit) : (options | bit);
    }

    void ComputeDocHeight()
    {
        int maxElem = 0;
        for (int i=0; i<mColumns.size(); i++)
        {
            StrVector& strVector = mColumns[i].strVector;
            if (strVector.size() > maxElem)
                maxElem = strVector.size();
        }
        mDocH = H();
        if (maxElem*mItemHeight > mDocH)
            mDocH = maxElem*mItemHeight;
    }

    void DrawItem(int x, int y, ColumnData& columnData, int strIdx)
    {
        StrVector& strVector = columnData.strVector;
        if (strIdx<0 || strIdx>strVector.size()-1)
            return;

        strconst str     = columnData.strVector[strIdx];
        int      options = columnData.strOptions[strIdx];
        ULONG    color   = columnData.strColors[strIdx];
        int      width   = columnData.width;

        if (options & isSelectedBit)
        {
            SetSolidFillColor(oglLIGHTBLUE);
            FillRectangle(x,y,width,mItemHeight);
        }
        if (options & isShadowedBit)
            oglSys.ShadowPrintf(mOglWnd,x+4,y+4,oglLIGHTGREY,color,str.c_str());
        else
            oglSys.PosColPrintf(mOglWnd,x+4,y+4,color,str.c_str());
    }

private:
    void Init(int w, int h)
    {
        mDocX = mDocY = 0;
        mDocW = w;
        mDocH = h;
        mItemHeight = 18;
        mOldH = h;
    }

    std::vector<ColumnData>   mColumns;
    int                       mItemHeight;
    int                       mOldH;
};

} // Namespace OglGui
#endif

---