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

---

Graph.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
// Graph.h
//
// Graph can be used to show a graph that can optionally be zoomed and panned.
//
// As nodes a Graph can accept any drawable object that implements the
//      SetGetDimensions2dIntI
// interface class, which defines the following two member functions:
//      virtual void GetDimensions(int& x, int& y, int& w, int& h) = 0;
//      virtual void SetDimensions(int x, int y, int w, int h) = 0;
//
// OglGui::Window as well as OglGui::View implement the SetGetDimensions2dIntI
// interface class. Therefore, any OglGui::Window derived OGL component as
// well as any OglGui::View derived view can be added as nodes to a Graph.
//
// Such nodes are first created in the normal way inside the graph, after which
// the graph needs to be informed about items added.
// Exampe:
//      Graph*  graph = new Graph(parent, 10, 10, 400, 400);
//      Window* wnd   = new Window(graph, 100, 100, 40, 40);
//      View*   view  = new View(graph, imPtr, 200, 200, 100, 100);
//      graph->AddNode(wnd);
//      graph->AddNode(view);
//      // Connect nodes 'wnd' to 'view' with a line going from RED to BLUE
//      graph->ConnectNode(wnd, view, oglRED, oglBLUE);
//
// Since a Graph itself is also derived from OglGui::window, it can also
// be added as a node, that is optionally sizable, inside another graph.
// When serving as a simple node you can let it show a text and ask it to
// draw a rectangle or an oval, of which the (possibly transparent) background
// can be set.
//
// ToDo: Add code for node removal.
//
// Author: Richard van Balen
#ifndef OglGui_Graph_h
#define OglGui_Graph_h

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

#ifndef OglGui_SizableWindow_h
#include "OglGui/SizableWindow.h"
#endif

/*
#ifndef OglGui_View_h
#include "OglGui/View.h"
#endif
*/

namespace OglGui {

class Graph : public SizableWindow, public DocDimensions
{
public:
    typedef SetGetDimensions2dIntI          Node;
    typedef std::vector<Node*>              NodeVector;
    typedef std::vector<ULONG>              ColorVector;

    // Info on the nodes inside a graph
    struct NodeInfo {
        NodeVector  nodeVector;      // First element is the node itself,
                                     // followed by the nodes it connects to
        ColorVector lineStartColors; // Connecting line start colors
        ColorVector lineEndColors;   // Connecting line end colors
        Graph*      graphPtr;        // Non-null when the node is a graph
        int         scaleMode;       // Scale constraints. 0 = no constraints
                                     // NoWidth,NoHeight,NoHorizontal,NoVertical
        float       scaleX;
        float       scaleY;
        float       scaleW;
        float       scaleH;
    };

    static const int  RECTANGLE = 1;
    static const int  OVAL      = 2;

    Graph(Window* parent, int w, int h, int drawShape=0, strconst txt="") :
        SizableWindow(parent, w, h)
    {
        Init(drawShape, txt);
    }

    Graph(Window* parent, int x, int y, int w, int h, int drawShape=0,
          strconst txt=""):
        SizableWindow(parent, x, y, w, h)
    {
        Init(drawShape, txt);
    }

    int NrOfNodes()
    {
        return mNodes.size();
    }

    int FindNodeIdx(Node* node)
    {
        for (int i=0; i<mNodes.size(); i++)
        {
            if (mNodes[i].nodeVector[0] == node)
                return i;
        }
        return -1;
    }

    Node* GetNode(int idx)
    {
        if (idx<0 || idx>mNodes.size()-1)
            return 0;
        return mNodes[idx].nodeVector[0];
    }

    int AddNode(Node* node, int scaleOption=0, Graph* graph=0)
    {
        NodeInfo nodeInfo;

        nodeInfo.graphPtr   = graph;
        nodeInfo.scaleMode  = scaleOption; // 0, NoHorizontal and/or NoVertical

        nodeInfo.nodeVector.push_back(node);
        mNodes.push_back(nodeInfo);
        return mNodes.size()-1;
    }

    int AddNode(Graph* graphWnd, int scaleOption=0)
    {
        return AddNode((Node*)graphWnd, scaleOption, graphWnd);
    }

