ROOT logo
// @(#)root/gui:$Id: TGFrame.h 38064 2011-02-14 13:54:40Z bellenot $
// Author: Fons Rademakers   03/01/98

/*************************************************************************
 * Copyright (C) 1995-2000, 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_TGFrame
#define ROOT_TGFrame


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGFrame, TGCompositeFrame, TGVerticalFrame, TGHorizontalFrame,       //
// TGMainFrame, TGTransientFrame and TGGroupFrame                       //
//                                                                      //
// This header contains all different Frame classes.                    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#ifndef ROOT_TGWindow
#include "TGWindow.h"
#endif
#ifndef ROOT_TQObject
#include "TQObject.h"
#endif
#ifndef ROOT_TGDimension
#include "TGDimension.h"
#endif
#ifndef ROOT_TGGC
#include "TGGC.h"
#endif
#ifndef ROOT_TGFont
#include "TGFont.h"
#endif
#ifndef ROOT_TGLayout
#include "TGLayout.h"
#endif
#ifndef ROOT_TGString
#include "TGString.h"
#endif
#ifndef ROOT_TList
#include "TList.h"
#endif

class TGResourcePool;
class TGTextButton;
class TGVFileSplitter;
class TDNDData;

//---- frame states

enum EFrameState {
   kIsVisible  = BIT(0),
   kIsMapped   = kIsVisible,
   kIsArranged = BIT(1)
};

//---- frame cleanup
enum EFrameCleanup {
   kNoCleanup    = 0,
   kLocalCleanup = 1,
   kDeepCleanup  = -1
};

//---- types of frames (and borders)

enum EFrameType {
   kChildFrame      = 0,
   kMainFrame       = BIT(0),
   kVerticalFrame   = BIT(1),
   kHorizontalFrame = BIT(2),
   kSunkenFrame     = BIT(3),
   kRaisedFrame     = BIT(4),
   kDoubleBorder    = BIT(5),
   kFitWidth        = BIT(6),
   kFixedWidth      = BIT(7),
   kFitHeight       = BIT(8),
   kFixedHeight     = BIT(9),
   kFixedSize       = (kFixedWidth | kFixedHeight),
   kOwnBackground   = BIT(10),
   kTransientFrame  = BIT(11),
   kTempFrame       = BIT(12),
   kMdiMainFrame    = BIT(13),
   kMdiFrame        = BIT(14)
};

//---- MWM hints stuff

enum EMWMHints {
   // functions
   kMWMFuncAll      = BIT(0),
   kMWMFuncResize   = BIT(1),
   kMWMFuncMove     = BIT(2),
   kMWMFuncMinimize = BIT(3),
   kMWMFuncMaximize = BIT(4),
   kMWMFuncClose    = BIT(5),

   // input mode
   kMWMInputModeless                = 0,
   kMWMInputPrimaryApplicationModal = 1,
   kMWMInputSystemModal             = 2,
   kMWMInputFullApplicationModal    = 3,

   // decorations
   kMWMDecorAll      = BIT(0),
   kMWMDecorBorder   = BIT(1),
   kMWMDecorResizeH  = BIT(2),
   kMWMDecorTitle    = BIT(3),
   kMWMDecorMenu     = BIT(4),
   kMWMDecorMinimize = BIT(5),
   kMWMDecorMaximize = BIT(6)
};

//---- drag and drop

enum EDNDFlags {
   kIsDNDSource = BIT(0),
   kIsDNDTarget = BIT(1)
};



//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGFrame                                                              //
//                                                                      //
// This class subclasses TGWindow, used as base class for some simple   //
// widgets (buttons, labels, etc.).                                     //
// It provides:                                                         //
//  - position & dimension fields                                       //
//  - an 'options' attribute (see constant above)                       //
//  - a generic event handler                                           //
//  - a generic layout mechanism                                        //
//  - a generic border                                                  //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TGFrame : public TGWindow, public TQObject {

protected:
   enum { kDeleteWindowCalled = BIT(15) };

   Int_t    fX;             // frame x position
   Int_t    fY;             // frame y position
   UInt_t   fWidth;         // frame width
   UInt_t   fHeight;        // frame height
   UInt_t   fMinWidth;      // minimal frame width
   UInt_t   fMinHeight;     // minimal frame height
   UInt_t   fMaxWidth;      // maximal frame width
   UInt_t   fMaxHeight;     // maximal frame height
   Int_t    fBorderWidth;   // frame border width
   UInt_t   fOptions;       // frame options
   Pixel_t  fBackground;    // frame background color
   UInt_t   fEventMask;     // currenty active event mask
   Int_t    fDNDState;      // EDNDFlags
   TGFrameElement *fFE;     // pointer to frame element

   static Bool_t      fgInit;
   static Pixel_t     fgDefaultFrameBackground;
   static Pixel_t     fgDefaultSelectedBackground;
   static Pixel_t     fgWhitePixel;
   static Pixel_t     fgBlackPixel;
   static const TGGC *fgBlackGC;
   static const TGGC *fgWhiteGC;
   static const TGGC *fgHilightGC;
   static const TGGC *fgShadowGC;
   static const TGGC *fgBckgndGC;
   static Time_t      fgLastClick;
   static UInt_t      fgLastButton;
   static Int_t       fgDbx, fgDby;
   static Window_t    fgDbw;
   static UInt_t      fgUserColor;

   static Time_t      GetLastClick();

   virtual void  *GetSender() { return this; }  //used to set gTQSender
   virtual void   Draw3dRectangle(UInt_t type, Int_t x, Int_t y,
                                  UInt_t w, UInt_t h);
   virtual void   DoRedraw();

   const TGResourcePool *GetResourcePool() const
      { return fClient->GetResourcePool(); }

   TString GetOptionString() const;                //used in SavePrimitive()

   // some protected methods use in gui builder
   virtual void StartGuiBuilding(Bool_t on = kTRUE);

private:
   TGFrame(const TGFrame&);             // not implemented
   TGFrame& operator=(const TGFrame&);  // not implemented

public:
   // Default colors and graphics contexts
   static Pixel_t     GetDefaultFrameBackground();
   static Pixel_t     GetDefaultSelectedBackground();
   static Pixel_t     GetWhitePixel();
   static Pixel_t     GetBlackPixel();
   static const TGGC &GetBlackGC();
   static const TGGC &GetWhiteGC();
   static const TGGC &GetHilightGC();
   static const TGGC &GetShadowGC();
   static const TGGC &GetBckgndGC();

   TGFrame(const TGWindow *p = 0, UInt_t w = 1, UInt_t h = 1,
           UInt_t options = 0, Pixel_t back = GetDefaultFrameBackground());
   TGFrame(TGClient *c, Window_t id, const TGWindow *parent = 0);
   virtual ~TGFrame();

   virtual void DeleteWindow();
   virtual void ReallyDelete() { delete this; }

   UInt_t GetEventMask() const { return fEventMask; }
   void   AddInput(UInt_t emask);
   void   RemoveInput(UInt_t emask);

   virtual Bool_t HandleEvent(Event_t *event);
   virtual Bool_t HandleConfigureNotify(Event_t *event);
   virtual Bool_t HandleButton(Event_t *) { return kFALSE; }
   virtual Bool_t HandleDoubleClick(Event_t *) { return kFALSE; }
   virtual Bool_t HandleCrossing(Event_t *) { return kFALSE; }
   virtual Bool_t HandleMotion(Event_t *) { return kFALSE; }
   virtual Bool_t HandleKey(Event_t *) { return kFALSE; }
   virtual Bool_t HandleFocusChange(Event_t *) { return kFALSE; }
   virtual Bool_t HandleClientMessage(Event_t *event);
   virtual Bool_t HandleSelection(Event_t *) { return kFALSE; }
   virtual Bool_t HandleSelectionRequest(Event_t *) { return kFALSE; }
   virtual Bool_t HandleSelectionClear(Event_t *) { return kFALSE; }
   virtual Bool_t HandleColormapChange(Event_t *) { return kFALSE; }
   virtual Bool_t HandleDragEnter(TGFrame *) { return kFALSE; }
   virtual Bool_t HandleDragLeave(TGFrame *) { return kFALSE; }
   virtual Bool_t HandleDragMotion(TGFrame *) { return kFALSE; }
   virtual Bool_t HandleDragDrop(TGFrame *, Int_t /*x*/, Int_t /*y*/, TGLayoutHints*)
                     { return kFALSE; }
   virtual void   ProcessedConfigure(Event_t *event)
                     { Emit("ProcessedConfigure(Event_t*)", (Long_t)event); } //*SIGNAL*
   virtual void   ProcessedEvent(Event_t *event)
                     { Emit("ProcessedEvent(Event_t*)", (Long_t)event); } //*SIGNAL*

   virtual void   SendMessage(const TGWindow *w, Long_t msg, Long_t parm1, Long_t parm2);
   virtual Bool_t ProcessMessage(Long_t, Long_t, Long_t) { return kFALSE; }

   virtual TGDimension GetDefaultSize() const ;
   virtual void    Move(Int_t x, Int_t y);
   virtual void    Resize(UInt_t w = 0, UInt_t h = 0);
   virtual void    Resize(TGDimension size);
   virtual void    MoveResize(Int_t x, Int_t y, UInt_t w = 0, UInt_t h = 0);
   virtual UInt_t  GetDefaultWidth() const { return GetDefaultSize().fWidth; }
   virtual UInt_t  GetDefaultHeight() const { return GetDefaultSize().fHeight; }
   virtual Pixel_t GetBackground() const { return fBackground; }
   virtual void    ChangeBackground(Pixel_t back);
   virtual void    SetBackgroundColor(Pixel_t back);
   virtual Pixel_t GetForeground() const;
   virtual void    SetForegroundColor(Pixel_t /*fore*/) { }
   virtual UInt_t  GetOptions() const { return fOptions; }
   virtual void    ChangeOptions(UInt_t options);
   virtual void    Layout() { }
   virtual void    MapSubwindows() { }  // Simple frames do not have subwindows
                                        // Redefine this in TGCompositeFrame!
   virtual void    ReparentWindow(const TGWindow *p, Int_t x = 0, Int_t y = 0)
                     { TGWindow::ReparentWindow(p, x, y); Move(x, y); }
   virtual void    MapWindow() { TGWindow::MapWindow(); if (fFE) fFE->fState |= kIsVisible; }
   virtual void    MapRaised() { TGWindow::MapRaised(); if (fFE) fFE->fState |= kIsVisible; }
   virtual void    UnmapWindow() { TGWindow::UnmapWindow(); if (fFE) fFE->fState &= ~kIsVisible; }

   virtual void    DrawBorder();
   virtual void    DrawCopy(Handle_t /*id*/, Int_t /*x*/, Int_t /*y*/) { }
   virtual void    Activate(Bool_t) { }
   virtual Bool_t  IsActive() const { return kFALSE; }
   virtual Bool_t  IsComposite() const { return kFALSE; }
   virtual Bool_t  IsEditable() const { return kFALSE; }
   virtual void    SetEditable(Bool_t) {}
   virtual void    SetLayoutBroken(Bool_t = kTRUE) {}
   virtual Bool_t  IsLayoutBroken() const { return kFALSE; }
   virtual void    SetCleanup(Int_t = kLocalCleanup) { /* backward compatebility */ }

   virtual void    SetDragType(Int_t type);
   virtual void    SetDropType(Int_t type);
   virtual Int_t   GetDragType() const;
   virtual Int_t   GetDropType() const;

   UInt_t GetWidth() const { return fWidth; }
   UInt_t GetHeight() const { return fHeight; }
   UInt_t GetMinWidth() const { return fMinWidth; }
   UInt_t GetMinHeight() const { return fMinHeight; }
   UInt_t GetMaxWidth() const { return fMaxWidth; }
   UInt_t GetMaxHeight() const { return fMaxHeight; }
   TGDimension GetSize() const { return TGDimension(fWidth, fHeight); }
   Int_t  GetX() const { return fX; }
   Int_t  GetY() const { return fY; }
   Int_t  GetBorderWidth() const { return fBorderWidth; }

   TGFrameElement *GetFrameElement() const { return fFE; }
   void SetFrameElement(TGFrameElement *fe) { fFE = fe; }

   Bool_t Contains(Int_t x, Int_t y) const
      { return ((x >= 0) && (x < (Int_t)fWidth) && (y >= 0) && (y < (Int_t)fHeight)); }
   virtual TGFrame *GetFrameFromPoint(Int_t x, Int_t y)
      { return (Contains(x, y) ? this : 0); }

   // Modifiers (without graphic update)
   virtual void SetX(Int_t x) { fX = x; }
   virtual void SetY(Int_t y) { fY = y; }
   virtual void SetWidth(UInt_t w) { fWidth = w; }
   virtual void SetHeight(UInt_t h) { fHeight = h; }
   virtual void SetMinWidth(UInt_t w) { fMinWidth = w; }
   virtual void SetMinHeight(UInt_t h) { fMinHeight = h; }
   virtual void SetMaxWidth(UInt_t w) { fMaxWidth = w; }
   virtual void SetMaxHeight(UInt_t h) { fMaxHeight = h; }
   virtual void SetSize(const TGDimension &s) { fWidth = s.fWidth; fHeight = s.fHeight; }

   // Printing and saving
   virtual void Print(Option_t *option="") const;
   void SaveUserColor(ostream &out, Option_t *);
   virtual void SavePrimitive(ostream &out, Option_t *option = "");

   // dummy to remove from context menu
   virtual void        Delete(Option_t * /*option*/ ="") { }
   virtual TObject    *DrawClone(Option_t * /*option */="") const { return 0; }
   virtual void        DrawClass() const { }
   virtual void        Dump() const { }
   virtual void        Inspect() const { }
   virtual void        SetDrawOption(Option_t * /*option*/="") { }

   // drag and drop...
   void                SetDNDSource(Bool_t onoff)
                       { if (onoff) fDNDState |= kIsDNDSource; else fDNDState &= ~kIsDNDSource; }
   void                SetDNDTarget(Bool_t onoff)
                       { if (onoff) fDNDState |= kIsDNDTarget; else fDNDState &= ~kIsDNDTarget; }
   Bool_t              IsDNDSource() const { return fDNDState & kIsDNDSource; }
   Bool_t              IsDNDTarget() const { return fDNDState & kIsDNDTarget; }

   virtual TDNDData   *GetDNDData(Atom_t /*dataType*/) { return 0; }
   virtual Bool_t      HandleDNDDrop(TDNDData * /*DNDData*/) { return kFALSE; }
   virtual Atom_t      HandleDNDPosition(Int_t /*x*/, Int_t /*y*/, Atom_t /*action*/,
                                         Int_t /*xroot*/, Int_t /*yroot*/) { return kNone; }
   virtual Atom_t      HandleDNDEnter(Atom_t * /*typelist*/) { return kNone; }
   virtual Bool_t      HandleDNDLeave() { return kFALSE; }
   virtual Bool_t      HandleDNDFinished() { return kFALSE; }

   ClassDef(TGFrame,0)  // Base class for simple widgets (button, etc.)
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGCompositeFrame                                                     //
//                                                                      //
// This class is the base class for composite widgets                   //
// (menu bars, list boxes, etc.).                                       //
//                                                                      //
// It provides:                                                         //
//  - a layout manager                                                  //
//  - a frame container (TList *)                                       //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TGCompositeFrame : public TGFrame {


