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

---

AlertTimeLine.h

Go to the documentation of this file.

/*
12345678901234567890123456789012345678901234567890123456789012345678901234567890
*/
#ifndef OglGui_AlertTimeLine_h
#define OglGui_AlertTimeLine_h

#include <iostream>

#ifndef OglGui_Button_h
#include "OglGui/Button.h"
#endif

#ifndef OglGui_AlertTimeLineListener_h
#include "OglGui/AlertTimeLineListener.h"
#endif

namespace OglGui
{

class AlertTimeLine : public  Window, ButtonListener
{
public:

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

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

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

    void
    SetAlertTimeLineListener(AlertTimeLineListener* listener, void* listenerData = 0)
    {
        mListener = listener;
        mListenerData = listenerData;
    }

// Start of test purpose only
    class GenerateAlertListener : public ButtonListener
    {
        virtual void ButtonSelectionEvent(Button* src, void* userData)
        {
            AlertTimeLine* timeLine = (AlertTimeLine*) userData;
            ULONG          col = src->GetBorderBackground();
            int            id = ABSRND(12);
            timeLine->AddAlert(id, col, (void*)id);
        }
    };

    class AdvanceTimeListener : public ButtonListener
    {
        virtual void ButtonSelectionEvent(Button* src, void* userData)
        {
            AlertTimeLine* timeLine = (AlertTimeLine*) userData;
            timeLine->AdvanceTime(60);
        }
    };

    void TestOnly_ManualTimeLineEvents()
    {
        GenerateAlertListener* genAlert = new GenerateAlertListener();
        Button* btn;
        btn = new Button(this, 0, H()-44, 80, 20, "test event");
        btn->SetBorderBackground(0xffffff00);
        btn->SetDoStateFeedback(false);
        btn->SetButtonListener(genAlert, (void*) this);
        btn->ConnectTo(this, T2T|B2T);

        btn = new Button(this, 0, H()-66, 80, 20, "test alert");
        btn->SetBorderBackground(0xffff0000);
        btn->SetDoStateFeedback(false);
        btn->SetButtonListener(genAlert, (void*) this);
        btn->ConnectTo(this, T2T|B2T);

        btn = new Button(this, 0, H()-88, 80, 20, "1 min");
        btn->SetButtonListener(new AdvanceTimeListener(), (void*) this);

        btn->ConnectTo(this, T2T|B2T);
    }
// End of test purpose only

    
    void SetTimeSpan(long seconds)      { mTimeSpan     = seconds; }
    void SetOlderThanText(strconst str) { mOlderThanStr = str; }
    void AdvanceTime(long seconds)      { mStartTime += seconds; }
    long GetCurrentTime()               { return mCurrentTime; }
    long GetStartTime()                 { return mStartTime; }
    long GetStartTimeOffset()           { return mStartTimeOffset; }

    Button* OlderThanButton()           { return mOlderThanBtn; }

    //void SetStartTime(long seconds)
    //{
    //    mCurrentTime = mStartTime = seconds - oglWndSecondsSinceStart;
    //}

    void SetTime(long startTimeSec, int currentTimeOffsetSec = 0)
    {
        mStartTime = startTimeSec - oglWndSecondsSinceStart;
        mStartTimeOffset = (long) currentTimeOffsetSec;
        mCurrentTime = mStartTime + mStartTimeOffset;
    }

    // Listener for the alert buttons
    virtual void ButtonSelectionEvent(Button *src, void* userData)
    {
        if (!mListener)
            return;
        int id = atoi(src->GetText().c_str());
        mListener->AlertSelectionEvent(this, id, userData, mListenerData);
    }

    void AddAlert(int alertId, ULONG col, void* userData, long seconds)
    {
        char    buf[40];
        sprintf(buf, "%d", alertId);

        int h = mLineY;// - mAlertH/2;
        int base = h;
        int nX = ComputeX(seconds);
        int nBtns = mAlertButtons.size();

        Button* lastBtn = nBtns ? mAlertButtons[nBtns-1] : 0;
        if (lastBtn && nX-lastBtn->X() < mAlertW)
        {
            int i = nBtns-1;
            while (i>=0 && mAlertButtons[i]->Y() > base)
                i--;
            while (i<nBtns && mAlertButtons[i]->X() > nX-mAlertW)
            {
                h = mAlertButtons[i]->Y() + mAlertH;
                i++;
            }
        }
        Button* btn = AlertButton(nX, h, mAlertW, mAlertH, col, buf);
        oglSys.SetUserData(btn->GetOGLWND(), 1, (void*) seconds);
        oglSys.SetUserData(btn->GetOGLWND(), 2, (void*) userData);
        btn->SetButtonListener(this, userData);
        mAlertButtons.push_back(btn);
        mNrAlerts++;
    }

    void AddAlert(int alertId, ULONG col, void* userData)
    {
        AddAlert(alertId, col, userData, mCurrentTime);
    }

    static void
    GetTimeUnits(long timeInSeconds, int& hours, int& minutes, int& seconds)
    {
        hours   = timeInSeconds / 3600;
        minutes = (timeInSeconds % 3600) / 60;
        seconds = (timeInSeconds % 3600) % 60;
    }