    void RemoveNodeIdx(int idx)
    {
        if (idx < 0 || idx >= mNodes.size())
            return;
        Node* node = mNodes[idx].nodeVector[0];
        for (int i=0; i<mNodes.size(); i++)
        {
            NodeVector& nodeVector = mNodes[i].nodeVector;
            for (int j=nodeVector.size()-1; j>=0; j--)
                if (nodeVector[j] == node)
                    nodeVector.erase(nodeVector.begin()+j);
        }
        mNodes.erase(mNodes.begin()+idx);
        // RvB: Maybe change interface so that we do not simply add nodes
        // but we add OglGui::window or OglGui::View derived objects.
        // Than destruction is possible and safe.
        // delete (OglGui::Window*) node;
    }

    void RemoveNode(Node* node)
    {
        RemoveNodeIdx(FindNodeIdx(node));
    }

    void ClearNodes()
    {
        mNodes.clear();
    }

    void ConnectNode(Node* fromNode, Node* toNode, ULONG startCol=oglBLACK,
                     ULONG endCol=oglBLACK)
    {
        int idx = FindNodeIdx(fromNode);
        if (idx==-1)
            return;
        NodeInfo& nodeInfo = mNodes[idx];
        nodeInfo.nodeVector.push_back(toNode);
        nodeInfo.lineStartColors.push_back(startCol);
        nodeInfo.lineEndColors.push_back(endCol);
    }

    virtual void AlignString(int offsetX=0, int offsetY=0)
    {
        if (mText.empty())
            return;
        int     x, y;
        ULONG   fCol = GetState() ? GetForeground() : oglGREY;

        oglSys.AlignTextXY(mOglWnd, (char *) mText.c_str(), mAlignH, mAlignV,
                           mOglWnd->width, mOglWnd->height, &x, &y);
        y += 3 + offsetY;
        x += offsetX;
        glNormal3f(0,0,1);
        if (mTextShadowed)
            oglSys.ShadowPrintf(mOglWnd, x, y, mShadowColor, fCol,
                                "%s", mText.c_str());
        else
            oglSys.PosColPrintf(mOglWnd, x, y, fCol, "%s", mText.c_str());
    }

    void DrawShape()
    {
        if (!mDrawShape)
            return;

        int w = W(), h = H();
        if (mShapeBg)
        {
            int bInfo[3];
            if (mShapeBg & 0xff000000)
                oglSys.StartBlend(bInfo);
            SetSolidFillColor(mShapeBg);
            if (mDrawShape == OVAL)
                FillOval(w/2,h/2,w/2,h/2);
            else
                FillRectangle(0,0,w-1,h-1);
             if (mShapeBg & 0xff000000)
                oglSys.EndBlend(bInfo);
        }
        if (mShapeFg & 0xff000000)
        {
            SetSolidLineColor(mShapeFg);
            if (mDrawShape == OVAL)
                DrawOval(w/2,h/2,w/2,h/2);
            else
                DrawRectangle(0.5,0.5,w-1,h-1);
        }
    }

    void DrawConnections()
    {
        glLineWidth(2);
        for (int i=0; i < mNodes.size(); i++)
        {
            int     x, y, w, h;
            Node*   node = mNodes[i].nodeVector[0];
            node->GetDimensions(x,y,w,h);

            int     srcX = x + w/2;
            int     srcY = y + h/2;

            NodeVector&     nodeVector      = mNodes[i].nodeVector;
            ColorVector&    colStartVector  = mNodes[i].lineStartColors;
            ColorVector&    colEndVector    = mNodes[i].lineEndColors;
            for (int j=1; j < nodeVector.size(); j++)
            {
                Node* dstNode = nodeVector[j];
                dstNode->GetDimensions(x,y,w,h);

                int dstX = x + w/2;
                int dstY = y + h/2;
                SetLineColors(colStartVector[j-1],colEndVector[j-1],0,0);
                DrawLine(srcX, srcY, dstX, dstY);
            }
        }
        glLineWidth(1);
    }

    void SetShowContentAt(int minW, int minH)
    {
        mShowContentMinW = minW;
        mShowContentMinH = minH;
    }