protected:
   TGLayoutManager *fLayoutManager;   // layout manager
   TList           *fList;            // container of frame elements
   Bool_t           fLayoutBroken;    // no layout manager is used
   Int_t            fMustCleanup;     // cleanup mode (see EFrameCleanup)
   Bool_t           fMapSubwindows;   // kTRUE - map subwindows

   static TGLayoutHints *fgDefaultHints;  // default hints used by AddFrame()

private:
   TGCompositeFrame(const TGCompositeFrame&);            // not implemented
   TGCompositeFrame& operator=(const TGCompositeFrame&); // not implemented

public:
   TGCompositeFrame(const TGWindow *p = 0, UInt_t w = 1, UInt_t h = 1,
                    UInt_t options = 0,
                    Pixel_t back = GetDefaultFrameBackground());
   TGCompositeFrame(TGClient *c, Window_t id, const TGWindow *parent = 0);
   virtual ~TGCompositeFrame();

   virtual TList *GetList() const { return fList; }

   virtual UInt_t GetDefaultWidth() const
                     { return GetDefaultSize().fWidth; }
   virtual UInt_t GetDefaultHeight() const
                     { return GetDefaultSize().fHeight; }
   virtual TGDimension GetDefaultSize() const
                     { return (IsLayoutBroken() ? TGDimension(fWidth, fHeight) :
                               fLayoutManager->GetDefaultSize()); }
   virtual TGFrame *GetFrameFromPoint(Int_t x, Int_t y);
   virtual Bool_t TranslateCoordinates(TGFrame *child, Int_t x, Int_t y,
                                       Int_t &fx, Int_t &fy);
   virtual void   MapSubwindows();
   virtual void   Layout();
   virtual Bool_t HandleButton(Event_t *) { return kFALSE; }
   virtual Bool_t HandleDoubleClick(Event_t *) { return kFALSE; }
   virtual Bool_t HandleCrossing(Event_t *) { return kFALSE; }
   virtual Bool_t HandleMotion(Event_t *) { return kFALSE; }
   virtual Bool_t HandleKey(Event_t *) { return kFALSE; }
   virtual Bool_t HandleFocusChange(Event_t *) { return kFALSE; }
   virtual Bool_t HandleSelection(Event_t *) { return kFALSE; }
   virtual Bool_t HandleDragEnter(TGFrame *);
   virtual Bool_t HandleDragLeave(TGFrame *);
   virtual Bool_t HandleDragMotion(TGFrame *);
   virtual Bool_t HandleDragDrop(TGFrame *frame, Int_t x, Int_t y, TGLayoutHints *lo);
   virtual void   ChangeOptions(UInt_t options);
   virtual Bool_t ProcessMessage(Long_t, Long_t, Long_t) { return kFALSE; }

   virtual TGLayoutManager *GetLayoutManager() const { return fLayoutManager; }
   virtual void SetLayoutManager(TGLayoutManager *l);

   virtual TGFrameElement* FindFrameElement(TGFrame *f) const;

   virtual void   AddFrame(TGFrame *f, TGLayoutHints *l = 0);
   virtual void   RemoveAll();
   virtual void   RemoveFrame(TGFrame *f);
   virtual void   ShowFrame(TGFrame *f);
   virtual void   HideFrame(TGFrame *f);
   Int_t          GetState(TGFrame *f) const;
   Bool_t         IsVisible(TGFrame *f) const;
   Bool_t         IsVisible(TGFrameElement *ptr) const { return (ptr->fState & kIsVisible); }
   Bool_t         IsArranged(TGFrame *f) const;
   Bool_t         IsArranged(TGFrameElement *ptr) const { return (ptr->fState & kIsArranged); }
   Bool_t         IsComposite() const { return kTRUE; }
   virtual Bool_t IsEditable() const;
   virtual void   SetEditable(Bool_t on = kTRUE);
   virtual void   SetLayoutBroken(Bool_t on = kTRUE);
   virtual Bool_t IsLayoutBroken() const
                  { return fLayoutBroken || !fLayoutManager; }
   virtual void   SetEditDisabled(UInt_t on = 1);
   virtual void   SetCleanup(Int_t mode = kLocalCleanup);
   virtual Int_t  MustCleanup() const { return fMustCleanup; }
   virtual void   Cleanup();
   virtual void   SetMapSubwindows(Bool_t on) {  fMapSubwindows = on; }
   virtual Bool_t IsMapSubwindows() const { return fMapSubwindows; }

   virtual void   Print(Option_t *option="") const;
   virtual void   ChangeSubframesBackground(Pixel_t back);
   virtual void   SavePrimitive(ostream &out, Option_t *option = "");
   virtual void   SavePrimitiveSubframes(ostream &out, Option_t *option = "");

   ClassDef(TGCompositeFrame,0)  // Base class for composite widgets (menubars, etc.)
};


