eventrouter.h

Go to the documentation of this file.

//************************************************************************
//                                                                      *
//           Copyright (C)  2006                                        *
//     University Corporation for Atmospheric Research                  *
//           All Rights Reserved                                        *
//                                                                      *
//************************************************************************/
//                  
//  File:       eventrouter.h
//
//  Author:     Alan Norton
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       May 2006
//
//  Description:  Definition of EventRouter class   
//      This (pure virtual) class manages communication between
//      gui elements, visualizers, and params.

#ifndef EVENTROUTER_H
#define EVENTROUTER_H
#include "assert.h"
#include "params.h"
#include "vizwinmgr.h"
#include "vizwin.h"
#include "histo.h"
#include "mapperfunction.h"
#include "panelcommand.h"
#include <qobject.h>

class QWidget;
class QComboBox;
class QButtonGroup;
class QGroupBox;
class QHBoxLayout;
#ifdef WIN32
//Annoying unreferenced formal parameter warning
#pragma warning( disable : 4100)
#endif

namespace VAPoR{
    class PanelCommand;
    class Histo;

//
class EventRouter
{
    
public:
    
    virtual void hookUpTab() = 0;

    virtual void updateTab() = 0;

    virtual void updateUrgentTabState() {return;}

    virtual void makeCurrent(Params* prevParams, Params* newParams, bool newWin, int instance = -1, bool reEnable = false) = 0;
    
    virtual void performGuiChangeInstance(int newCurrent, bool undoredo=true);

    virtual void performGuiNewInstance();

    virtual void performGuiDeleteInstance();

    virtual void performGuiCopyInstance();

    virtual void performGuiCopyInstanceToViz(int vizwin);

    void guiSetTextChanged(bool on) {textChangedFlag = on;}

    virtual void confirmText(bool /*render*/) = 0;

    virtual void reinitTab(bool doOverride) = 0;

    virtual void guiSetEnabled(bool On, int instance, bool undoredo=false  ) {assert(0);}

    virtual void captureMouseUp() {assert(0);}

    virtual void captureMouseDown(int mouseNum) {assert(0);}

#ifndef DOXYGEN_SKIP_THIS
    EventRouter() {
        textChangedFlag = 0; savedCommand = 0;
        fidelityDefaultChanged = true;
        histogramList = 0;
        numHistograms = 0;
        isoShown = colorMapShown = opacityMapShown = texShown = false;
    }
    virtual ~EventRouter() {
        for (int i = 0; i<numHistograms; i++) 
            if (histogramList[i]) delete histogramList[i];
        if (histogramList) delete [] histogramList;
    }
    //Methods to change instances (for undo/redo).
    //Only used by renderer params
    //Insert an instance (where there was none).
    //if instPosition is at end, appends to current instances
    //void insertCurrentInstance(Params* newParams, int instPosition);
    //Remove specified instance, disable it if necessary.
    void removeRendererInstance(int winnum, int instance);
    void newRendererInstance(int winnum);
    void copyRendererInstance(int toWinnum, RenderParams* rParams);
    void changeRendererInstance(int winnum, int newInstance);
    
    Params::ParamsBaseType getParamsBaseType() {return myParamsBaseType;}
    
    //Make the tab refresh after a scrolling operation.
    //Helpful on windows only, and only some tabs
    virtual void refreshTab() {}

    //UpdateRenderer ignores renderParams argument and uses the
    //params associated with the instance if it is nonnegative
    virtual void updateRenderer(RenderParams* , bool /*wasEnabled*/, bool /*newWindow*/){assert(0);}
    
    //make sure the params cleanly detaches from gui, to
    //handle possible connections from editors, frames, etc.
    virtual void cleanParams(Params*) {}
    
    virtual void sessionLoadTF(QString* ) {assert(0);}
    //Clone the params and any other related classes.
    //Default just clones the params:
    virtual Params* deepCopy(Params* p) {return (p->deepCopy());}
    
    virtual void guiSetLocal(Params* p, bool lg){
        if (textChangedFlag) confirmText(false);
    
        PanelCommand* cmd;
        Params* localParams = VizWinMgr::getInstance()->getCorrespondingLocalParams(p);
        if (lg){
            cmd = PanelCommand::captureStart(localParams,  "set Global to Local");
        }
        else cmd = PanelCommand::captureStart(localParams,  "set Local to Global");
        localParams->setLocal(lg);
        int winnum = localParams->getVizNum();
        GLWindow* glwin = VizWinMgr::getInstance()->getVizWin(winnum)->getGLWindow();
        glwin->setActiveParams(Params::GetCurrentParamsInstance(localParams->GetParamsBaseTypeId(),winnum),localParams->GetParamsBaseTypeId());
        PanelCommand::captureEnd(cmd, localParams);
        updateTab();
    }
    