    void HandleShowContent()
    {
        bool showContent = W() >= mShowContentMinW && H() >= mShowContentMinH;
        if (!showContent && (mOglWnd->wndList || mOglWnd->objectList))
        {
            mOldWndList      = mOglWnd->wndList;
            mOldObjectList   = mOglWnd->objectList;
            mOglWnd->wndList = mOglWnd->objectList = 0;
        }
        if (showContent && !(mOglWnd->wndList || mOglWnd->objectList))
        {
            mOglWnd->wndList    = mOldWndList;
            mOglWnd->objectList = mOldObjectList;
        }
        if (showContent)
            DrawConnections();
    }

    virtual void DisplayFunc()
    {
        OGC myOGC;
        OGCSave(&myOGC);
        HandleShowContent();
        DrawShape();
        AlignString(mAlignOffH, mAlignOffV);
        SizableWindow::DisplayFunc();
        if (mDocBased && mDocLines)
        {
            SetSolidLineColor(oglBLACK);
            DrawRectangle(mDocX,mDocY,mDocW, mDocH);
        }
        OGCRestore(&myOGC);
    }

    void StartScalers()
    {
        if (mDocBased)
        {
            mDocScaleX = mDocX/(float)W();
            mDocScaleY = mDocY/(float)H();
            mDocScaleW = mDocW/(float)W();
            mDocScaleH = mDocH/(float)H();
        }
        int wndW = mDocBased ? DocW() : W();
        int wndH = mDocBased ? DocH() : H();
        for (int i=0; i < mNodes.size(); i++)
        {
            NodeInfo& nodeInfo = mNodes[i];
            int x, y, w, h;
            nodeInfo.nodeVector[0]->GetDimensions(x, y, w, h);
            x = mDocBased ? -mDocX + x : x;
            y = mDocBased ? -mDocY + y : y;
            nodeInfo.scaleX = x/(float)wndW;
            nodeInfo.scaleY = y/(float)wndH;
            nodeInfo.scaleW = w/(float)wndW;
            nodeInfo.scaleH = h/(float)wndH;
            if (nodeInfo.graphPtr)
                nodeInfo.graphPtr->StartScalers();
        }
    }

    void DoScaling(bool passive=false)
    {
        if (passive && mDocBased)
        {
            mDocX = mDocScaleX * W();
            mDocY = mDocScaleY * H();
            mDocW = mDocScaleW * W();
            mDocH = mDocScaleH * H();
        }
        int lw = mDocBased ? DocW() : W();
        int lh = mDocBased ? DocH() : H();
        for (int i=0; i < mNodes.size(); i++)
        {
            NodeInfo&   nodeInfo = mNodes[i];
            Node*       node     = nodeInfo.nodeVector[0];
            int         mode     = nodeInfo.scaleMode;

            int         fx, fy, fw, fh;
            node->GetDimensions(fx,fy,fw,fh);
            if(!(mode & NoHorizontal))
            {
                fx = (int)(lw * nodeInfo.scaleX);
                if(!(mode & NoWidth))
                    fw = (int)(lw * nodeInfo.scaleW);
            }
            if(!(mode & NoVertical))
            {
                fy = (int)(lh * nodeInfo.scaleY);
                if(!(mode & NoHeight))
                    fh = (int)(lh * nodeInfo.scaleH);
            }

            node->SetDimensions(fx+mDocX, fy+mDocY, fw, fh);
            if (nodeInfo.graphPtr)
                nodeInfo.graphPtr->DoScaling(true);
        }
    }

    void DoPanning()
    {
        int sz = mNodes.size();
        for (int i=0; i < mNodes.size(); i++)
        {
            NodeInfo&   nodeInfo = mNodes[i];
            Node*       node     = nodeInfo.nodeVector[0];

            int fx, fy, fw, fh;
            node->GetDimensions(fx,fy,fw,fh);
            node->SetDimensions(fx-mPanDifX,fy-mPanDifY,fw,fh);
        }
    }

    virtual void DocX(int x)
    {
        mPanDifY = 0;
        if (mPanDifX = mDocX-x)
        {
            mDocX = x;
            DoPanning();
        }
    }

