TGCompositeFrame

class TGCompositeFrame : public TGFrame

    protected:

      virtual void SavePrimitiveSubframes(ofstream& out, Option_t* option)

    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)
                          TGCompositeFrame(const TGCompositeFrame&)
                  virtual ~TGCompositeFrame()
             virtual void AddFrame(TGFrame* f, TGLayoutHints* l = 0)
             virtual void ChangeOptions(UInt_t options)
           static TClass* Class()
             virtual void Cleanup()
           virtual UInt_t GetDefaultHeight() const
      virtual TGDimension GetDefaultSize() const
           virtual UInt_t GetDefaultWidth() const
         virtual TGFrame* GetFrameFromPoint(Int_t x, Int_t y)
         TGLayoutManager* GetLayoutManager() const
           virtual TList* GetList() const
                    Int_t GetState(TGFrame* f) const
           virtual Bool_t HandleButton(Event_t*)
           virtual Bool_t HandleCrossing(Event_t*)
           virtual Bool_t HandleDoubleClick(Event_t*)
           virtual Bool_t HandleDragDrop(TGFrame* frame, Int_t x, Int_t y, TGLayoutHints* lo)
           virtual Bool_t HandleDragEnter(TGFrame*)
           virtual Bool_t HandleDragLeave(TGFrame*)
           virtual Bool_t HandleDragMotion(TGFrame*)
           virtual Bool_t HandleFocusChange(Event_t*)
           virtual Bool_t HandleKey(Event_t*)
           virtual Bool_t HandleMotion(Event_t*)
           virtual Bool_t HandleSelection(Event_t*)
             virtual void HideFrame(TGFrame* f)
          virtual TClass* IsA() const
                   Bool_t IsArranged(TGFrame* f) const
                   Bool_t IsArranged(TGFrameElement* ptr) const
           virtual Bool_t IsComposite() const
           virtual Bool_t IsEditable() const
           virtual Bool_t IsLayoutBroken() const
           virtual Bool_t IsMapSubwindows() const
                   Bool_t IsVisible(TGFrame* f) const
                   Bool_t IsVisible(TGFrameElement* ptr) const
             virtual void Layout()
             virtual void MapSubwindows()
            virtual Int_t MustCleanup() const
             virtual void Print(Option_t* option = "") const
           virtual Bool_t ProcessMessage(Long_t, Long_t, Long_t)
             virtual void RemoveFrame(TGFrame* f)
             virtual void SavePrimitive(ofstream& out, Option_t* option)
             virtual void SetCleanup(Int_t mode = kLocalCleanup)
             virtual void SetEditable(Bool_t on = kTRUE)
             virtual void SetEditDisabled(Bool_t on = kTRUE)
             virtual void SetLayoutBroken(Bool_t on = kTRUE)
                     void SetLayoutManager(TGLayoutManager* l)
             virtual void SetMapSubwindows(Bool_t on)
             virtual void ShowFrame(TGFrame* f)
             virtual void ShowMembers(TMemberInspector& insp, char* parent)
             virtual void Streamer(TBuffer& b)
                     void StreamerNVirtual(TBuffer& b)
           virtual Bool_t TranslateCoordinates(TGFrame* child, Int_t x, Int_t y, Int_t& fx, Int_t& fy)

Data Members

    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 TContextMenu* fgContextMenu   context menu for setting GUI attributes
      static TGLayoutHints* fgDefaultHints  default hints used by AddFrame()