    static long UnitsToSeconds(int h, int m, int s)
    {
        return h * 3600 + m * 60 + s;
    }

    virtual void DisplayFunc()
    {
        mCurrentTime = mStartTime + mStartTimeOffset + oglWndSecondsSinceStart;

        OGC oldOGC;
        OGCSave(&oldOGC);

        int h = H(), w = W();
        SetSolidLineColor(oglBLACK);
        DrawLine(0, mLineY, w-mAlertW, mLineY);
        SetSolidLineColor(oglWHITE);
        DrawLine(0, mLineY-1, w-mAlertW, mLineY-1);

        DrawTicks();
        DrawCurrentTime();
        PositionAlerts();

        oglSys.PosColPrintf(mOglWnd, w/2, 0, oglBLACK, "total: %d", mNrAlerts);

        char buf[100];
        sprintf(buf, "%d %s", mNrOlderAlerts, mOlderThanStr.c_str());
        mOlderThanBtn->SetText(buf);
        mOlderThanBtn->SetState(mNrOlderAlerts==0 ? 0 : 1);

        oglSys.UpdateSceneFlag(mOglWnd, 1);
        OGCRestore(&oldOGC);
        Window::DisplayFunc();
    }

protected:

    long GetButtonTime(Button* btn)
    {
        OGLWND* oglWnd = btn->GetOGLWND();
        return (long) oglSys.GetUserData(oglWnd, 1);
    }

    void DrawCurrentTime()
    {
        int     h, m, s;
        GetTimeUnits(mCurrentTime, h, m, s);
        oglSys.PosColPrintf(mOglWnd, W()-130, 0, oglBLACK,
                            "current time: %02d:%02d:%02d", h, m, s);
    }

    void DrawTicks(bool detailed=true, int detailResolution=10)
    {
        int     h, m, s;
        long    tickT = mCurrentTime;

        while (tickT  >= (mCurrentTime - mTimeSpan))
        {
            GetTimeUnits(tickT, h, m, s);
            int x = ComputeX(tickT);
            if ( !(m%5) && !(s%60)){
                DrawLine(x, mLineY, x, mLineY - 7);
                oglSys.PosColPrintf(mOglWnd, x-16, mLineY-20, 0xff505050,
                                   "%02d:%02d", h, m);
            }
            else if (!(s%60))
            {
                DrawLine(x, mLineY, x, mLineY - 5);
                oglSys.PosColPrintf(mOglWnd, x-6, mLineY-18, 0xff757575,
                                    "%02d", m);
                //oglSys.PosColPrintf(mOglWnd, x-6, mLineY-18, 0xff606060,
                //                    "%02d", m);
            }
            else if(detailed && !(s%detailResolution))
                DrawLine(x, mLineY, x, mLineY - 3);

            tickT--;
        }
    }
    int ComputeX(long btnTime)
    {
        float   x = W() - ((mCurrentTime - btnTime)/(float)mTimeSpan) * W();
        x -=  mAlertW;
        return (int) x;
    }
    int ComputeX(Button* btn)
    {
        long    btnTime = GetButtonTime(btn);
        return ComputeX(btnTime);
    }

    void PositionAlerts()
    {
        for (int i=0; i<mAlertButtons.size(); i++)
        {
            Button* btn = mAlertButtons[i];
            int     x   = ComputeX(btn);
            btn->SetDimensions(x, RETAIN, RETAIN, RETAIN);
        }
        // Delete those alerts that become to old
        for (int i=mAlertButtons.size()-1; i >= 0; i--)
        {
            Button* btn = mAlertButtons[i];
            if (btn->X() < -btn->W()/2)
            {
                mAlertButtons.erase(mAlertButtons.begin()+i);
                mNrOlderAlerts++;
                delete btn;
            }
        }
    }

    Button* AlertButton(int x, int y, int w, int h, ULONG col, strconst str)
    {
        Button* btn = new Button(this, x, y, w, h, str, BEV_ETCHED, true);
        btn->SetBorderType(1);
        btn->SetBorderBackground(col);
        btn->SetDoStateFeedback(false);
        return btn;
    }

private:
        void Init(int w, int h)
        {
        mLineY = 40;
        mAlertW = 20;
        mAlertH = 16;
        mTimeSpan = 900; // default in sec

        mOlderThanStr = "older than 15 minutes ..."; // default
        mOlderThanBtn = new Button(this, 0, 0, 140, 18, "", BEV_ETCHED, true);
        mNrAlerts = 0;
        mNrOlderAlerts = 0;

        mListener = 0;

        SetAllowChildScaling(false);
        }

    std::vector<Button*> mAlertButtons;
    std::string          mOlderThanStr;
    Button*              mOlderThanBtn;

    AlertTimeLineListener*  mListener;
    void*                   mListenerData;

    int         mNrAlerts;
    int         mNrOlderAlerts;

    int         mLineY;
    int         mAlertW;
    int         mAlertH;
    long        mStartTime;
    long        mStartTimeOffset;
    long        mCurrentTime;
    long        mTimeSpan;
};

} // namespace OglGui

#endif

---