文章标题

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 activestatic 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 shadersbool 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 instancestatic 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 instancestatic 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 instancestatic 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 instanceParams* 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 instancesstatic 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 indexstatic 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 indexint 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 currentParams* 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 currentParams* 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 statesVizWin* 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 datavoid refreshRenderData();////Disable all renderers that use specified variablesvoid 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 changesvoid 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 gridsvoid 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 paramsvoid initViews();//Methods to handle save/restore of session stateParamNode* 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 classstatic 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