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

---

Window.h

Go to the documentation of this file.

#ifndef Impala_Visualization_Window_h
#define Impala_Visualization_Window_h

#include <vector>
#include <strstream>
#include "OglGui/Window.h"
#include "Basis/CmdOptions.h"
#include "Visualization/ViewWithRect.h"
#include "Visualization/AppController.h"
#include "Visualization/AppControlGUI.h"
#include "Core/Geometry/RectangleTiler.h"

namespace Impala
{
namespace Visualization
{


class Window : public OglGui::Window, public AppControlGUI
{
public:
    typedef Core::Array::Array2dVec3UInt8 Array2dVec3UInt8;

    Window(int x, int y, int width, int height, bool is2d=true) :
        OglGui::Window(x, y, width, height, is2d),
        AppControlGUI(-1, true)
    {
        Init();
        AppController::Instance().AddControl(this);
    }

    Window(OglGui::Window* parent, int width, int height, bool is2d=true) :
        OglGui::Window(parent, width, height, is2d),
        AppControlGUI(-1, false)
    {
        Init();
    }

    Window(OglGui::Window* parent, int x, int y, int width, int height, bool is2d=true) :
        OglGui::Window(parent, x, y, width, height, is2d),
        AppControlGUI(-1, false)
    {
        Init();
    }

    virtual
    ~Window()
    {
#ifdef DESTRUCT_VERBOSE
printf("virtual Vis::Window destructor\n");
#endif
    }

    virtual void
    HandleStart()
    {
        if (!Valid())
            return;
        OglGui::Sys::Instance().Start(mOglWnd);
    }

    static Window*
    CastToWindow( OglGui::Window *oWnd )
    {
        if( !oWnd )
            return 0;
        if( oWnd->GetRunTimeType() & 4 )
            // RvB: Next line should probably be a static_cast. But it seems to work
            return (Window *) oWnd;
        return 0;
    }

    Window*
    MakeViewport(int width, int height, bool is2d)
    {
        Window* w = new Window(this, width, height);
        w->SetIs2d(is2d);
        return w;
    }

    // viewer part
    int
    NrViewers()
    {
        return mOglView.size();
    }

    void
    SetMakeViewWithRect(bool flag)
    {
        mMakeViewWithRect = flag;
    }

    void
    MakeView(int imW, int imH, double scale, bool texturing, bool noTexScaling,
             bool keepDispImage, OglGui::ViewListener* listener)
    {
        int n = mOglView.size();
        View* view;
        if (mIs2d)
        {
            int pX2d;
            int pY2d;
            mViewTiler.GetPos2d(scale * imW, scale * imH, pX2d, pY2d);
            if (mMakeViewWithRect)
                view = new ViewWithRect(mOglWnd, pX2d, pY2d, imW, imH, scale,
                                        texturing, noTexScaling, keepDispImage,
                                        listener);
            else
                view = new View(mOglWnd, pX2d, pY2d, imW, imH, scale,
                                texturing, noTexScaling, keepDispImage,
                                listener);
        }
        else
        {
            if (n == 0)
            {
                mFirstImSize = Max(imW, imH);
                std::cout << "Setting firstImSize " << imW << " x " << imH << std::endl;
            }
            float scaleX = ((float) imW / mFirstImSize) * scale;
            float scaleY = ((float) imH / mFirstImSize) * scale;
            std::cout << "scale : " << scaleX << " x " << scaleY << std::endl;
            float pX3d;
            float pY3d;
            float pZ3d;
            mViewTiler.GetPos3d(scaleX, scaleY, pX3d, pY3d, pZ3d);
            view = new View(mOglWnd, pX3d, pY3d, pZ3d, imW, imH, scaleX,
                            scaleY, noTexScaling, keepDispImage, listener);
        }
        mOglView.push_back(view);
    }

