table.h

namespace wex
{
 
    class table : public gui
    {
    public:
        table(gui *parent)
            : gui(parent),
              myRowDisplayCount(25),
              myRowStart(0),
              myRowHiLit(-1)
 
        {
            registerEventHandlers();
            text("");
        }
 
        void set(const std::vector<std::vector<std::string>> &val)
        {
            myContents = val;
        }
        void set(const std::vector<std::string> &val, int colcount)
        {
            std::vector<std::vector<std::string>> vvs;
            for (
                int row = 0;
                row < val.size() / colcount;
                row++)
            {
                std::vector<std::string> vrow;
                for (int col = 0; col < colcount; col++)
                {
                    // if (col == 0)
                    //     vrow.push_back(
                    //         val[row * colcount + col] + " " + val[row * colcount + col + 1]);
                    // else if (col == 1)
                    //     continue;
                    // else
                    vrow.push_back(val[row * colcount + col]);
                }
                vvs.push_back(vrow);
            }
            set(vvs);
        }
 
        void rowInc(int i)
        {
            myRowStart += i;
            if (myRowStart < 0)
                myRowStart = 0;
        }
 
        void rowLastDisplay()
        {
            myRowStart = myContents.size() - 1;
        }
 
        void rowHiLit( int k )
        {
            myRowHiLit = k;
        }
 
    private:
        std::vector<std::vector<std::string>> myContents;
        std::vector<int> myRowID;
        int myRowDisplayCount;
        int myRowStart;
        int myRowHiLit;
 
        void draw(shapes &S)
        {
            myRowID.clear();
 
            if (!myContents.size())
                return;
 
            int colCount = myContents[0].size();
            int colWidth;
            if (colCount <= 1)
                colWidth = size()[0];
            else
                colWidth = size()[0] / (colCount - 1);
            int rowStop;
            if (myContents.size() < 20)
            {
                myRowStart = 0;
                rowStop = myContents.size();
            }
            else
            {
                if (myRowStart > myContents.size() - 20)
                    myRowStart = myContents.size() - 20;
                rowStop = myRowStart + 30;
                if (rowStop > myContents.size())
                    rowStop = myContents.size();
            }
            // std::cout << "row " << myRowStart << " to " << myRowStart + rowStop - 1
            //           << " from " << myContents.size() << "\n";
            for (int kr = myRowStart; kr < rowStop; kr++)
            {
                if (myContents[kr].size() > colCount)
                    throw std::runtime_error(
                        "bad col count");
 
                if( kr == myRowHiLit )
                        S.color(0x0000FF);
                else
                        S.color(0);
 
                for (int kc = 0; kc < colCount; kc++)
                {
                    auto &val = myContents[kr][kc];
                    int x, w;
                    if (kc == 0)
                    {
                        x = 0;
                        w = 50;
 
                        // save the database ID of the row
                        // so it can be sent if the row is clicked
                        // assumes first column contains the db id
                        myRowID.push_back(atoi(val.c_str()));
                    }
                    else
                    {
                        x = 50 + (kc - 1) * colWidth;
                        w = colWidth;
                    }
                    S.text(
                        val,
                        {x, (kr - myRowStart) * 20,
                         w - 5, 20});
                    int xline = x + w - 10;
                    S.line({xline, (kr - myRowStart) * 20,
                            xline, (kr - myRowStart + 1) * 20});
                }
            }
        }
 
        void registerEventHandlers()
        {
            events().draw(
                [&](PAINTSTRUCT &ps)
                {
                    wex::shapes S(ps);
                    draw(S);
                });
 
            events().click(
                [this]
                {
                    PostMessageA(
                        myParent->handle(),
                        wex::eventMsgID::asyncReadComplete,
                        myRowID[getMouseStatus().y / 20],
                        0);
                });
        }
    };
}