    virtual void DocY(int y)
    {
        mPanDifX = 0;
        if (mPanDifY = mDocY-y)
        {
            mDocY = y;
            DoPanning();
        }
    }

    // MouseFunc used when Graph contents is window based.
    virtual void WndMouseFunc(int msg, int btn, int state, int x, int y)
    {
        bool zoomState = (state==(oglLeftButton|oglControl|oglShift));
        if (!zoomState)
            mZooming = false;
        if (!mZooming && !zoomState)
            SizableWindow::MouseFunc(msg, btn, state, x, y);
        if (msg == oglMouseDown && btn == oglLeftButton && zoomState)
        {
            mZooming    = mZoomable ? true : false;
            mStartTopX  = x;
            mStartTopY  = y;
            oglSys.VPToTopWndI(mOglWnd, &mStartTopX, &mStartTopY);
            mLastX = mStartTopX;
            mNormX = x / (float) W();
            mNormY = y / (float) H();
            if (mZooming)
                StartScalers();
        }
        if (msg == oglMouseMove && mZooming)
        {
            int topX = x, topY = y;
            oglSys.VPToTopWndI(mOglWnd,&topX, &topY);
            int difX = mLastX-topX;
            int nX, nY, nW, nH;
            GetDimensions(nX,nY,nW,nH);
            int nnW = (1.0-(difX/100.0)) * nW;
            if (nnW==nW && difX) // If rounding stops size difference
                nnW -= difX;
            if (nnW >= mMinW && nnW <= mMaxW)
                nW = nnW;
            int nnH = (1.0-(difX/100.0)) * nH;
            if (nnH==nH && difX) // If rounding stops size difference
                nnH -= difX;
            if (nnH >= mMinH && nnH <= mMaxH)
                nH = nnH;
            nX = mStartTopX - mNormX * nW;
            nY = mStartTopY - mNormY * nH;
            oglSys.TopWndToVPI(GetParent()->GetOGLWND(), &nX, &nY);
            ClampMinMax(nX, nY, nW, nH);
            SetDimensions(nX, nY, nW, nH);
            DoScaling();
            mLastX = topX;
        }
    }

    // MouseFunc used when Graph contents is DocDimensions based.
    virtual void DocMouseFunc(int msg, int btn, int state, int x, int y)
    {
        bool zoomState = (state==(oglLeftButton|oglControl|oglShift));
        bool panState  = (state==(oglLeftButton|oglShift));
        if (!zoomState)
            mZooming = false;
        if (!panState)
            mPanning = false;
        if (msg == oglMouseDown && btn == oglLeftButton)
        {
            mZooming = mZoomable  ? zoomState : false;
            mPanning = mAllowMove ? panState  : false;
            mStartTopX = mLastX = x;
            mStartTopY = mLastY = y;
            mNormX = (mStartTopX-mDocX) / (float) DocW();
            mNormY = (mStartTopY-mDocY) / (float) DocH();
            if (mZooming)
                StartScalers();
        }
        if (!mZooming && !mPanning)
            Window::MouseFunc(msg,btn,state,x,y);
        if (msg == oglMouseMove && (mZooming||mPanning))
        {
            int nX, nY, nW, nH;
            GetDocDimensions(nX,nY,nW,nH);
            if (mZooming)
            {
                int difX = mLastX-x;
                if ((nW *= (1.0-(difX/100.0)))<12)
                    nW = 12;
                if ((nH *= (1.0-(difX/100.0)))<12)
                    nH = 12;
                nX = mStartTopX - mNormX * nW;
                nY = mStartTopY - mNormY * nH;
            }
            if (mPanning)
            {
                mPanDifX = mLastX - x;
                mPanDifY = mLastY - y;
                nX -= mPanDifX;
                nY -= mPanDifY;
            }
            mLastX = x;
            mLastY = y;

            bool sizeChange = (nW != mDocW || nH != mDocH);
            bool posChange  = (nX != mDocX || nY != mDocY);
            if (posChange || sizeChange)
                SetDocDimensions(nX, nY, nW, nH);
            if (mZooming && sizeChange)
                DoScaling();
            if (mPanning && posChange)
                DoPanning();
        }
    }