class TGVerticalFrame : public TGCompositeFrame {
public:
   TGVerticalFrame(const TGWindow *p = 0, UInt_t w = 1, UInt_t h = 1,
                   UInt_t options = kChildFrame,
                   Pixel_t back = GetDefaultFrameBackground()) :
      TGCompositeFrame(p, w, h, options | kVerticalFrame, back) { SetWindowName(); }
   virtual void SavePrimitive(ostream &out, Option_t *option = "");

   ClassDef(TGVerticalFrame,0)  // Composite frame with vertical child layout
};

class TGHorizontalFrame : public TGCompositeFrame {
public:
   TGHorizontalFrame(const TGWindow *p = 0, UInt_t w = 1, UInt_t h = 1,
                     UInt_t options = kChildFrame,
                     Pixel_t back = GetDefaultFrameBackground()) :
      TGCompositeFrame(p, w, h, options | kHorizontalFrame, back) { SetWindowName(); }
   virtual void SavePrimitive(ostream &out, Option_t *option = "");

   ClassDef(TGHorizontalFrame,0)  // Composite frame with horizontal child layout
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGMainFrame                                                          //
//                                                                      //
// This class defines top level windows that interact with the system   //
// Window Manager (WM or MWM for Motif Window Manager).                 //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TGMainFrame : public TGCompositeFrame {

protected:
   enum { kDontCallClose = BIT(14) };

