文章標題

ifndef VIZWINMGR_H

define VIZWINMGR_H

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

include

include “twoDdataparams.h”

include “twoDimageparams.h”

include “viewpointparams.h”

include “regionparams.h”

include “probeparams.h”

include “flowparams.h”

include “isolineparams.h”

include “dvrparams.h”

include “animationparams.h”

include

include “params.h”

include “command.h”

namespace VAPoR{
class AnimationController;
class AnimationParams;

class EventRouter;
class TabManager;
class MainForm;
class ViewpointParams;
class RegionParams;
class DvrParams;
class ProbeParams;
class TwoDDataParams;
class TwoDImageParams;
class Trackball;
class VizWin;
class AnimationEventRouter;
class RegionEventRouter;
class DvrEventRouter;
class ProbeEventRouter;
class TwoDDataEventRouter;
class TwoDImageEventRouter;
class ViewpointEventRouter;
class FlowEventRouter;
class IsoEventRouter;

typedef EventRouter* (EventRouterCreateFcn)();

//! \class VizWinMgr
//! \brief A class for managing all visualizers
//! \author Alan Norton
//! \version Revision
//! \date Date
//! This class manages the VAPOR visualizers.
//! Its main function is to keep track of what visualizers are active
//! and what EventRouter and Params instances are associated with each visualizer.
//
class VizWinMgr : public QObject, public ParsedXml
{
Q_OBJECT

enum 
{
  PREAMBLE,
  RENDER,
  TEMPORAL,
  TFEDIT,
  DONE
};

public:

//! Static method that identifies the currently active params instance of a given type.
//! This is the currently selected instance in the current active visualizer.
//! \param[in] const std::string& tag  The XML tag associated with a Params class
//! \retval Params* Pointer to Params instance that is currently active
static Params* getActiveParams(const std::string& tag){
    return (Params::GetParamsInstance(tag, getInstance()->activeViz));
}

//! Method that requests a re-rendering for the renderer associated with a particular RenderParams instance.
//! The renderer must be enabled or this will have no effect unless the optional 'always' parameter is true.
//! \param[in] RenderParams* pointer to RenderParams instance that is associated with the rendering requested.
//! \param[in] bool always indicates that rerender will occur even if the params is disabled.
void forceRender(RenderParams* rp, bool always=false);

//!Method that forces all glWindows to reload their shaders
bool reloadShaders();
//! Static method obtains the EventRouter instance associated with a particular Params type.  There is a unique EventRouter
//! subclass associated with each tab, and a unique instance of that subclass.
//! \param[in] Params::ParamsBaseType TypeId of the Params type
//! \retval EventRouter* Pointer to the associated EventRouter instance
static EventRouter* getEventRouter(Params::ParamsBaseType typeId);

//! Static method that creates an eventRouter, and installs it as one of the tabs.
//! All extension EventRouter classes must call this during the InstallExtensions() method.
//! \param[in] const std::string tag : XML tag identifying the Params class.
//! \param[in] EventRouterCreateFcn : the required method that creates the EventRouter.
static void InstallTab(const std::string tag, EventRouterCreateFcn fcn);

//! Static method obtains the EventRouter instance associated with a particular Params tag
//! \param[in] const std::string& Tag of the Params 
//! \retval EventRouter* pointer to the associated EventRouter instance
static EventRouter* getEventRouter(const std::string& tag){
    return getEventRouter(ParamsBase::GetTypeFromTag(tag));
}

//! Static method that returns the global Params of a given type.
//! If the params is a RenderParams type, returns a default instance that
//! is not actually used in rendering
//! \param[in] Params::ParamsBaseType TypeId of the Params type
//! \retval Params* pointer to the associated Params instance
static Params* getGlobalParams(Params::ParamsBaseType ptype);

//! Method that specifies a params instance that is to be associated with a particular instance index in the renderer tab. 
//! This is needed during EventRouter::MakeCurrent(), when the
//! Params instance changes as a result of Undo/Redo action.
//! \param[in] int winNum : Visualizer number
//! \param[in] Params* p : Pointer to the new Params instance
//! \param[in] ParamsBase::ParamsBaseType TypeId associated with this Params
//! \param[in] int instance : The index of the associated instance, or -1 for the active instance.
void setParams(int winNum, Params* p, ParamsBase::ParamsBaseType typeId, int instance = -1);

//! Method that identifies the params instance associated with a visualizer, type, and instance index. 
//! \param[in] int winNum : Visualizer number
//! \param[in] ParamsBase::ParamsBaseType TypeId associated with this Params
//! \param[in] int instance : The index of the associated instance, or -1 for the active instance.
//! \retval Params*  Pointer to the Params instance
Params* getParams(int winNum, Params::ParamsBaseType pType, int instance = -1);

//! Static method that identifies the number of instances of a Params of a particular type, in a particular visualizer.
//! \param[in] int winnum Visualizer number
//! \param[in] ParamsBase::ParamsBaseType TypeId associated with this Params
//! \retval int Number of instances
static int getNumInstances(int winnum, Params::ParamsBaseType pType);

//! Static method that identifies the active instance index of a Params in a particular visualizer.
//! \param[in] int winnum Visualizer number
//! \param[in] ParamsBase::ParamsBaseType TypeId associated with this Params
//! \retval int Current active instance index
static int getCurrentInstanceIndex(int winnum, Params::ParamsBaseType t);

//! Static method that identifies the instance index of a Params instance in a particular renderer tab.
//! Each of the renderer instances indicated in the tab are associated with a unique Params instance, whether or
//! not the instance has been enabled.  All of the instances are associated with a particular visualizer.
//! \param[in] int winnum Visualizer number
//! \param[in] Params* Pointer to Params instance
//! \param[in] ParamsBase::ParamsBaseType TypeId associated with this Params
//! \retval int Instance index associated with this params or -1 if not found.
static int findInstanceIndex(int winnum, Params* params, Params::ParamsBaseType t);

//! Method that identifies the active index in the active visualizer
//! \param[in] ParamsBase::ParamsBaseType TypeId associated with this Params
//! \retval int Current active instance index
int getActiveInstanceIndex(Params::ParamsBaseType t){
    return getCurrentInstanceIndex(activeViz,t);
}

//! Identify the params instance that is current of a particular type (i.e. in a particular tab).
//! \param[in] ParamsBase::ParamsBaseType TypeId associated with this Params
//! \retval Params* Params instance that is current
Params* getApplicableParams(Params::ParamsBaseType t);

//! Identify the params instance that is currently applied of a particular tag
//! \param[in] const std::string& XML tag associated with this Params
//! \retval Params* Params instance that is current
Params* getApplicableParams(const std::string& tag){
    return getApplicableParams(ParamsBase::GetTypeFromTag(tag));
}

//! General function for window-specific dirty bit setting.
//! Useful when the state of a Params has changed and some window(s) will need to be redrawn.
//! Turns on or off the specified dirty bit in all of the windows where the
//! specified Params is used.
//! Optionally requests a refresh in those windows.
//! \param[in] Params* : Pointer to a Params instance.
//! \param[in] DirtyBitType bittype : Dirty bit that is being set
//! \param[in] bit : Indicates whether it is being set dirty (true, default) or clean.
//! \param[in] bool refresh : Indicates whether a refresh is also requested; true by default.
void setVizDirty(Params* p, DirtyBitType bittype, bool bit = true, bool refresh = true);

//! Static method that enables use of a manipulator with a Mouse Mode. 
//! \param[in] const std::string Tag associated with Params class that owns the manipulator
//! \param[in] int Manipulator type.  Valid types are 1 (3d axis aligned), 2 (2D) and 3 (3D Rotated)
//! \param[in] const char* Name of the mouse mode that will be displayed in GUI
//! \param[in] const char* const xpmIcon[] An xpm bitmap that will be displayed in the GUI, defaults to no icon.
static int RegisterMouseMode(const std::string paramsTag, int manipType, const char* name, const char* const xpmIcon[]=0);

ifndef DOXYGEN_SKIP_THIS

//Following methods are not usually needed for extensibility:
~VizWinMgr();
static VizWinMgr* getInstance() {
    if (!theVizWinMgr)
        theVizWinMgr = new VizWinMgr();
    return theVizWinMgr;
}
static DvrParams* getActiveDvrParams(){
    return((DvrParams*)Params::GetParamsInstance(Params::_dvrParamsTag,getInstance()->activeViz,-1));
}
static IsolineParams* getActiveIsolineParams(){
    return ((IsolineParams*)Params::GetParamsInstance(IsolineParams::_isolineParamsTag,getInstance()->activeViz,-1));}
static ProbeParams* getActiveProbeParams(){
    return ((ProbeParams*)Params::GetParamsInstance(Params::_probeParamsTag,getInstance()->activeViz,-1));}
static TwoDDataParams* getActiveTwoDDataParams(){
    return ((TwoDDataParams*)Params::GetParamsInstance(Params::_twoDDataParamsTag,getInstance()->activeViz,-1));}
static TwoDImageParams* getActiveTwoDImageParams(){
    return ((TwoDImageParams*)Params::GetParamsInstance(Params::_twoDImageParamsTag,getInstance()->activeViz,-1));}
static RegionParams* getActiveRegionParams(){
    return (getInstance()->getRegionParams(getInstance()->activeViz));
}
static FlowParams* getActiveFlowParams(){
    return ((FlowParams*)Params::GetParamsInstance(Params::_flowParamsTag,getInstance()->activeViz,-1));}
static ViewpointParams* getActiveVPParams(){
    return (getInstance()->getViewpointParams(getInstance()->activeViz));
}
static AnimationParams* getActiveAnimationParams(){
    return (getInstance()->getAnimationParams(getInstance()->activeViz));
}
void forceFidelityUpdate();
void createAllDefaultParams();
void RegisterMouseModes();

//Respond to end:
void closeEvent();
void vizAboutToDisappear(int i); 

//Public Inlines:
//Respond to user events,
//Make sure this state tracks actual window state.
void minimize(int i) {
    isMin[i] = true;
    isMax[i] = false;
}
void maximize(int i) {
    isMin[i] = false;
    isMax[i] = true;

}
void normalize(int i) {
    isMin[i] = false;
    isMax[i] = false;
}
//method to launch a viz window, returns vizNum
//Default values create a new vis use whatever available number.
//If usenum is >= 0 it relaunches a previously used visualizer.
//If usenum is < 0 and newNum is >=0, it creates a new visualizer
//at position "newNum"
int launchVisualizer(int usenum = -1, const char* name = "", int newNum = -1);

void nameChanged(QString& name, int num);

int getNumVisualizers(); 
TabManager* getTabManager() { return tabManager;}

//activeViz is -1 if none is active, otherwise is no. of active viz win.
int getActiveViz() {return activeViz;}
VizWin* getActiveVisualizer() {
    if(activeViz>=0)return vizWin[activeViz];
    else return 0;
}
//Method that is called when a window is made active:
void setActiveViz(int vizNum); 
//Obtain the parameters that currently apply in specified window:
ViewpointParams* getViewpointParams(int winNum);
RegionParams* getRegionParams(int winNum);
//For a renderer, there will only exist a local version.
// If instance is negative, return the current instance.

Params* getIsoParams(int winnum, int instance = -1){
    return Params::GetParamsInstance(Params::GetTypeFromTag(Params::_isoParamsTag),winnum, instance);
}
Params* getDvrParams(int winnum, int instance = -1){
    return Params::GetParamsInstance(Params::GetTypeFromTag(Params::_dvrParamsTag),winnum, instance);
}
ProbeParams* getProbeParams(int winNum, int instance = -1);
IsolineParams* getIsolineParams(int winNum, int instance = -1);
TwoDDataParams* getTwoDDataParams(int winNum, int instance = -1);
TwoDImageParams* getTwoDImageParams(int winNum, int instance = -1);

int getNumFlowInstances(int winnum){return Params::GetNumParamsInstances(Params::_flowParamsTag,winnum);}
int getNumProbeInstances(int winnum){return Params::GetNumParamsInstances(Params::_probeParamsTag,winnum);}
int getNumTwoDDataInstances(int winnum){return Params::GetNumParamsInstances(Params::_twoDDataParamsTag,winnum);}
int getNumTwoDImageInstances(int winnum){return Params::GetNumParamsInstances(Params::_twoDImageParamsTag,winnum);}
int getNumDvrInstances(int winnum){
    return Params::GetNumParamsInstances(Params::_dvrParamsTag, winnum);
}
int getNumIsoInstances(int winnum){
    return Params::GetNumParamsInstances(Params::_isoParamsTag, winnum);
}

void setCurrentInstanceIndex(int winnum, int inst, Params::ParamsBaseType t);

void appendInstance(int winnum, Params* p);

void insertInstance(int winnum, int posn, Params* p);


void removeInstance(int winnum, int instance, Params::ParamsBaseType t);
FlowParams* getFlowParams(int winNum, int instance = -1);
AnimationParams* getAnimationParams(int winNum);

RegionEventRouter* getRegionRouter();
AnimationEventRouter* getAnimationRouter(); 
ProbeEventRouter* getProbeRouter();
TwoDDataEventRouter* getTwoDDataRouter(); 
TwoDImageEventRouter* getTwoDImageRouter();
ViewpointEventRouter* getViewpointRouter();
FlowEventRouter* getFlowRouter();


//Make all the params for the current window update their tabs:
void updateActiveParams();

//set/get Data describing window states
VizWin* getVizWin(int i) {return vizWin[i];}


void setVizWinName(int winNum, QString& qs);
QString& getVizWinName(int winNum) {return vizName[winNum];}
bool isMinimized(int winNum) {return isMin[winNum];}
bool isMaximized(int winNum) {return isMax[winNum];}


void setViewpointParams(int winNum, ViewpointParams* p){setParams(winNum, (Params*)p, Params::GetTypeFromTag(Params::_viewpointParamsTag));}
void setRegionParams(int winNum, RegionParams* p){setParams(winNum, (Params*)p, Params::GetTypeFromTag(Params::_regionParamsTag));}
void setAnimationParams(int winNum, AnimationParams* p){setParams(winNum, (Params*)p, Params::GetTypeFromTag(Params::_animationParamsTag));}
void replaceGlobalParams(Params* p, ParamsBase::ParamsBaseType t);
void createDefaultParams(int winnum);
Params* getCorrespondingLocalParams(Params* p) {
    return getLocalParams(p->GetParamsBaseTypeId());
}

void setSelectionMode( int mode);
//Direct access to actual params object:
ViewpointParams* getRealVPParams(int win) {
    if (!vizWin[win]) return 0;
    Params* p = Params::GetParamsInstance(Params::_viewpointParamsTag,win,-1);
    if (p->isLocal()) return (ViewpointParams*)p;
    return (ViewpointParams*)Params::GetDefaultParams(Params::_viewpointParamsTag);
}
Trackball* getGlobalTrackball() {return globalTrackball;}

//Force all renderers to re-obtain render data
void refreshRenderData();
//
//Disable all renderers that use specified variables
void disableRenderers(const vector<string>& vars2D, const vector<string>& vars3D);
//Disable all renderers 
void disableAllRenderers();
//Following methods notify all params that are associated with a
//specific window.
//Set the dirty bits in all the visualizers that use a
//region parameter setting
//

void setRegionDirty(RegionParams* p){setVizDirty(p, RegionBit, true);}

//AnimationParams, force a render.  Probe & Volume renderer need to rebuild
//
void setAnimationDirty(AnimationParams* ap){setVizDirty(ap, AnimationBit, true);}
//Force rerender of window using a flowParams, or region params..
//
void refreshFlow(FlowParams*);
void refreshViewpoint(ViewpointParams* vParams);
void refreshRegion(RegionParams* rParams);
void refreshProbe(ProbeParams* pParams);
void refreshIsoline(IsolineParams* pParams);
void refreshTwoDData(TwoDDataParams* pParams);
void refreshTwoDImage(TwoDImageParams* pParams);

//Force dvr renderer to get latest CLUT
//
void setClutDirty(RenderParams* p);

//Force all text-renderers to refresh, e.g. if background color changes
void refreshText();


//Force dvr renderers to get latest DataRange
//
void setDatarangeDirty(RenderParams* p); 
void setFlowGraphicsDirty(FlowParams* p);
void setFlowDataDirty(FlowParams* p, bool doInterrupt = true);
void setFlowDisplayListDirty(FlowParams* p);
bool flowDataIsDirty(FlowParams* p);

//Force reconstructing of all elevation grids
void setAllTwoDElevDirty();
//Tell the animationController that the frame counter has changed 
//for all the associated windows.
//
void animationParamsChanged(AnimationParams* );
//Reset the near/far distances for all the windows that
//share a viewpoint, based on region in specified regionparams
//
void resetViews(ViewpointParams* vp);
//Set the viewer coords changed flag in all the visualizers
//that use these vp params:
void setViewerCoordsChanged(ViewpointParams* vp);
//Change to play state for the specified renderers:
//
void startPlay(AnimationParams* aParams);
//Tell all parameter panels to reinitialize (based on change of 
//Metadata).  If the parameter is true, we can override the panels' 
//previous state
//
void reinitializeParams(bool doOverride);
//Reinitialize params and tabs for 
//change in active variables
//
void reinitializeVariables();
//reset to starting state
//
void restartParams();

//Make each window use its viewpoint params
void initViews();

//Methods to handle save/restore of session state
ParamNode* buildNode();
bool elementStartHandler(ExpatParseMgr*, int /* depth*/ , std::string& /*tag*/, const char ** /*attribs*/);
bool elementEndHandler(ExpatParseMgr*, int /*depth*/ , std::string& /*tag*/);
//this tag needs to be visible in session class
static const string _visualizersTag;



void setInteractiveNavigating(int level);
bool findCoincident2DSurface(int vizwin,  float coordinate, TwoDParams *tParams);
void stopFlowIntegration();

public slots:
//arrange the viz windows:
void cascade();
void coverRight();
void fitSpace();
//Slots to handle home viewpoint (dispatch to proper panel)
void home();
void sethome();
//Slot that responds when user requests to activate a window:
void winActivated(int);
void killViz(int viznum);
//Slots that set viewpoint:
void viewAll();
void viewRegion();
void alignView(int axis);
//The vizWinMgr has to dispatch signals from gui’s to the appropriate parameter panels

void setVpLocalGlobal(int val);
void setRgLocalGlobal(int val);
void setAnimationLocalGlobal(int val);

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);

protected:
static const string _vizUseLatLonAttr;
static const string _vizTimeAnnotColorAttr;
static const string _vizTimeAnnotTextSizeAttr;
static const string _vizTimeAnnotTypeAttr;
static const string _vizTimeAnnotCoordsAttr;
static const string _vizElevGridEnabledAttr;
static const string _vizElevGridColorAttr;
static const string _vizElevGridRefinementAttr;
static const string _vizWinTag;
static const string _vizWinNameAttr;
static const string _vizBgColorAttr;
static const string _vizRegionColorAttr;
static const string _vizSubregionColorAttr;
static const string _vizColorbarBackgroundColorAttr;
static const string _vizAxisPositionAttr;
static const string _vizAxisOriginAttr;
static const string _vizAxisAnnotationEnabledAttr;
static const string _vizMinTicAttr;
static const string _vizMaxTicAttr;
static const string _vizTicLengthAttr;
static const string _vizTicDirAttr;
static const string _vizNumTicsAttr;
static const string _vizAxisColorAttr;
static const string _vizTicWidthAttr;
static const string _vizLabelHeightAttr;
static const string _vizLabelDigitsAttr;
static const string _vizColorbarDigitsAttr;
static const string _vizColorbarFontsizeAttr;
static const string _vizColorbarLLPositionAttr;//obsolete with 2.4
static const string _vizColorbarURPositionAttr;//obsolete with 2.4
static const string _vizColorbarSizeAttr; //new with 2.4
static const string _vizColorbarLLXTag;//new with 2.4
static const string _vizColorbarLLYTag;//new with 2.4
static const string _vizColorbarTitlesTag; //new with 2.4
static const string _vizColorbarNumTicsAttr;
static const string _vizAxisArrowsEnabledAttr;
static const string _vizColorbarEnabledAttr; //obsolete with 2.4
static const string _vizColorbarEnabledTag; //new with 2.4
static const string _vizColorbarParamsNameAttr; //obsolete with 2.4
static const string _vizRegionFrameEnabledAttr;
static const string _vizSubregionFrameEnabledAttr;
static const string _visualizerNumAttr;
static const string _vizElevGridDisplacementAttr;
static const string _vizElevGridInvertedAttr;
static const string _vizElevGridRotationAttr;
static const string _vizElevGridTexturedAttr;
static const string _vizElevGridTextureNameAttr;

RegionParams* getRealRegionParams(int win) {
    if (!vizWin[win]) return 0;
    Params* p = Params::GetParamsInstance(Params::_regionParamsTag,win,-1);
    if (p->isLocal()) return (RegionParams*)p;
    return (RegionParams*)Params::GetDefaultParams(Params::_regionParamsTag);
}
AnimationParams* getRealAnimationParams(int win) {
    if (!vizWin[win]) return 0;
    Params* p = Params::GetParamsInstance(Params::_animationParamsTag,win,-1);
    if (p->isLocal()) return (AnimationParams*)p;
    return (AnimationParams*)Params::GetDefaultParams(Params::_animationParamsTag);
}
ViewpointParams* getGlobalVPParams(){return (ViewpointParams*)(Params::GetDefaultParams(Params::_viewpointParamsTag));}
RegionParams* getGlobalRegionParams(){
    return (RegionParams*)(Params::GetDefaultParams(Params::_regionParamsTag));
}
AnimationParams* getGlobalAnimationParams(){return (AnimationParams*)(Params::GetDefaultParams(Params::_animationParamsTag));}

static Params::ParamsBaseType RegisterEventRouter(const std::string tag, EventRouter* router);
static std::map<ParamsBase::ParamsBaseType, EventRouter*> eventRouterMap;

// Method that returns the current params instance that applies in the current
// active visualizer if it is local.  
Params* getLocalParams(Params::ParamsBaseType t);

static void setGlobalParams(Params* p, ParamsBase::ParamsBaseType t);

static VizWinMgr* theVizWinMgr;
VizWinMgr ();

VizWin* vizWin[MAXVIZWINS];
QMdiSubWindow* vizMdiWin[MAXVIZWINS];

QString vizName[MAXVIZWINS];
bool isMax[MAXVIZWINS];
bool isMin[MAXVIZWINS];

//Remember the activation order:
int activationOrder[MAXVIZWINS];
int activationCount;
int getLastActive(){
    int mx = -1; int mj = -1;
    for (int j = 0; j< MAXVIZWINS; j++){
        if (vizWin[j] && activationOrder[j]>mx){ 
            mx = activationOrder[j];
            mj = j;
        }
    }
    return mj;
}
Trackball* globalTrackball;



MainForm* myMainWindow;
static TabManager* tabManager;

int activeViz;
vector<int> parsingInstance;
int parsingVizNum, parsingDvrInstance, parsingIsoInstance,parsingFlowInstance, parsingProbeInstance,parsingTwoDDataInstance,parsingTwoDImageInstance;

QMdiArea* myMDIArea;
FlowTab* myFlowTab;

int     benchmark;
QTimer *benchmarkTimer;
bool spinAnimate;

endif //DOXYGEN_SKIP_THIS

};
};

endif // VIZWINMGR_H