TEveWindow.h

Go to the documentation of this file.

// @(#)root/eve:$Id$
// Author: Matevz Tadel 2007
 
/*************************************************************************
 * Copyright (C) 1995-2007, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
#ifndef ROOT_TEveWindow
#define ROOT_TEveWindow
 
#include "TEveElement.h"
 
#include "TGFrame.h"
#include "TContextMenu.h"
 
class TEveWindow;
class TEveWindowSlot;
class TEveWindowFrame;
class TEveWindowMainFrame;
class TEveWindowPack;
class TEveWindowTab;
class TEveContextMenu;
 
class TGButton;
class TGSplitButton;
class TGTextButton;
 
class TGPack;
class TGTab;
 
//==============================================================================
// TEveCompositeFrame
//==============================================================================
 
class TEveCompositeFrame : public TGCompositeFrame
{
   friend class TEveWindow;
   friend class TEveWindowManager;
 
public:
   typedef TGFrame* (*IconBarCreator_foo)(TEveCompositeFrame*, TGCompositeFrame*, Int_t);
 
private:
   TEveCompositeFrame(const TEveCompositeFrame&);            // Not implemented
   TEveCompositeFrame& operator=(const TEveCompositeFrame&); // Not implemented
 
   static IconBarCreator_foo fgIconBarCreator;
   static UInt_t             fgTopFrameHeight;
   static UInt_t             fgMiniBarHeight;
   static Bool_t             fgAllowTopFrameCollapse;
 
protected:
   TGCompositeFrame  *fTopFrame;
   TGTextButton      *fToggleBar;
   TGTextButton      *fTitleBar;
   TGFrame           *fIconBar;
   TGLayoutHints     *fEveWindowLH;
 
   TGFrame           *fMiniBar;
 
   TEveElement       *fEveParent;
   TEveWindow        *fEveWindow;
 
   Bool_t             fShowInSync;
 
   static TEveContextMenu *fgCtxMenu;
   static const TString    fgkEmptyFrameName;
 
   static TList           *fgFrameList;
 
public:
   TEveCompositeFrame(TGCompositeFrame* gui_parent, TEveWindow* eve_parent);
   virtual ~TEveCompositeFrame();
 
   virtual void WindowNameChanged(const TString& name);
 
   virtual void Destroy() = 0;
 
   virtual void        AcquireEveWindow(TEveWindow* ew);
   virtual TEveWindow* RelinquishEveWindow(Bool_t reparent=kTRUE);
 
   TEveWindow* GetEveWindow() const { return fEveWindow; }
   TEveWindow* GetEveParentAsWindow() const;
 
   virtual void SetCurrent(Bool_t curr);
   virtual void SetShowTitleBar(Bool_t show);
   virtual void HideAllDecorations();
   virtual void ShowNormalDecorations();
 
   void ActionPressed();
   void FlipTitleBarState();
   void TitleBarClicked();
 
   static void SetupFrameMarkup(IconBarCreator_foo creator,
                                UInt_t top_frame_height   = 14,
                                UInt_t mini_bar_height    = 4,
                                Bool_t allow_top_collapse = kTRUE);
 
   ClassDef(TEveCompositeFrame, 0); // Composite frame containing eve-window-controls and eve-windows.
};
 
 
//==============================================================================
// TEveCompositeFrameInMainFrame
//==============================================================================
 
class TEveCompositeFrameInMainFrame : public TEveCompositeFrame
{
private:
   TEveCompositeFrameInMainFrame(const TEveCompositeFrameInMainFrame&);            // Not implemented
   TEveCompositeFrameInMainFrame& operator=(const TEveCompositeFrameInMainFrame&); // Not implemented
 
protected:
   TGMainFrame      *fMainFrame;
   TEveWindow       *fOriginalSlot;
   TEveWindow       *fOriginalContainer;
 
public:
   TEveCompositeFrameInMainFrame(TGCompositeFrame* parent, TEveWindow* eve_parent,
                                 TGMainFrame* mf);
   virtual ~TEveCompositeFrameInMainFrame();
 
   virtual void WindowNameChanged(const TString& name);
 
   virtual void Destroy();
 
   void SetOriginalSlotAndContainer(TEveWindow* slot, TEveWindow* container);
 
   void SomeWindowClosed(TEveWindow* w);
   void MainFrameClosed();
 
   TEveWindow* GetOriginalSlot() const { return fOriginalSlot; }
   TEveWindow* GetOriginalContainer() const { return fOriginalContainer; }
 
   ClassDef(TEveCompositeFrameInMainFrame, 0); // Eve-composite-frame that is contained in one tab of a TGTab.
};
 
 
//==============================================================================
// TEveCompositeFrameInPack
//==============================================================================
 
class TEveCompositeFrameInPack : public TEveCompositeFrame
{
private:
   TEveCompositeFrameInPack(const TEveCompositeFrameInPack&);            // Not implemented
   TEveCompositeFrameInPack& operator=(const TEveCompositeFrameInPack&); // Not implemented
 
protected:
   TGPack        *fPack;
 
public:
   TEveCompositeFrameInPack(TGCompositeFrame* parent, TEveWindow* eve_parent,
                            TGPack* pack);
   virtual ~TEveCompositeFrameInPack();
 
   virtual void Destroy();
 
   ClassDef(TEveCompositeFrameInPack, 0); // Eve-composite-frame that is contained in a TGPack.
};
 
 
//==============================================================================
// TEveCompositeFrameInTab
//==============================================================================
 
class TEveCompositeFrameInTab : public TEveCompositeFrame
{
private:
   TEveCompositeFrameInTab(const TEveCompositeFrameInTab&);            // Not implemented
   TEveCompositeFrameInTab& operator=(const TEveCompositeFrameInTab&); // Not implemented
 
protected:
   TGTab            *fTab;
   TGCompositeFrame *fParentInTab;
 
   Int_t FindTabIndex();
 
public:
   TEveCompositeFrameInTab(TGCompositeFrame* parent, TEveWindow* eve_parent,
                           TGTab* tab);
   virtual ~TEveCompositeFrameInTab();
 
   virtual void WindowNameChanged(const TString& name);
 
   virtual void Destroy();
 
   virtual void SetCurrent(Bool_t curr);
 
   ClassDef(TEveCompositeFrameInTab, 0); // Eve-composite-frame that is contained in one tab of a TGTab.
};
 
 
//==============================================================================
//==============================================================================
// TEveWindow classes
//==============================================================================
//==============================================================================
 
 
//==============================================================================
// TEveWindow
//==============================================================================
 
class TEveWindow : public TEveElementList
{
   friend class TEveWindowManager;
 
private:
   TEveWindow(const TEveWindow&);            // Not implemented
   TEveWindow& operator=(const TEveWindow&); // Not implemented
 
protected:
   TEveCompositeFrame  *fEveFrame;
   Bool_t               fShowTitleBar;
 
   virtual void SetCurrent(Bool_t curr);
 
   static UInt_t        fgMainFrameDefWidth;
   static UInt_t        fgMainFrameDefHeight;
 
   static Pixel_t       fgCurrentBackgroundColor;
   static Pixel_t       fgMiniBarBackgroundColor;
 
   virtual void PreDeleteElement();
 
public:
   TEveWindow(const char* n="TEveWindow", const char* t="");
   virtual ~TEveWindow();
 
   virtual void NameTitleChanged();
 
   virtual TGFrame*        GetGUIFrame() = 0;
   virtual void            PreUndock();
   virtual void            PostDock();
 
   virtual Bool_t          CanMakeNewSlots() const { return kFALSE; }
   virtual TEveWindowSlot* NewSlot() { return 0; }
 
   void PopulateEmptyFrame(TEveCompositeFrame* ef);
 
   void SwapWindow(TEveWindow* w);
   void SwapWindowWithCurrent();        // *MENU*
 
   void UndockWindow();                 // *MENU*
   void UndockWindowDestroySlot();      // *MENU*
 
   void ReplaceWindow(TEveWindow* w);
 
   virtual void DestroyWindow();        // *MENU*
   virtual void DestroyWindowAndSlot(); // *MENU*
 
   TEveCompositeFrame* GetEveFrame()  { return fEveFrame; }
   void                ClearEveFrame();
 
   void   FlipShowTitleBar()      { SetShowTitleBar(!fShowTitleBar); }
   Bool_t GetShowTitleBar() const { return fShowTitleBar; }
   void   SetShowTitleBar(Bool_t x);
 
   Bool_t IsCurrent() const;
   void   MakeCurrent();
 
 
   Bool_t IsAncestorOf(TEveWindow* win);
 
   void   TitleBarClicked();
 
 
   // Static helper functions for common window management scenarios.
 
   static TEveWindowSlot* CreateDefaultWindowSlot();
   static TEveWindowSlot* CreateWindowMainFrame(TEveWindow* eve_parent=0);
   static TEveWindowSlot* CreateWindowInTab(TGTab* tab, TEveWindow* eve_parent=0);
 
   static void            SwapWindows(TEveWindow* w1, TEveWindow* w2);
 
   // Access to static data-members.
 
   static UInt_t  GetMainFrameDefWidth();
   static UInt_t  GetMainFrameDefHeight();
   static void    SetMainFrameDefWidth (UInt_t x);
   static void    SetMainFrameDefHeight(UInt_t x);
 
   static Pixel_t GetCurrentBackgroundColor();
   static Pixel_t GetMiniBarBackgroundColor();
   static void    SetCurrentBackgroundColor(Pixel_t p);
   static void    SetMiniBarBackgroundColor(Pixel_t p);
 
   ClassDef(TEveWindow, 0); // Abstract base-class for eve-windows.
};
 
 
//==============================================================================
// TEveWindowSlot
//==============================================================================
 
class TEveWindowSlot : public TEveWindow
{
private:
   TEveWindowSlot(const TEveWindowSlot&);            // Not implemented
   TEveWindowSlot& operator=(const TEveWindowSlot&); // Not implemented
 
protected:
   TGTextButton      *fEmptyButt;
   TGCompositeFrame  *fEmbedBuffer;
 
   virtual void SetCurrent(Bool_t curr);
 
public:
   TEveWindowSlot(const char* n="TEveWindowSlot", const char* t="");
   virtual ~TEveWindowSlot();
 
   virtual TGFrame* GetGUIFrame();
 
   TEveWindowPack*   MakePack(); // *MENU*
   TEveWindowTab*    MakeTab();  // *MENU*
 
   TEveWindowFrame*  MakeFrame(TGFrame* frame=0);
 
   TGCompositeFrame* StartEmbedding();
   TEveWindowFrame*  StopEmbedding(const char* name=0);
 
   ClassDef(TEveWindowSlot, 0); // An unoccupied eve-window slot.
};
 
 
//==============================================================================
// TEveWindowFrame
//==============================================================================
 
class TEveWindowFrame : public TEveWindow
{
private:
   TEveWindowFrame(const TEveWindowFrame&);            // Not implemented
   TEveWindowFrame& operator=(const TEveWindowFrame&); // Not implemented
 
protected:
   TGFrame         *fGUIFrame;
 
public:
   TEveWindowFrame(TGFrame* frame, const char* n="TEveWindowFrame", const char* t="");
   virtual ~TEveWindowFrame();
 
   virtual TGFrame* GetGUIFrame() { return fGUIFrame; }
 
   TGCompositeFrame* GetGUICompositeFrame();
 
   ClassDef(TEveWindowFrame, 0); // Eve-window containing any TGFrame.
};
 
 
//==============================================================================
// TEveWindowPack
//==============================================================================
 
class TEveWindowPack : public TEveWindow
{
private:
   TEveWindowPack(const TEveWindowPack&);            // Not implemented
   TEveWindowPack& operator=(const TEveWindowPack&); // Not implemented
 
protected:
   TGPack          *fPack;
 
public:
   TEveWindowPack(TGPack* p, const char* n="TEveWindowPack", const char* t="");
   virtual ~TEveWindowPack();
 
   virtual TGFrame*        GetGUIFrame();
 
   virtual Bool_t          CanMakeNewSlots() const { return kTRUE; }
   virtual TEveWindowSlot* NewSlotWithWeight(Float_t w);
   virtual TEveWindowSlot* NewSlot(); // *MENU*
 
   void FlipOrientation(); // *MENU*
   void SetVertical(Bool_t x=kTRUE);
   void SetHorizontal() { SetVertical(kFALSE); }
 
   void EqualizeFrames();  // *MENU*
 
   TGPack* GetPack() const { return fPack; }
 
   ClassDef(TEveWindowPack, 0); // Eve-window containing a TGPack.
};
 
 
//==============================================================================
// TEveWindowTab
//==============================================================================
 
class TEveWindowTab : public TEveWindow
{
private:
   TEveWindowTab(const TEveWindowTab&);            // Not implemented
   TEveWindowTab& operator=(const TEveWindowTab&); // Not implemented
 
protected:
   TGTab           *fTab;
 
public:
   TEveWindowTab(TGTab* tab, const char* n="TEveWindowTab", const char* t="");
   virtual ~TEveWindowTab();
 
   virtual TGFrame*        GetGUIFrame();
 
   virtual Bool_t          CanMakeNewSlots() const { return kTRUE; }
   virtual TEveWindowSlot* NewSlot(); // *MENU*
 
   TGTab* GetTab() const { return fTab; }
 
   ClassDef(TEveWindowTab, 0); // Eve-window containing a TGTab.
};
 
 
//==============================================================================
//==============================================================================
// Helper classes
//==============================================================================
//==============================================================================
 
 
//==============================================================================
// TEveContextMenu
//==============================================================================
 
class TEveContextMenu : public TContextMenu
{
public:
   TEveContextMenu(const char *name, const char *title = "Eve context menu");
 
   void SetupAndPopup(TGWindow* button, TObject* obj);
 
   ClassDef(TEveContextMenu, 0) // Specialization of TContextMenu for Eve.
};
 
#endif