   // mapping between key and window
   class TGMapKey : public TObject {
   private:
      TGMapKey(const TGMapKey&);
      TGMapKey& operator=(const TGMapKey&);
   public:
      UInt_t     fKeyCode;
      TGWindow  *fWindow;
      TGMapKey(UInt_t keycode, TGWindow *w): fKeyCode(keycode), fWindow(w) { }
   };

   Atom_t       *fDNDTypeList;  // handles DND types
   TList        *fBindList;     // list with key bindings
   TString       fWindowName;   // window name
   TString       fIconName;     // icon name
   TString       fIconPixmap;   // icon pixmap name
   TString       fClassName;    // WM class name
   TString       fResourceName; // WM resource name
   UInt_t        fMWMValue;     // MWM decoration hints
   UInt_t        fMWMFuncs;     // MWM functions
   UInt_t        fMWMInput;     // MWM input modes
   Int_t         fWMX;          // WM x position
   Int_t         fWMY;          // WM y position
   UInt_t        fWMWidth;      // WM width
   UInt_t        fWMHeight;     // WM height
   UInt_t        fWMMinWidth;   // WM min width
   UInt_t        fWMMinHeight;  // WM min height
   UInt_t        fWMMaxWidth;   // WM max width
   UInt_t        fWMMaxHeight;  // WM max height
   UInt_t        fWMWidthInc;   // WM width increments
   UInt_t        fWMHeightInc;  // WM height increments
   EInitialState fWMInitState;  // WM initial state

   TString GetMWMvalueString() const;  //used in SaveSource()
   TString GetMWMfuncString() const;   //used in SaveSource()
   TString GetMWMinpString() const;    //used in SaveSource()

private:
   TGMainFrame(const TGMainFrame&);             // not implemented
   TGMainFrame& operator=(const TGMainFrame&);  // not implemented

public:
   TGMainFrame(const TGWindow *p = 0, UInt_t w = 1, UInt_t h = 1,
               UInt_t options = kVerticalFrame);
   virtual ~TGMainFrame();

   virtual Bool_t HandleKey(Event_t *event);
   virtual Bool_t HandleClientMessage(Event_t *event);
   virtual Bool_t HandleSelection(Event_t *event);
   virtual Bool_t HandleSelectionRequest(Event_t *event);
   virtual Bool_t HandleButton(Event_t *event);
   virtual Bool_t HandleMotion(Event_t *event);
   virtual Bool_t SaveFrameAsCodeOrImage();
   virtual void   SendCloseMessage();
   virtual void   CloseWindow();   //*SIGNAL*

   void DontCallClose();
   void SetWindowName(const char *name = 0);
   void SetIconName(const char *name);
   const TGPicture *SetIconPixmap(const char *iconName);
   void SetIconPixmap(char **xpm_array);
   void SetClassHints(const char *className, const char *resourceName);
   void SetMWMHints(UInt_t value, UInt_t funcs, UInt_t input);
   void SetWMPosition(Int_t x, Int_t y);
   void SetWMSize(UInt_t w, UInt_t h);
   void SetWMSizeHints(UInt_t wmin, UInt_t hmin, UInt_t wmax, UInt_t hmax,
                       UInt_t winc, UInt_t hinc);
   void SetWMState(EInitialState state);

   virtual Bool_t BindKey(const TGWindow *w, Int_t keycode, Int_t modifier) const;
   virtual void   RemoveBind(const TGWindow *w, Int_t keycode, Int_t modifier) const;
   TList *GetBindList() const { return fBindList; }

   const char *GetWindowName() const { return fWindowName; }
   const char *GetIconName() const { return fIconName; }
   const char *GetIconPixmap() const { return fIconPixmap; }
   void GetClassHints(const char *&className, const char *&resourceName) const
      { className = fClassName.Data(); resourceName = fResourceName.Data(); }
   void GetMWMHints(UInt_t &value, UInt_t &funcs, UInt_t &input) const
      { value = fMWMValue; funcs = fMWMFuncs; input = fMWMInput; }
   void GetWMPosition(Int_t &x, Int_t &y) const { x = fWMX; y = fWMY; }
   void GetWMSize(UInt_t &w, UInt_t &h) const { w = fWMWidth; h = fWMHeight; }
   void GetWMSizeHints(UInt_t &wmin, UInt_t &hmin, UInt_t &wmax, UInt_t &hmax,
                       UInt_t &winc, UInt_t &hinc) const
      { wmin = fWMMinWidth; hmin = fWMMinHeight; wmax = fWMMaxWidth;
        hmax = fWMMaxHeight; winc = fWMWidthInc; hinc = fWMHeightInc; }
   EInitialState GetWMState() const { return fWMInitState; }