    virtual void MouseFunc(int msg, int btn, int state, int x, int y)
    {
        if (mDocBased)
            DocMouseFunc(msg,btn,state,x,y);
        else
            WndMouseFunc(msg,btn,state,x,y);
    }

// Setters/Getters
    void        Shape(int shape)                { mDrawShape = shape; }
    ULONG       Shape()                         { return mDrawShape; }
    void        ShapeBg(ULONG col)              { mShapeBg = col; }
    ULONG       ShapeBg()                       { return mShapeBg; }
    void        ShapeFg(ULONG col)              { mShapeFg = col; }
    ULONG       ShapeFg()                       { return mShapeFg; }
    void        SetText(std::string text)       { mText = text; }
    std::string GetText() const                 { return mText; }
    void        SetTextShadowed(bool mode=true) { mTextShadowed = mode; }
    void        SetShadowColor(ULONG shadCol)   { mShadowColor = shadCol; }
    ULONG       GetShadowColor() const          { return mShadowColor; }
    void        Zoomable(bool mode)             { mZoomable = mode; }
    bool        Zoomable()                      { return mZoomable; }
    void        Panable(bool mode)              { mAllowMove = mode; }
    bool        Panable()                       { return mAllowMove; }
    void        DocLines(bool mode)             { mDocLines = mode; }
    bool        DocLines()                      { return mDocLines; }
    void        DocBased(bool mode)             { mDocBased = mode; }
    bool        DocBased()                      { return mDocBased; }
    int         NrNodes()                       { return mNodes.size(); }

    void GetAlign(int& hAlign, int& vAlign) const
    {
        hAlign = mAlignH;
        vAlign = mAlignV;
    }

    void SetAlign(int hAlign, int vAlign=oglCenterAlign)
    {
        mAlignH = hAlign;
        mAlignV = vAlign;
    }

    void SetAlignOffsets(int hOff, int vOff)
    {
        mAlignOffH = hOff;
        mAlignOffV = vOff;
    }

    void SetCentered(bool val)
    {
        mAlignH = val ? oglCenterAlign : oglLeftAlign;
        mAlignV = oglCenterAlign;
    }

protected:
    std::vector<NodeInfo>   mNodes;
    std::string             mText;
    int                     mAlignH, mAlignOffH;
    int                     mAlignV, mAlignOffV;
    int                     mDrawShape;

    ULONG                   mShapeBg;
    ULONG                   mShapeFg;
    ULONG                   mShadowColor;

    float                   mDocScaleX;
    float                   mDocScaleY;
    float                   mDocScaleW;
    float                   mDocScaleH;

    bool                    mTextShadowed;
    bool                    mDocBased;
    bool                    mDocLines;
    bool                    mZoomable;
    bool                    mZooming;
    bool                    mPanning;


private:
    void Init(int drawShape, strconst txt)
    {
        mText           = txt;
        mTextShadowed   = false;
        mShadowColor    = oglLIGHTGREY;
        mAlignH         = oglCenterAlign;
        mAlignV         = oglCenterAlign;
        mAlignOffH      = 0;
        mAlignOffV      = 0;

        mDrawShape      = drawShape;
        mShapeBg        = 0xe0ff8080;
        mShapeFg        = mForeGroundColor;

        mZoomable       = true;
        mZooming        = false;
        mPanning        = false;
        mDocBased       = false;
        mDocLines       = true;

        mDocX           = 0;
        mDocY           = 0;
        mDocW           = W();
        mDocH           = H();

        mShowContentMinW    = 40;
        mShowContentMinH    = 40;
        mOldWndList         = 0;
        mOldObjectList      = 0;

        ActOnModifier(oglShift);
    }

    int                 mShowContentMinW;
    int                 mShowContentMinH;
    int                 mLastX;
    int                 mLastY;
    int                 mStartTopX;
    int                 mStartTopY;
    int                 mPanDifX;
    int                 mPanDifY;
    float               mNormX;
    float               mNormY;

    LIST*               mOldWndList;
    LIST*               mOldObjectList;
};

} // Namespace OglGui
#endif

---