    // update image data of given view by copying data from given buffer
    // view will be created if it doesn't exist
    // however, view should be the first vacancy in the list
    // in case it exists it should have the right sizes
    void
    UpdateView(int view, unsigned char* dataPtr, int width, int height,
               double scale = 1.0, OglGui::ViewListener* listener = 0)
    {
        if (! dataPtr)
        {
            std::cout << "Window::updateView : dataPtr is null" << std::endl;
            return;
        }
        if (view > mOglView.size())
        {
            std::cout << "Window::updateView : invalid view : " << view << std::endl;
            return;
        }
        if (view == mOglView.size())
            MakeView(width, height, scale, false, false, true, listener);
        mOglView[view]->UpdateImage(dataPtr);
    }

    void
    UpdateView(int view, Array2dVec3UInt8* image,
               OglGui::ViewListener* listener = 0)
    {
        UpdateView(view, image->CPB(0,0), image->W(), image->H(), 1.0, listener);
    }

    // update image data of given view by copying data from given buffer
    // view will be created if it doesn't exist
    // however, view should be the first vacancy in the list
    // in case it exists it should have the right sizes
    template <class ArrayT>
    void
    UpdateView(int view, ArrayT* im, std::string displayMode,
               double scale = 1.0, OglGui::ViewListener* listener = 0)
    {
        if (! im)
        {
            std::cout << "Window::updateView : im is null" << std::endl;
            return;
        }
        if (view > mOglView.size())
        {
            std::cout << "Window::updateView : invalid view : " << view << std::endl;
            return;
        }
        if (view == mOglView.size())
            MakeView(im->CW(), im->CH(), scale, false, false, true, listener);
        mOglView[view]->UpdateImage(im, displayMode);
        mOglView[view]->SetZoom(scale, scale);
    }

    void
    SetViewText(int viewIdx, std::string text)
    {
        View* view = GetView(viewIdx);
        if (!view)
            return;
        view->SetText(text);
    }

    void
    SetViewSelected(int viewIdx, bool clearOthers = true)
    {
        for (int i=0 ; i<mOglView.size() ; i++)
        {
            if (i == viewIdx)
                mOglView[i]->SetSelected(true);
            else if (clearOthers)
                mOglView[i]->SetSelected(false);
        }
    }

    void
    SetViewSelectedTo(int viewIdx, bool state)
    {
        if (viewIdx >=mOglView.size() || viewIdx < 0)
            return;
        mOglView[viewIdx]->SetSelected(state);
    }

    bool
    GetViewSelected(int viewIdx)
    {
        return mOglView[viewIdx]->GetSelected();
    }

    void
    SetViewVisible(int viewIdx, bool flag)
    {
        View* view = GetView(viewIdx);
        if (!view)
            return;
        view->SetVisible(flag);
    }

    void
    SetViewPos(int viewIdx, int x, int y)
    {
        View* view = GetView(viewIdx);
        if (!view)
            return;
        view->SetDimensions2D(x, y, RETAIN, RETAIN);
    }

    View*
    GetView(int index)
    {
        if ((index < 0) || (index >= mOglView.size()))
            return 0;
        return mOglView[index];
    }

    ViewWithRect*
    GetViewWithRect(int index)
    {
        return (ViewWithRect*) GetView(index);
    }

    int
    GetViewIdx(View* view)
    {
        for (int i=0 ; i<mOglView.size() ; i++)
            if (mOglView[i] == view)
                return i;
        return -1;
    }

    // Deprecate?? Try using View::OnMouse or OnViewMouse
    View*
    FindView(int x, int y)
    {
        if (mIs2d)
        {
            OGLVIEW* view = viewSys.FindView(mOglWnd, x, y);
            if (!view)
                return 0;
            OglGui::View* v = (OglGui::View*) viewSys.GetSysData(view, 1);
            return (View*) v;
        }
        else
        {
            OGLVIEW3D* view = view3DSys.FindView(mOglWnd, x, y);
            if (!view)
                return 0;
            OglGui::View* v = (OglGui::View*) view3DSys.GetSysData(view, 1);
            return (View*) v;
        }
    }