    virtual void setFidelityDefaultChangedFlag(bool val){fidelityDefaultChanged = val;}
    //Methods to support maintaining a list of histograms
    //in each router (at least those with a TFE)

    virtual Histo* getHistogram(RenderParams*, bool mustGet, bool isIsoWin = false);
    virtual void refreshHistogram(RenderParams* , int sesVarNum, const float drange[2]);
    virtual void refresh2DHistogram(RenderParams* , int sesVarNum, const float drange[2]);

    //For render params, setEditorDirty uses the current instance if Params
    //arg is null
    virtual void setEditorDirty(RenderParams*){}
    virtual void updateMapBounds(RenderParams*) {assert (0);}
    virtual void updateClut(RenderParams*){assert(0);}
    
//Methods for loading/saving transfer functions:
void saveTF(RenderParams* rParams);
void fileSaveTF(RenderParams* rParams);
void loadInstalledTF(RenderParams* rParams, int varnum);
void loadTF(RenderParams* rParams, int varnum);

void fileLoadTF(RenderParams* rParams, int varnum, const char* startPath, bool savePath);
    //Workaround Darwin/Qt bug.  Note these are public:
    bool isoShown, colorMapShown, opacityMapShown, texShown;

public slots:

    virtual void guiStartChangeMapFcn(QString) { assert(0); }
    virtual void guiEndChangeMapFcn() { assert(0); }
    
    
protected:
    bool textChangedFlag;
    QButtonGroup* fidelityButtons;
    //for subclasses with a box:
    void setIgnoreBoxSliderEvents(bool val) {ignoreBoxSliderEvents = val;}
    //Use fidelity setting and preferences to calculate LOD and Refinement
    //To support Fidelity, each eventRouter class must perform the following:
    //Implement fidelityBox and fidelityLayout as in dvr.ui
    // set fidelityButtons = 0 in constructor
    // implement slots guiSetFidelity(int) and guiSetFidelityDefault()
    // connect fidelityDefaultButton clicked() to guiSetFidelityDefault
    // in updateTab, check for fidelityUpdateChanged, if so, call setupFidelity
    //   then connect fidelityButtons to guiSetFidelity, then call updateFidelity()
    // in reinitTab, call SetFidelityLevel, then connect fidelityButtons to guiSetFidelity
    // in guiSetCompRatios, call SetIgnoreFidelity(true)
    // in guiSetRefinement, call SetIgnoreFidelity(true)
    // in guiSetFidelityDefault, call setFidelityDefault

    //Build the vectors of reflevels and lods
    virtual int orderLODRefs(int dim);
    //Determine the default lod and ref level for a specified region size
    virtual void calcLODRefDefault(int dim, float regMBs, int* lod, int* reflevel);
    virtual void updateFidelity(QGroupBox*, RenderParams* rp, QComboBox* lodCombo, QComboBox* refinementCombo);

    void setupFidelity(int dim, QHBoxLayout* fidelityLayout,
        QGroupBox* fidelityBox, RenderParams* dParams, bool useDefault=false);
    void setFidelityDefault(int dim, RenderParams* dParams);
    bool ignoreBoxSliderEvents;
    //for subclasses with a datarange:
    virtual void setDatarangeDirty(RenderParams* ) {assert(0);}
    //Routers with histograms keep an array, one for each variable,
    // or variable combination
    Histo** histogramList;
    int numHistograms; //how large is histo array..
    //There is one tabbed panel for each class of Params
    
    Params::ParamsBaseType myParamsBaseType;
    
    PanelCommand* savedCommand;
    
    vector<QAction*>* makeWebHelpActions(const char* text[], const char* urls[]);
    virtual QAction* getWebHelpAction(int n) {return (*myWebHelpActions)[n];}
    vector<QAction*>* myWebHelpActions;

    vector<int> fidelityRefinements;
    vector<int> fidelityLODs;
    bool fidelityDefaultChanged;
    
#endif //DOXYGEN_SKIP_THIS
};
};
#endif // EVENTROUTER_H