   virtual void SavePrimitive(ostream &out, Option_t *option = "");
   virtual void SaveSource(const char *filename = "Rootappl.C", Option_t *option = ""); // *MENU*icon=bld_save.png*

   ClassDef(TGMainFrame,0)  // Top level window frame
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGTransientFrame                                                     //
//                                                                      //
// This class defines transient windows that typically are used for     //
// dialogs.                                                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TGTransientFrame : public TGMainFrame {

protected:
   const TGWindow   *fMain;  // window over which to popup dialog

private:
   TGTransientFrame(const TGTransientFrame&);             // not implemented
   TGTransientFrame& operator=(const TGTransientFrame&);  // not implemented

public:
   TGTransientFrame(const TGWindow *p = 0, const TGWindow *main = 0, UInt_t w = 1, UInt_t h = 1,
                    UInt_t options = kVerticalFrame);

   enum EPlacement { kCenter, kLeft, kRight, kTop, kBottom, kTopLeft, kTopRight,
                     kBottomLeft, kBottomRight };
   virtual void    CenterOnParent(Bool_t croot = kTRUE, EPlacement pos = kCenter);
   const TGWindow *GetMain() const { return fMain; }
   virtual void    SavePrimitive(ostream &out, Option_t *option = "");
   virtual void    SaveSource(const char *filename = "Rootdlog.C", Option_t *option = ""); // *MENU*icon=bld_save.png*

   ClassDef(TGTransientFrame,0)  // Frame for dialog (transient) windows
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGGroupFrame                                                         //
//                                                                      //
// A group frame is a composite frame with a border and a title.        //
// It is typically used to group a number of logically related widgets  //
// visually together.                                                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TGGroupFrame : public TGCompositeFrame {

protected:
   TGString      *fText;         // title text
   FontStruct_t   fFontStruct;   // title fontstruct
   GContext_t     fNormGC;       // title graphics context
   Int_t          fTitlePos;     // *OPTION={GetMethod="GetTitlePos";SetMethod="SetTitlePos";Items=(-1="Left",0="Center",1="Right")}*
   Bool_t         fHasOwnFont;   // kTRUE - font defined locally,  kFALSE - globally

   virtual void DoRedraw();

   static const TGFont *fgDefaultFont;
   static const TGGC   *fgDefaultGC;

private:
   TGGroupFrame(const TGGroupFrame&);              // not implemented
   TGGroupFrame& operator=(const TGGroupFrame&);   // not implemented

public:
   enum ETitlePos { kLeft = -1, kCenter = 0, kRight = 1 };

   static FontStruct_t  GetDefaultFontStruct();
   static const TGGC   &GetDefaultGC();

   TGGroupFrame(const TGWindow *p, TGString *title,
                UInt_t options = kVerticalFrame,
                GContext_t norm = GetDefaultGC()(),
                FontStruct_t font = GetDefaultFontStruct(),
                Pixel_t back = GetDefaultFrameBackground());
   TGGroupFrame(const TGWindow *p = 0, const char *title = 0,
                UInt_t options = kVerticalFrame,
                GContext_t norm = GetDefaultGC()(),
                FontStruct_t font = GetDefaultFontStruct(),
                Pixel_t back = GetDefaultFrameBackground());
   virtual ~TGGroupFrame();

   virtual TGDimension GetDefaultSize() const;
   virtual void  DrawBorder();
   virtual void  SetTitle(TGString *title);
   virtual void  SetTitle(const char *title);
   virtual void  Rename(const char *title)  { SetTitle(title); } //*MENU*icon=bld_rename.png*
           Int_t GetTitlePos() const { return fTitlePos; }
   virtual void  SetTitlePos(ETitlePos pos = kLeft) { fTitlePos = pos; }  //*SUBMENU*
   virtual void  SetTextColor(Pixel_t color, Bool_t local = kTRUE);
   virtual void  SetTextFont(const char *fontName, Bool_t local = kTRUE);
   virtual void  SetTextFont(FontStruct_t font, Bool_t local = kTRUE);
   GContext_t GetNormGC() const { return fNormGC; }
   FontStruct_t GetFontStruct() const { return fFontStruct; }

   virtual const char *GetTitle() const { return fText->GetString(); }
   Bool_t HasOwnFont() const;

   virtual void  SavePrimitive(ostream &out, Option_t *option = "");

   ClassDef(TGGroupFrame,0)  // A composite frame with border and title
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGHeaderFrame                                                        //
//                                                                      //
// Horizontal Frame used to contain header buttons and splitters        //
// in a list view. Used to have resizable column headers.               //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TGHeaderFrame : public TGHorizontalFrame {
private:
   TGHeaderFrame(const TGHeaderFrame&); // Not implemented
   TGHeaderFrame& operator=(const TGHeaderFrame&); // Not implemented

protected:
   Int_t              fNColumns;     // number of columns
   TGTextButton     **fColHeader;    // column headers for in detailed mode
   TGVFileSplitter  **fSplitHeader;  // column splitters
   Cursor_t           fSplitCursor;  // split cursor;
   Bool_t             fOverSplitter; // Indicates if the cursor is over a splitter
   Int_t              fOverButton;   // Indicates over which button the mouse is
   Int_t              fLastButton;   // Indicates the last button clicked if any

public:
   TGHeaderFrame(const TGWindow *p = 0, UInt_t w = 1, UInt_t h = 1,
                 UInt_t options = kChildFrame,
                 Pixel_t back = GetDefaultFrameBackground());

   virtual Bool_t HandleButton(Event_t* event);
   virtual Bool_t HandleMotion(Event_t* event);
   virtual Bool_t HandleDoubleClick(Event_t *event);

   void SetColumnsInfo(Int_t nColumns, TGTextButton  **colHeader, TGVFileSplitter  **splitHeader);

   ClassDef(TGHeaderFrame,0)  // Header frame with buttons and splitters
};