    void
    SetAllowRepositionViewers(bool flag)
    {
        mAllowRepositionViewers = flag;
    }

    virtual void
    RepositionViewers()
    {
        if (!mAllowRepositionViewers)
            return;
        mViewTiler.ResetWnd(WndWidth(), WndHeight());
        for (int v=0 ; v<mOglView.size() ; v++)
        {
            if (mIs2d)
            {
                int x, y, w, h;
                mOglView[v]->GetDimensions2D(&x, &y, &w, &h);
                mViewTiler.GetPos2d(w, h, x, y);
                mOglView[v]->SetDimensions2D(x, y, RETAIN, RETAIN);
            }
            else
            {
                // todo
            }
        }
    }

    void
    DeleteViewers()
    {
        if (mIs2d)
            viewSys.DeleteViews(mOglWnd);
        else
            view3DSys.DeleteViews(mOglWnd);
        mOglView.clear();
        mViewTiler.ResetPos();
    }

    int
    SuggestWndWidth(double nrView, int imageWidth)
    {
        CmdOptions& options = CmdOptions::GetInstance();
        int reqWndWidth = options.GetInt("wndWidth");
        if (reqWndWidth != -1)
            return reqWndWidth;
        double viewScale = options.GetDouble("viewScale");
        return nrView * (viewScale * imageWidth + 5);
    }

    int
    SuggestWndHeight(double nrView, int imageHeight)
    {
        CmdOptions& options = CmdOptions::GetInstance();
        int reqWndHeight = options.GetInt("wndHeight");
        if (reqWndHeight != -1)
            return reqWndHeight;
        double viewScale = options.GetDouble("viewScale");
        return nrView * (viewScale * imageHeight + 5);
    }

    int
    SuggestWidth(std::string str)
    {
        if (! mOglWnd)
        {
            std::cout << "suggestWndWidth : no mOglwnd" << std::endl;
            return str.size() * 10;
        }
        OGLWND* top = oglSys.GetTopOGLWND(mOglWnd);
        if (! top->hFont)
        {
            std::cout << "suggestWidth : no hFont" << std::endl;
            return str.size() * 10;
        }
        int w;
        int h;
        oglSys.AbstFontTextSize(top, top->hFont, (char *) str.c_str(), &w, &h);
        return w;
    }

    // OGL user funcs

    virtual void
    InitFunc()
    {
        OglGui::Window::InitFunc();

        mInfoBox = oglSys.InfoBox(2, 2, 150, 18, 1);
        mInfoBox->transparent = 0.4f;
        oglSys.InfoBoxSolidCol(mInfoBox, oglSys.RGB2Color(255, 255, 255));
        oglSys.InfoBoxAddStr(mInfoBox, "This is a test", 2, 5, oglBLACK);
    }

    virtual void
    ExitFunc()
    {
        if (mInfoBox)
            oglSys.InfoBoxDestroy(mInfoBox);
        mInfoBox = 0;
        OglGui::Window::ExitFunc();
    }

    virtual void
    DisplayFunc()
    {
        if (mDoStatus)
            oglSys.SetStatusStr(mOglWnd, mStatusBuf);

        OglGui::Window::DisplayFunc();

        if (mInfoBoxActive && mInfoBoxDraw)
            oglSys.InfoBoxDraw(mOglWnd, mInfoBox);
    }