Class Description

                                                                      
 TGFrame, TGCompositeFrame, TGVerticalFrame, TGHorizontalFrame,       
 TGMainFrame, TGTransientFrame and TGGroupFrame                       
                                                                      
 The frame classes describe the different "dressed" GUI windows.      
                                                                      
 The TGFrame class is a subclasses of TGWindow, and is 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                                                  
                                                                      
 The TGCompositeFrame class is the base class for composite widgets   
 (menu bars, list boxes, etc.).                                       
 It provides:                                                         
  - a layout manager                                                  
  - a frame container (TList *)                                       
                                                                      
 The TGVerticalFrame and TGHorizontalFrame are composite frame that   
 layout their children in vertical or horizontal way.                 
                                                                      
 The TGMainFrame class defines top level windows that interact with   
 the system Window Manager.                                           
                                                                      
 The TGTransientFrame class defines transient windows that typically  
 are used for dialogs windows.                                        
                                                                      
 The TGGroupFrame is a composite frame with a border and a title.     
 It is typically used to group a number of logically related widgets  
 visually together.                                                   
                                                                      

 Create a composite frame. A composite frame has in addition to a TGFrame
 also a layout manager and a list of child frames.

 Create a frame using an externally created window. For example
 to register the root window (called by TGClient), or a window
 created via TVirtualX::InitWindow() (id is obtained with TVirtualX::GetWindowID()).

 Delete a composite frame.

 Return kTRUE if frame is being edited.

 Switch ON/OFF edit mode.
 If edit mode is ON it is possible:

  1. embed other ROOT GUI application (a la ActiveX)

  For example:
    TGMainFrame *m = new TGMainFrame(gClient->GetRoot(), 500, 500);
    m->SetEditable();
    gSystem->Load("$ROOTSYS/test/Aclock"); // load Aclock demo
    Aclock a;
    gROOT->Macro("$ROOTSYS/tutorials/guitest.C");
    m->SetEditable(0);
    m->MapWindow();

 Cleanup and delete all objects contained in this composite frame.
 This will delete all objects added via AddFrame().
 CAUTION: all objects (frames and layout hints) must be unique, i.e.
 cannot be shared.

 Set the layout manager for the composite frame.
 The layout manager is adopted by the frame and will be deleted
 by the frame.

 Set broken layout. No Layout method is called.

  disable/enable edit this frame and all subframes

 Change composite frame options. Options is an OR of the EFrameTypes.

 Turn on automatic cleanup of child frames in dtor.

 if mode = kNoCleanup    - no automatic cleanup
 if mode = kLocalCleanup - automatic cleanup in this composite frame only
 if mode = kDeepCleanup  - automatic deep cleanup in this composite frame
                           and all child composite frames (hierarchical)

 Attention!
    Hierarchical cleaning is dangerous and must be used with caution.
    There are many GUI components (in ROOT and in user code) which do not
    use Clean method in destructor ("custom deallocation").
    Adding such component to GUI container which is using hierarchical
    cleaning will produce seg. violation when container is deleted.
    The reason is double deletion: first whem Clean method is invoked,
    then at "custom deallocation".
    We are going to correct all ROOT code to make it to be
    consitent with hierarchical cleaning scheeme.

 Add frame to the composite frame using the specified layout hints.
 If no hints are specified default hints TGLayoutHints(kLHintsNormal,0,0,0,0)
 will be used. Most of the time, however, you will want to provide
 specific hints. User specified hints can be reused many times
 and need to be destroyed by the user. The added frames cannot not be
 added to different composite frames but still need to be deleted by
 the user.

 Remove frame from composite frame.

 Map all sub windows that are part of the composite frame.

 Hide sub frame.

 Show sub frame.

 Get state of sub frame.

 Get state of sub frame.

 Get state of sub frame.

 Layout the elements of the composite frame.

 Print all frames in this composite frame.

 Get frame located at specified point.

 Translate coordinates to child frame.

 Handle drag enter event.

 Handle drag leave event.

 Handle drag motion event.

 Handle drop event.

 auxilary protected method  used to save subframes

 Save a composite frame widget as a C++ statement(s) on output stream out

Inline Functions

                  TList* GetList() const
                  UInt_t GetDefaultWidth() const
                  UInt_t GetDefaultHeight() const
             TGDimension GetDefaultSize() const
                  Bool_t HandleButton(Event_t*)
                  Bool_t HandleDoubleClick(Event_t*)
                  Bool_t HandleCrossing(Event_t*)
                  Bool_t HandleMotion(Event_t*)
                  Bool_t HandleKey(Event_t*)
                  Bool_t HandleFocusChange(Event_t*)
                  Bool_t HandleSelection(Event_t*)
                  Bool_t ProcessMessage(Long_t, Long_t, Long_t)
        TGLayoutManager* GetLayoutManager() const
                  Bool_t IsVisible(TGFrameElement* ptr) const
                  Bool_t IsArranged(TGFrameElement* ptr) const
                  Bool_t IsComposite() const
                  Bool_t IsLayoutBroken() const
                   Int_t MustCleanup() const
                    void SetMapSubwindows(Bool_t on)
                  Bool_t IsMapSubwindows() const
                 TClass* Class()
                 TClass* IsA() const
                    void ShowMembers(TMemberInspector& insp, char* parent)
                    void Streamer(TBuffer& b)
                    void StreamerNVirtual(TBuffer& b)
        TGCompositeFrame TGCompositeFrame(const TGCompositeFrame&)