#endif
 TGFrame.h:1
 TGFrame.h:2
 TGFrame.h:3
 TGFrame.h:4
 TGFrame.h:5
 TGFrame.h:6
 TGFrame.h:7
 TGFrame.h:8
 TGFrame.h:9
 TGFrame.h:10
 TGFrame.h:11
 TGFrame.h:12
 TGFrame.h:13
 TGFrame.h:14
 TGFrame.h:15
 TGFrame.h:16
 TGFrame.h:17
 TGFrame.h:18
 TGFrame.h:19
 TGFrame.h:20
 TGFrame.h:21
 TGFrame.h:22
 TGFrame.h:23
 TGFrame.h:24
 TGFrame.h:25
 TGFrame.h:26
 TGFrame.h:27
 TGFrame.h:28
 TGFrame.h:29
 TGFrame.h:30
 TGFrame.h:31
 TGFrame.h:32
 TGFrame.h:33
 TGFrame.h:34
 TGFrame.h:35
 TGFrame.h:36
 TGFrame.h:37
 TGFrame.h:38
 TGFrame.h:39
 TGFrame.h:40
 TGFrame.h:41
 TGFrame.h:42
 TGFrame.h:43
 TGFrame.h:44
 TGFrame.h:45
 TGFrame.h:46
 TGFrame.h:47
 TGFrame.h:48
 TGFrame.h:49
 TGFrame.h:50
 TGFrame.h:51
 TGFrame.h:52
 TGFrame.h:53
 TGFrame.h:54
 TGFrame.h:55
 TGFrame.h:56
 TGFrame.h:57
 TGFrame.h:58
 TGFrame.h:59
 TGFrame.h:60
 TGFrame.h:61
 TGFrame.h:62
 TGFrame.h:63
 TGFrame.h:64
 TGFrame.h:65
 TGFrame.h:66
 TGFrame.h:67
 TGFrame.h:68
 TGFrame.h:69
 TGFrame.h:70
 TGFrame.h:71
 TGFrame.h:72
 TGFrame.h:73
 TGFrame.h:74
 TGFrame.h:75
 TGFrame.h:76
 TGFrame.h:77
 TGFrame.h:78
 TGFrame.h:79
 TGFrame.h:80
 TGFrame.h:81
 TGFrame.h:82
 TGFrame.h:83
 TGFrame.h:84
 TGFrame.h:85
 TGFrame.h:86
 TGFrame.h:87
 TGFrame.h:88
 TGFrame.h:89
 TGFrame.h:90
 TGFrame.h:91
 TGFrame.h:92
 TGFrame.h:93
 TGFrame.h:94
 TGFrame.h:95
 TGFrame.h:96
 TGFrame.h:97
 TGFrame.h:98
 TGFrame.h:99
 TGFrame.h:100
 TGFrame.h:101
 TGFrame.h:102
 TGFrame.h:103
 TGFrame.h:104
 TGFrame.h:105
 TGFrame.h:106
 TGFrame.h:107
 TGFrame.h:108
 TGFrame.h:109
 TGFrame.h:110
 TGFrame.h:111
 TGFrame.h:112
 TGFrame.h:113
 TGFrame.h:114
 TGFrame.h:115
 TGFrame.h:116
 TGFrame.h:117
 TGFrame.h:118
 TGFrame.h:119
 TGFrame.h:120
 TGFrame.h:121
 TGFrame.h:122
 TGFrame.h:123
 TGFrame.h:124
 TGFrame.h:125
 TGFrame.h:126
 TGFrame.h:127
 TGFrame.h:128
 TGFrame.h:129
 TGFrame.h:130
 TGFrame.h:131
 TGFrame.h:132
 TGFrame.h:133
 TGFrame.h:134
 TGFrame.h:135
 TGFrame.h:136
 TGFrame.h:137
 TGFrame.h:138
 TGFrame.h:139
 TGFrame.h:140
 TGFrame.h:141
 TGFrame.h:142
 TGFrame.h:143
 TGFrame.h:144
 TGFrame.h:145
 TGFrame.h:146
 TGFrame.h:147
 TGFrame.h:148
 TGFrame.h:149
 TGFrame.h:150
 TGFrame.h:151
 TGFrame.h:152
 TGFrame.h:153
 TGFrame.h:154
 TGFrame.h:155
 TGFrame.h:156
 TGFrame.h:157
 TGFrame.h:158
 TGFrame.h:159
 TGFrame.h:160
 TGFrame.h:161
 TGFrame.h:162
 TGFrame.h:163
 TGFrame.h:164
 TGFrame.h:165
 TGFrame.h:166
 TGFrame.h:167
 TGFrame.h:168
 TGFrame.h:169
 TGFrame.h:170
 TGFrame.h:171
 TGFrame.h:172
 TGFrame.h:173
 TGFrame.h:174
 TGFrame.h:175
 TGFrame.h:176
 TGFrame.h:177
 TGFrame.h:178
 TGFrame.h:179
 TGFrame.h:180
 TGFrame.h:181
 TGFrame.h:182
 TGFrame.h:183
 TGFrame.h:184
 TGFrame.h:185
 TGFrame.h:186
 TGFrame.h:187
 TGFrame.h:188
 TGFrame.h:189
 TGFrame.h:190
 TGFrame.h:191
 TGFrame.h:192
 TGFrame.h:193
 TGFrame.h:194
 TGFrame.h:195
 TGFrame.h:196
 TGFrame.h:197
 TGFrame.h:198
 TGFrame.h:199
 TGFrame.h:200
 TGFrame.h:201
 TGFrame.h:202
 TGFrame.h:203
 TGFrame.h:204
 TGFrame.h:205
 TGFrame.h:206
 TGFrame.h:207
 TGFrame.h:208
 TGFrame.h:209
 TGFrame.h:210
 TGFrame.h:211
 TGFrame.h:212
 TGFrame.h:213
 TGFrame.h:214
 TGFrame.h:215
 TGFrame.h:216
 TGFrame.h:217
 TGFrame.h:218
 TGFrame.h:219
 TGFrame.h:220
 TGFrame.h:221
 TGFrame.h:222
 TGFrame.h:223
 TGFrame.h:224
 TGFrame.h:225
 TGFrame.h:226
 TGFrame.h:227
 TGFrame.h:228
 TGFrame.h:229
 TGFrame.h:230
 TGFrame.h:231
 TGFrame.h:232
 TGFrame.h:233
 TGFrame.h:234
 TGFrame.h:235
 TGFrame.h:236
 TGFrame.h:237
 TGFrame.h:238
 TGFrame.h:239
 TGFrame.h:240
 TGFrame.h:241
 TGFrame.h:242
 TGFrame.h:243
 TGFrame.h:244
 TGFrame.h:245
 TGFrame.h:246
 TGFrame.h:247
 TGFrame.h:248
 TGFrame.h:249
 TGFrame.h:250
 TGFrame.h:251
 TGFrame.h:252
 TGFrame.h:253
 TGFrame.h:254
 TGFrame.h:255
 TGFrame.h:256
 TGFrame.h:257
 TGFrame.h:258
 TGFrame.h:259
 TGFrame.h:260
 TGFrame.h:261
 TGFrame.h:262
 TGFrame.h:263
 TGFrame.h:264
 TGFrame.h:265
 TGFrame.h:266
 TGFrame.h:267
 TGFrame.h:268
 TGFrame.h:269
 TGFrame.h:270
 TGFrame.h:271
 TGFrame.h:272
 TGFrame.h:273
 TGFrame.h:274
 TGFrame.h:275
 TGFrame.h:276
 TGFrame.h:277
 TGFrame.h:278
 TGFrame.h:279
 TGFrame.h:280
 TGFrame.h:281
 TGFrame.h:282
 TGFrame.h:283
 TGFrame.h:284
 TGFrame.h:285
 TGFrame.h:286
 TGFrame.h:287
 TGFrame.h:288
 TGFrame.h:289
 TGFrame.h:290
 TGFrame.h:291
 TGFrame.h:292
 TGFrame.h:293
 TGFrame.h:294
 TGFrame.h:295
 TGFrame.h:296
 TGFrame.h:297
 TGFrame.h:298
 TGFrame.h:299
 TGFrame.h:300
 TGFrame.h:301
 TGFrame.h:302
 TGFrame.h:303
 TGFrame.h:304
 TGFrame.h:305
 TGFrame.h:306
 TGFrame.h:307
 TGFrame.h:308
 TGFrame.h:309
 TGFrame.h:310
 TGFrame.h:311
 TGFrame.h:312
 TGFrame.h:313
 TGFrame.h:314
 TGFrame.h:315
 TGFrame.h:316
 TGFrame.h:317
 TGFrame.h:318
 TGFrame.h:319
 TGFrame.h:320
 TGFrame.h:321
 TGFrame.h:322
 TGFrame.h:323
 TGFrame.h:324
 TGFrame.h:325
 TGFrame.h:326
 TGFrame.h:327
 TGFrame.h:328
 TGFrame.h:329
 TGFrame.h:330
 TGFrame.h:331
 TGFrame.h:332
 TGFrame.h:333
 TGFrame.h:334
 TGFrame.h:335
 TGFrame.h:336
 TGFrame.h:337
 TGFrame.h:338
 TGFrame.h:339
 TGFrame.h:340
 TGFrame.h:341
 TGFrame.h:342
 TGFrame.h:343
 TGFrame.h:344
 TGFrame.h:345
 TGFrame.h:346
 TGFrame.h:347
 TGFrame.h:348
 TGFrame.h:349
 TGFrame.h:350
 TGFrame.h:351
 TGFrame.h:352
 TGFrame.h:353
 TGFrame.h:354
 TGFrame.h:355
 TGFrame.h:356
 TGFrame.h:357
 TGFrame.h:358
 TGFrame.h:359
 TGFrame.h:360
 TGFrame.h:361
 TGFrame.h:362
 TGFrame.h:363
 TGFrame.h:364
 TGFrame.h:365
 TGFrame.h:366
 TGFrame.h:367
 TGFrame.h:368
 TGFrame.h:369
 TGFrame.h:370
 TGFrame.h:371
 TGFrame.h:372
 TGFrame.h:373
 TGFrame.h:374
 TGFrame.h:375
 TGFrame.h:376
 TGFrame.h:377
 TGFrame.h:378
 TGFrame.h:379
 TGFrame.h:380
 TGFrame.h:381
 TGFrame.h:382
 TGFrame.h:383
 TGFrame.h:384
 TGFrame.h:385
 TGFrame.h:386
 TGFrame.h:387
 TGFrame.h:388
 TGFrame.h:389
 TGFrame.h:390
 TGFrame.h:391
 TGFrame.h:392
 TGFrame.h:393
 TGFrame.h:394
 TGFrame.h:395
 TGFrame.h:396
 TGFrame.h:397
 TGFrame.h:398
 TGFrame.h:399
 TGFrame.h:400
 TGFrame.h:401
 TGFrame.h:402
 TGFrame.h:403
 TGFrame.h:404
 TGFrame.h:405
 TGFrame.h:406
 TGFrame.h:407
 TGFrame.h:408
 TGFrame.h:409
 TGFrame.h:410
 TGFrame.h:411
 TGFrame.h:412
 TGFrame.h:413
 TGFrame.h:414
 TGFrame.h:415
 TGFrame.h:416
 TGFrame.h:417
 TGFrame.h:418
 TGFrame.h:419
 TGFrame.h:420
 TGFrame.h:421
 TGFrame.h:422
 TGFrame.h:423
 TGFrame.h:424
 TGFrame.h:425
 TGFrame.h:426
 TGFrame.h:427
 TGFrame.h:428
 TGFrame.h:429
 TGFrame.h:430
 TGFrame.h:431
 TGFrame.h:432
 TGFrame.h:433
 TGFrame.h:434
 TGFrame.h:435
 TGFrame.h:436
 TGFrame.h:437
 TGFrame.h:438
 TGFrame.h:439
 TGFrame.h:440
 TGFrame.h:441
 TGFrame.h:442
 TGFrame.h:443
 TGFrame.h:444
 TGFrame.h:445
 TGFrame.h:446
 TGFrame.h:447
 TGFrame.h:448
 TGFrame.h:449
 TGFrame.h:450
 TGFrame.h:451
 TGFrame.h:452
 TGFrame.h:453
 TGFrame.h:454
 TGFrame.h:455
 TGFrame.h:456
 TGFrame.h:457
 TGFrame.h:458
 TGFrame.h:459
 TGFrame.h:460
 TGFrame.h:461
 TGFrame.h:462
 TGFrame.h:463
 TGFrame.h:464
 TGFrame.h:465
 TGFrame.h:466
 TGFrame.h:467
 TGFrame.h:468
 TGFrame.h:469
 TGFrame.h:470
 TGFrame.h:471
 TGFrame.h:472
 TGFrame.h:473
 TGFrame.h:474
 TGFrame.h:475
 TGFrame.h:476
 TGFrame.h:477
 TGFrame.h:478
 TGFrame.h:479
 TGFrame.h:480
 TGFrame.h:481
 TGFrame.h:482
 TGFrame.h:483
 TGFrame.h:484
 TGFrame.h:485
 TGFrame.h:486
 TGFrame.h:487
 TGFrame.h:488
 TGFrame.h:489
 TGFrame.h:490
 TGFrame.h:491
 TGFrame.h:492
 TGFrame.h:493
 TGFrame.h:494
 TGFrame.h:495
 TGFrame.h:496
 TGFrame.h:497
 TGFrame.h:498
 TGFrame.h:499
 TGFrame.h:500
 TGFrame.h:501
 TGFrame.h:502
 TGFrame.h:503
 TGFrame.h:504
 TGFrame.h:505
 TGFrame.h:506
 TGFrame.h:507
 TGFrame.h:508
 TGFrame.h:509
 TGFrame.h:510
 TGFrame.h:511
 TGFrame.h:512
 TGFrame.h:513
 TGFrame.h:514
 TGFrame.h:515
 TGFrame.h:516
 TGFrame.h:517
 TGFrame.h:518
 TGFrame.h:519
 TGFrame.h:520
 TGFrame.h:521
 TGFrame.h:522
 TGFrame.h:523
 TGFrame.h:524
 TGFrame.h:525
 TGFrame.h:526
 TGFrame.h:527
 TGFrame.h:528
 TGFrame.h:529
 TGFrame.h:530
 TGFrame.h:531
 TGFrame.h:532
 TGFrame.h:533
 TGFrame.h:534
 TGFrame.h:535
 TGFrame.h:536
 TGFrame.h:537
 TGFrame.h:538
 TGFrame.h:539
 TGFrame.h:540
 TGFrame.h:541
 TGFrame.h:542
 TGFrame.h:543
 TGFrame.h:544
 TGFrame.h:545
 TGFrame.h:546
 TGFrame.h:547
 TGFrame.h:548
 TGFrame.h:549
 TGFrame.h:550
 TGFrame.h:551
 TGFrame.h:552
 TGFrame.h:553
 TGFrame.h:554
 TGFrame.h:555
 TGFrame.h:556
 TGFrame.h:557
 TGFrame.h:558
 TGFrame.h:559
 TGFrame.h:560
 TGFrame.h:561
 TGFrame.h:562
 TGFrame.h:563
 TGFrame.h:564
 TGFrame.h:565
 TGFrame.h:566
 TGFrame.h:567
 TGFrame.h:568
 TGFrame.h:569
 TGFrame.h:570
 TGFrame.h:571
 TGFrame.h:572
 TGFrame.h:573
 TGFrame.h:574
 TGFrame.h:575
 TGFrame.h:576
 TGFrame.h:577
 TGFrame.h:578
 TGFrame.h:579
 TGFrame.h:580
 TGFrame.h:581
 TGFrame.h:582
 TGFrame.h:583
 TGFrame.h:584
 TGFrame.h:585
 TGFrame.h:586
 TGFrame.h:587
 TGFrame.h:588
 TGFrame.h:589
 TGFrame.h:590
 TGFrame.h:591
 TGFrame.h:592
 TGFrame.h:593
 TGFrame.h:594
 TGFrame.h:595
 TGFrame.h:596
 TGFrame.h:597
 TGFrame.h:598
 TGFrame.h:599
 TGFrame.h:600
 TGFrame.h:601
 TGFrame.h:602
 TGFrame.h:603
 TGFrame.h:604
 TGFrame.h:605
 TGFrame.h:606
 TGFrame.h:607
 TGFrame.h:608
 TGFrame.h:609
 TGFrame.h:610
 TGFrame.h:611
 TGFrame.h:612
 TGFrame.h:613
 TGFrame.h:614
 TGFrame.h:615
 TGFrame.h:616
 TGFrame.h:617
 TGFrame.h:618
 TGFrame.h:619
 TGFrame.h:620
 TGFrame.h:621
 TGFrame.h:622
 TGFrame.h:623
 TGFrame.h:624
 TGFrame.h:625
 TGFrame.h:626
 TGFrame.h:627
 TGFrame.h:628
 TGFrame.h:629
 TGFrame.h:630
 TGFrame.h:631
 TGFrame.h:632
 TGFrame.h:633
 TGFrame.h:634
 TGFrame.h:635
 TGFrame.h:636
 TGFrame.h:637
 TGFrame.h:638
 TGFrame.h:639
 TGFrame.h:640
 TGFrame.h:641
 TGFrame.h:642
 TGFrame.h:643
 TGFrame.h:644
 TGFrame.h:645
 TGFrame.h:646
 TGFrame.h:647
 TGFrame.h:648
 TGFrame.h:649
 TGFrame.h:650
 TGFrame.h:651
 TGFrame.h:652
 TGFrame.h:653
 TGFrame.h:654
 TGFrame.h:655
 TGFrame.h:656
 TGFrame.h:657
 TGFrame.h:658
 TGFrame.h:659
 TGFrame.h:660
 TGFrame.h:661
 TGFrame.h:662
 TGFrame.h:663
 TGFrame.h:664
 TGFrame.h:665
 TGFrame.h:666
 TGFrame.h:667
 TGFrame.h:668
 TGFrame.h:669
 TGFrame.h:670
 TGFrame.h:671
 TGFrame.h:672
 TGFrame.h:673
 TGFrame.h:674
 TGFrame.h:675
 TGFrame.h:676
 TGFrame.h:677
 TGFrame.h:678
 TGFrame.h:679
 TGFrame.h:680
 TGFrame.h:681
 TGFrame.h:682
 TGFrame.h:683
 TGFrame.h:684
 TGFrame.h:685
 TGFrame.h:686
 TGFrame.h:687
 TGFrame.h:688
 TGFrame.h:689
 TGFrame.h:690
 TGFrame.h:691
 TGFrame.h:692
 TGFrame.h:693
 TGFrame.h:694
 TGFrame.h:695
 TGFrame.h:696
 TGFrame.h:697
 TGFrame.h:698
 TGFrame.h:699
 TGFrame.h:700
 TGFrame.h:701
 TGFrame.h:702
 TGFrame.h:703
 TGFrame.h:704
 TGFrame.h:705
 TGFrame.h:706
 TGFrame.h:707
 TGFrame.h:708
 TGFrame.h:709
 TGFrame.h:710
 TGFrame.h:711
 TGFrame.h:712
 TGFrame.h:713
 TGFrame.h:714
 TGFrame.h:715
 TGFrame.h:716
 TGFrame.h:717
 TGFrame.h:718
 TGFrame.h:719
 TGFrame.h:720