vizwinmgr.h

Go to the documentation of this file.

//************************************************************************
//                                                                      *tab
//           Copyright (C)  2004                                        *
//     University Corporation for Atmospheric Research                  *
//           All Rights Reserved                                        *
//                                                                      *
//************************************************************************/
//                  
//  File:       vizwinmgr.h
//
//  Author:     Alan Norton
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       Sept 2004
//


#ifndef VIZWINMGR_H
#define VIZWINMGR_H

class QMdiArea;
class QMdiSubWindow;
class QWidget;
class QDesktopWidget;
class QMainWidget;
class QTimer;

#include "vapor/ControlExecutive.h"
#include <qobject.h>

#include "viewpointparams.h"
#include "regionparams.h"
#include "animationparams.h"
#include <vapor/common.h>


#include "params.h"

namespace VAPoR{

class AnimationParams;
class EventRouter;
class TabManager;
class MainForm;
class ViewpointParams;
class RegionParams;

class VizWin;
class AnimationEventRouter;
class RegionEventRouter;
class ViewpointEventRouter;

typedef EventRouter* (EventRouterCreateFcn)();

//
class VizWinMgr : public QObject
{
    Q_OBJECT

public:
    
    void forceRender(Params* p, bool always=false);
    
    static void InstallTab(const std::string tag, EventRouterCreateFcn fcn);

    static EventRouter* getEventRouter(const std::string& tag);

    void SetToDefaults();

    static void UndoRedo(bool isUndo, int /*instance*/, Params* beforeP, Params* afterP, Params* aux1 = 0, Params* aux2 = 0);

    int getNumVisualizers(); 
   
    VizWin* getActiveVizWin() {
        int activeViz = ControlExec::GetActiveVizIndex();
        assert(activeViz >= 0);
        //Use an iterator so we don't insert if the viz is not there
        std::map<int, VizWin*>::iterator it;
        it = _vizWindow.find(activeViz);
        if (it == _vizWindow.end()) return 0;
        return _vizWindow[activeViz];
    }

    Visualizer* getActiveVisualizer() {
        int activeViz = ControlExec::GetActiveVizIndex();
        assert(activeViz >= 0);
        return ControlExec::GetVisualizer(activeViz);
    }
    RegionEventRouter* getRegionRouter();

    AnimationEventRouter* getAnimationRouter();

    ViewpointEventRouter* getViewpointRouter();

    VizWin* getVizWin(int i) {return _vizWindow[i];}

    //Following methods notify all params that are associated with a
    //specific window.
    void refreshViewpoint(ViewpointParams* vParams);

    void refreshRegion(RegionParams* rParams);

    static VizWinMgr* getInstance() {
        if (!_vizWinMgr)
            _vizWinMgr = new VizWinMgr();
        return _vizWinMgr;
    }
    
    void createAllDefaultTabs();
    
    void vizAboutToDisappear(int i); 
    
    int launchVisualizer();

    int addVisualizer(int viznum);

    void removeVisualizer(int viznum);

    int attachVisualizer(int useViznum);
    
    void setActiveViz(int vizNum); 

    void updateActiveParams();
    
    void createDefaultParams(int winnum);
    
    void refreshRenderData();
    
    void disableRenderers(const vector<string>& vars2D, const vector<string>& vars3D);

    void disableAllRenderers();

    void resetViews(ViewpointParams* vp);

    void resetTrackball();
    
    ~VizWinMgr();


public slots:
    void cascade();

    void fitSpace();

    void home();

    void sethome();

    void winActivated(int);

    void killViz(int viznum);

    //Slots that set viewpoint:

    void viewAll();

    void viewRegion();

    void alignView(int axis);

    void setVpLocalGlobal(int val);

    void setRgLocalGlobal(int val);

    void setAnimationLocalGlobal(int val);
#ifndef DOXYGEN_SKIP_THIS
signals:
    //Turn on/off multiple viz options:
    void enableMultiViz(bool onOff);
    //Respond to user setting the vizselectorcombo:
    void newViz(QString&, int);
    void removeViz(int);
    void activateViz(int);
    void changeName(QString&, int);
    
private:
    
    static void RegisterEventRouter(const std::string tag, EventRouter* router);
    
    // map tags to eventrouters
    static std::map<string, EventRouter*> _eventRouterMap;
    
    
    VizWinMgr();
    
    //Find the previous active visualizer, by looking at the last one
    //that corresponds to a valid visualizer
    int getLastActive(){
        int lastActivation = -1; int prevActiveVis = -1;
        //Use an iterator to loop over activation orders
        std::map<int, int>::iterator it;
        std::map<int, VizWin*>::iterator it2;
        for (it = _activationOrder.begin(); it != _activationOrder.end(); it++){
            int order = it->second;
            int vis = it->first;
            //Check if vis is a valid visualizer
            it2 = _vizWindow.find(vis);
            if (it2 == _vizWindow.end()) continue;
            
            if (order >lastActivation){ 
                lastActivation = order;
                prevActiveVis = vis;
            }
        }
        return prevActiveVis;
    }
    static VizWinMgr* _vizWinMgr;
    //Map visualizer id to vizwin
    std::map<int, VizWin*> _vizWindow;
    std::map<int,QMdiSubWindow*> _vizMdiWin;
    //Activation order is a history of all the active visualizer indices.
    //It is a mapping from visualizer indices to the activation order.
    //When a visualizer is closed, the most recently active visualizer is re-activated.
    std::map<int,int> _activationOrder;
    
    //Remember the activation order:
    int _activationCount;
    MainForm* _mainForm;
    static TabManager* _tabManager;
   
    QMdiArea* _mdiArea;
    

#endif //DOXYGEN_SKIP_THIS
    
};
};
#endif // VIZWINMGR_H