    virtual void
    MouseFunc(int msg, int but, int state, int x, int y)
    {
        if (mInfoBox) 
        {
            mInfoBox->x = x + 20;
            mInfoBox->y = y - 25;
            mInfoBoxDraw = false;
        }
       
        //if (msg == oglMouseUp)
        //    mPointerDrag = false;

        if (((msg==oglMouseDown && (but==oglLeftButton)) ||
             (state & oglLeftButton) && msg==oglMouseMove))
        {
            // RvB: Deze (FindView)is in 3D erg duur, vooral omdat view3DSys ook
            // nog eens op zoek gaat. Mischien moet in OGL C de OnViewer functies met
            // een OnMouse worden uitgebreid. Nadeel wel dat in 3D alleen goed
            // de mouse positie in image coordinaten om te zetten is wanneer de
            // viewer flat is en niet geroteerd is.
            /* todo : save InfoBox part
            mPointerView = FindView(x, y);
            if (mPointerView)
            {
                Array2dVec3UInt8* disp;
                mPointerView->WndToIm(x, y, mPointerX, mPointerY);
                if( mInfoBoxActive && (disp = mPointerView->GetDispImage()) )
                {
                    UInt8* ptr = disp->CPB(mPointerX, mPointerY);
                    std::ostrstream infoStream;
                    infoStream << mPointerX << "," << mPointerY << " = " 
                               << "(" << ptr[0] << "," << ptr[1] << ","
                               << ptr[2] << ")" << std::ends;
                    SetInfoBoxString(infoStream.str());
                    infoStream.freeze(false);
                    mInfoBoxDraw = true;
                }
                if ((msg == oglMouseDown) && (but == oglLeftButton))
                {
                    mPointerDrag = true;
                    mPointerDragX = mPointerX;
                    mPointerDragY = mPointerY;
                }
            }
            */
            //if (mListener)
            //    mListener->PointerEvent(this, mListenerData);
        }
        OglGui::Window::MouseFunc( msg, but, state, x, y );
    }

    void
    SetStatusStr(char* buf)
    {
        strcpy(mStatusBuf, buf);
        mDoStatus = true;
    }

    void
    ActivateInfoBox(bool doit)
    {
        mInfoBoxActive = doit;
    }

    void
    SetInfoBoxString(char* str)
    {
        oglSys.InfoBoxChangeStr(mInfoBox, 0, str, RETAIN, RETAIN, RETAIN);
    }

    // In OxWnd renamed to SetRoundness
    /*
    void
    SetBorderRoundness(float r0, float r1, float r2, float r3)
    {
        if( r0 != FRETAIN )
            mOglWnd->r0 = r0;
        if( r1 != FRETAIN )
            mOglWnd->r1 = r1;
        if( r2 != FRETAIN )
            mOglWnd->r2 = r2;
        if( r3 != FRETAIN )
            mOglWnd->r3 = r3;
    }
    */

    // In OxWnd renamed to GetRoundness
    /*
    void
    GetBorderRoundness(float& r0, float& r1, float& r2, float& r3)
    {
        r0 = mOglWnd->r0;
        r1 = mOglWnd->r1;
        r2 = mOglWnd->r2;
        r3 = mOglWnd->r3;
    }
    */

protected:

    // Not used in OglGui::Window
    //unsigned int mHighlightColor;
    //unsigned int mNormalColor;

    bool mDoStatus;
    char mStatusBuf[256];

    INFOBOX* mInfoBox;
    bool     mInfoBoxDraw;
    bool     mInfoBoxActive;

private:

    void
    Init()
    {
        if (!mOglWnd)
        {
            std::cout << "CreateOGLWND/ViewPort failed" << std::endl;
            return;
        }

        mRunTimeType |= 4;

        mViewTiler.ResetWnd(mOglWnd->width, mOglWnd->height);
        mMakeViewWithRect = false;
        mAllowRepositionViewers = true;

        //todo: add skinning
        //mNormalColor = 0xffd2c799;
        //mHighlightColor = 0xffddddaa;
//        mOglWnd->bgCol = mNormalColor;

        
        mDoStatus = false;
        mInfoBoxActive = true;
        mInfoBoxDraw = false;
        mInfoBox = 0;
    }

    bool                       mMakeViewWithRect;
    std::vector<View*>         mOglView;
    Core::Geometry::RectangleTiler mViewTiler;
    bool                       mAllowRepositionViewers;

    int mFirstImSize; // for normalization of 3d viewers size, based on first view

};

} // namespace Visualization
} // namespace Impala

#endif

---