FWGUIManager.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef Fireworks_Core_FWGUIManager_h
#define Fireworks_Core_FWGUIManager_h
//
// Package:     Core
// Class  :     FWGUIManager
//
//
// Original Author:  Chris Jones
//         Created:  Mon Feb 11 10:52:24 EST 2008
//
 
// system include files
#include <map>
#include <boost/function.hpp>
#include <sigc++/sigc++.h>
#include "Rtypes.h"
#include "GuiTypes.h"
#include "TGFileDialog.h"
#include <memory>
 
// user include files
#include "Fireworks/Core/interface/FWConfigurable.h"
#include "DataFormats/Provenance/interface/EventID.h"
 
// forward declarations
class TGPictureButton;
class TGComboBox;
class TGTextButton;
class TGTextEntry;
class TGFrame;
class TGSplitFrame;
class TGVerticalFrame;
class TGMainFrame;
class TGPack;
class TGCompositeFrame;
class TGCheckButton;
class TGPopupMenu;
 
class TGListTreeItem;
class TGListTree;
class TEveElementList;
class TEveElement;
class TEveWindowPack;
class TEveWindowSlot;
class TEveCompositeFrame;
class TEveWindow;
 
class CmsShowMainFrame;
class FWEventItem;
class FWViewBase;
class FWGUISubviewArea;
 
class FWSelectionManager;
class FWSummaryManager;
class FWDetailViewManager;
class FWInvMassDialog;
class CSGAction;
class CSGContinuousAction;
 
class FWGUIEventDataAdder;
 
class CmsShowTaskExecutor;
 
class FWNavigatorBase;
 
class FWModelContextMenuHandler;
class FWViewContextMenuHandlerBase;
class TGWindow;
 
namespace edm {
  class EventBase;
}
 
class CmsShowEDI;
class CmsShowModelPopup;
class CmsShowViewPopup;
class FWViewManagerManager;
class CmsShowCommonPopup;
class CmsShowHelpPopup;
 
namespace fireworks {
  class Context;
}
 
class FWGUIManager : public FWConfigurable {
  // typedefs
public:
  typedef boost::function2<FWViewBase*, TEveWindowSlot*, const std::string&> ViewBuildFunctor;
  typedef std::map<std::string, ViewBuildFunctor> NameToViewBuilder;
 
private:
  typedef std::map<TEveWindow*, FWViewBase*> ViewMap_t;
  typedef ViewMap_t::iterator ViewMap_i;
 
public:
  FWGUIManager(fireworks::Context* ctx, const FWViewManagerManager* iVMMgr, FWNavigatorBase* navigator);
 
  ~FWGUIManager() override;
  void evePreTerminate();
 
  //configuration management interface
  void addTo(FWConfiguration&) const override;
  void setFrom(const FWConfiguration&) override;
  void setWindowInfoFrom(const FWConfiguration& iFrom, TGMainFrame* iFrame);
  void initEmpty();
 
  TGVerticalFrame* createList(TGCompositeFrame* p);
  void createViews(TEveWindowSlot* slot);
  void exportImageOfMainView();
  void exportImagesOfAllViews();
  void exportAllViews(const std::string& format, int height);
 
  void createEDIFrame();
  void showEDIFrame(int iInfoToShow = -1);
 
  void open3DRegion();
  void showCommonPopup();
 
  void createModelPopup();
  void showModelPopup();
  void showViewPopup();
  void popupViewClosed();
 
  void showSelectedModelContextMenu(Int_t iGlobalX, Int_t iGlobalY, FWViewContextMenuHandlerBase* iHandler);
 
  void showInvMassDialog();
  //   void showGeometryBrowser();
 
  // help
  void createHelpPopup();
  void createShortcutPopup();
  void createHelpGLPopup();
 
  // ---------- const member functions ---------------------
  //      bool waitingForUserAction() const;
  CSGContinuousAction* playEventsAction();
  CSGContinuousAction* playEventsBackwardsAction();
  CSGContinuousAction* loopAction();
 
  // ---------- static member functions --------------------
  static FWGUIManager* getGUIManager();
  fireworks::Context* getContext() { return m_context; }
  static TGFrame* makeGUIsubview(TEveCompositeFrame* cp, TGCompositeFrame* parent, Int_t height);
 
  // ---------- member functions ---------------------------
  //have to use the portable syntax else the reflex code will not build
  void registerViewBuilder(const std::string& iName, ViewBuildFunctor& iBuilder);
 
  ViewMap_i createView(const std::string& iName, TEveWindowSlot* slot = nullptr);
  void newViewSlot(const std::string& iName);
 
  void connectSubviewAreaSignals(FWGUISubviewArea*);
  void enableActions(bool enable = true);
  void disablePrevious();
  void disableNext();
  void setPlayMode(bool);
  void updateStatus(const char* status);
  void clearStatus();
  void eventChangedCallback();
 
  CSGAction* getAction(const std::string name);
 
  void addData();
  void titleChanged(const char* title);
 
  void openEveBrowserForDebugging() const;
  void setDelayBetweenEvents(Float_t);
 
  void showEventFilterGUI();
  void filterButtonClicked();
  void setFilterButtonText(const char* txt);
  void setFilterButtonIcon(int);
  void updateEventFilterEnable(bool);
 
  void runIdChanged();
  void lumiIdChanged();
  void eventIdChanged();
  void checkSubviewAreaIconState(TEveWindow*);
  void subviewIsBeingDestroyed(FWGUISubviewArea*);
  void subviewDestroy(FWGUISubviewArea*);  // timeout funct
  void subviewDestroyAll();
  void subviewInfoSelected(FWGUISubviewArea*);
  void subviewInfoUnselected(FWGUISubviewArea*);
  void subviewSwapped(FWGUISubviewArea*);
 
  CmsShowMainFrame* getMainFrame() const { return m_cmsShowMainFrame; }
  const edm::EventBase* getCurrentEvent() const;
 
  void resetWMOffsets();
 
  // signals
  sigc::signal<void> filterButtonClicked_;
  sigc::signal<void, const TGWindow*> showEventFilterGUI_;
  sigc::signal<void, const std::string&> writeToConfigurationFile_;
  sigc::signal<void, const std::string&> writePartialToConfigurationFile_;
  sigc::signal<void, const std::string&> loadFromConfigurationFile_;
  sigc::signal<void, const std::string&> loadPartialFromConfigurationFile_;
  sigc::signal<void, edm::RunNumber_t, edm::LuminosityBlockNumber_t, edm::EventNumber_t> changedEventId_;
  sigc::signal<void> goingToQuit_;
  sigc::signal<void> writeToPresentConfigurationFile_;
 
  sigc::signal<void> changedRunEntry_;
  sigc::signal<void> changedEventEntry_;
  sigc::signal<void, Float_t> changedDelayBetweenEvents_;
 
private:
  FWGUIManager(const FWGUIManager&) = delete;                   // stop default
  const FWGUIManager& operator=(const FWGUIManager&) = delete;  // stop default
 
  TEveWindow* getSwapCandidate();
 
  void newItem(const FWEventItem*);
 
  bool promptForConfigurationFile(std::string& result, enum EFileDialogMode mode);
  void promptForSaveConfigurationFile();
  void promptForPartialSaveConfigurationFile();
  void promptForLoadConfigurationFile();
  void promptForPartialLoadConfigurationFile();
  void savePartialToConfigurationFile();
 
  void delaySliderChanged(Int_t);
 
  void finishUpColorChange();
 
  void setViewPopup(TEveWindow*);
 
  void measureWMOffsets();
 
  // ---------- static member data --------------------------------
 
  static FWGUIManager* m_guiManager;
 
  // ---------- member data --------------------------------
  fireworks::Context* m_context;
 
  FWSummaryManager* m_summaryManager;
 
  //views are owned by their individual view managers
  FWDetailViewManager* m_detailViewManager;
  const FWViewManagerManager* m_viewManagerManager;
  FWModelContextMenuHandler* m_contextMenuHandler;
  FWNavigatorBase* m_navigator;
  CmsShowMainFrame* m_cmsShowMainFrame;
 
  TGPopupMenu* m_fileMenu;
  FWGUIEventDataAdder* m_dataAdder;
 
  // event data inspector
  CmsShowEDI* m_ediFrame;
  CmsShowModelPopup* m_modelPopup;
  CmsShowViewPopup* m_viewPopup;
  CmsShowCommonPopup* m_commonPopup;
  FWInvMassDialog* m_invMassDialog;
 
  // help
  CmsShowHelpPopup* m_helpPopup;
  CmsShowHelpPopup* m_shortcutPopup;
  CmsShowHelpPopup* m_helpGLPopup;
 
  // subview memebers
  mutable ViewMap_t m_viewMap;
  NameToViewBuilder m_nameToViewBuilder;
 
  TEveWindowPack* m_viewPrimPack;
  TEveWindowPack* m_viewSecPack;
 
  sigc::connection m_modelChangeConn;
 
  std::unique_ptr<CmsShowTaskExecutor> m_tasks;
  std::vector<FWViewBase*> m_regionViews;
  int m_WMOffsetX, m_WMOffsetY, m_WMDecorH;
};
 
#endif