// File created: 02/15/2003                          last modified: 05/02/2006

/******************************************************************************
* Copyright(c) 2000-2005, Dr. Christian Stratowa, Vienna, Austria.            *
* Author: Christian Stratowa.                                                 *
******************************************************************************/

#include <Riostream.h>

#include "TROOT.h"
#include "TApplication.h"
#include "TSystem.h"
#include "TSystemDirectory.h"
#include "TSystemFile.h"
#include "TVirtualX.h"

#include "TBrowser.h"
#include "TGClient.h"

#include "RQ_OBJECT.h"

#ifndef ROOT_TG3DLine
#include "TG3DLine.h"
#endif

#ifndef ROOT_TGButton
#include "TGButton.h"
#endif

#ifndef ROOT_TGFileDialog
#include "TGFileDialog.h"
#endif

#ifndef ROOT_TGFrame
#include "TGFrame.h"
#endif

#ifndef ROOT_TGLayout
#include "TGLayout.h"
#endif

#ifndef ROOT_TGMenu
#include "TGMenu.h"
#endif

#ifndef ROOT_TGMsgBox
#include "TGMsgBox.h"
#endif

#ifndef ROOT_TGPicture
#include "TGPicture.h"
#endif

#ifndef ROOT_TGShutter
#include "TGShutter.h"
#endif

#ifndef ROOT_TGTab
#include "TGTab.h"
#endif

#ifndef ROOT_TList
#include "TList.h"
#endif

#ifndef ROOT_TString
#include "TString.h"
#endif

// Menu commands
enum EMenuCommands {
   M_FILE,
   M_FILE_OPEN,
   M_FILE_EXIT,

   M_TOOLS,
   M_TOOLS_BROWSER,
};

// Shutter commands
enum EShutterCommands {
   S_SHUT1 = 1001,
   S_SHUT1_A,
   S_SHUT1_B,

   S_SHUT2 = 2001,
   S_SHUT2_A,
   S_SHUT2_B,
};

struct ShutterData_t {
   const char *sPixmap_name;
   const char *sTip_text;
   Int_t       sId;
   TGButton   *sButton;
};

const char *xpm_names[] = {
    "Folder.xpm",
    "Folder.xpm",
    0
};

static const char *kShutterName[] = { "Shutter1",
                                      "Shutter2",
                                      0
};

ShutterData_t kItems1[] = {
   { "folder_s.xpm", "xxx", S_SHUT1_A, 0 },
   { "folder_s.xpm", "xxx", S_SHUT1_B, 0 },
   { 0,               0,    0,         0 }
};

ShutterData_t kItems2[] = {
   { "folder_s.xpm", "xxx", S_SHUT2_A, 0 },
   { "folder_s.xpm", "xxx", S_SHUT2_B, 0 },
   { 0,               0,    0,         0 }
};

static const char *kOpenTypes[] = { "All files",   "*",
                                    "ROOT files",  "*.root",
                                    "ROOT macros", "*.C",
                                    0,             0 };

//debug: print function names
const Bool_t kCS  = 1; 

//extern TString Path2Name(const char *name, const char *sep, const char *exten);

class SubFrame;
class FrameA;
class FrameB;

class MyFrame {

   RQ_OBJECT("MyFrame")

   private:
      TGMainFrame        *fMain;

   // MenuBar Frame
      TGPopupMenu        *fMenuFile;
      TGPopupMenu        *fMenuTool;
      TGMenuBar          *fMenuBar;
      TGHorizontal3DLine *fLineH1;

   // Shutter Frame
      TGHorizontalFrame  *fHF1;
      TGShutter           *fShutter;
      const TGPicture     *fDefaultPic;
      TGVerticalFrame     *fVF1;
      SubFrame             *fSubFrame;

   // Layout hints
      TGLayoutHints      *fMenuBarLayout;
      TGLayoutHints      *fMenuBarItemLayout;
      TGLayoutHints      *fMenuBarHelpLayout;

      TList    *fTrash;

   public:
      MyFrame(const TGWindow *window, UInt_t w, UInt_t h);
      virtual ~MyFrame();

      void HideSubFrames();
      void DisplayMessage(const char *title, const char *msg, Int_t id = 0,
              EMsgBoxIcon icon = kMBIconExclamation);
      void FileDialog(EFileDialogMode mode, TGFileInfo *fi);

   // Slots
      void DoCloseWindow();
      void DoMenu(Int_t id);
      void DoShutter(Int_t id = -1);

   private:
      void CreateMenuBar();
      void DeleteMenuBar();
      void CreateShutter(TGCompositeFrame *parent);
      void DeleteShutter();
      void CreateShutterFrames(TGCompositeFrame *parent);
      void DeleteShutterFrames();

      void AddShutterItem(const char *name, ShutterData_t data[], Int_t id);

//      ClassDef(MyFrame,0) //MainFrame
};

class SubFrame {

   RQ_OBJECT("SubFrame")

   private:
      MyFrame            *fMyFrame;
      TGCompositeFrame   *fShutterFrame;
      FrameA              *fFrameA;
      FrameB              *fFrameB;

      TList    *fTrash;

   public:
      SubFrame() {}
      SubFrame(TGCompositeFrame *parent, MyFrame *main, UInt_t w, UInt_t h);
      virtual ~SubFrame();

      void HideSubFrames();
      void HandleShutter(Int_t id = -1);

      void DoMenu(Int_t id);

   private:
      void CreateShutterItemFrames(TGCompositeFrame *parent);
      void DeleteShutterItemFrames();

//      ClassDef(SubFrame,0) //SubFrame
};

class FrameA {

   RQ_OBJECT("FrameA")

   private:
      MyFrame            *fMyFrame;
      TGCompositeFrame    *fFrame;
      TGCanvas            *fCanvas;
      TGTab               *fTab;
      TGCompositeFrame     *fFTabA;      //Tab A
      TGGroupFrame          *fFGroupA;
      TGCompositeFrame     *fFTabB;      //Tab B
      TGGroupFrame          *fFGroupB;

      TList    *fTrash;

   public:
      FrameA() {}
      FrameA(TGCompositeFrame *parent, MyFrame *main, UInt_t w, UInt_t h);
      virtual ~FrameA();

      void DoSelectOpenFile(Int_t id = -1);

      TGCompositeFrame *GetMain() {return fFrame;}

   private:
      void CreateTabA(TGTab *tab);
      void DeleteTabA();
      void CreateTabB(TGTab *tab);
      void DeleteTabB();

//      ClassDef(FrameA,0) //FrameA
};

class FrameB {

   RQ_OBJECT("FrameB")

   private:
      MyFrame            *fMyFrame;
      TGCompositeFrame    *fFrame;
      TGGroupFrame         *fFG1;

      TList    *fTrash;

   public:
      FrameB() {}
      FrameB(TGCompositeFrame *parent, MyFrame *main, UInt_t w, UInt_t h);
      virtual ~FrameB();

      TGCompositeFrame *GetMain() {return fFrame;}

/*   private:
      void CreateTabA(TGTab *tab);
      void DeleteTabA();
      void CreateTabB(TGTab *tab);
      void DeleteTabB();
*/
//      ClassDef(FrameB,0) //FrameB
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Utility functions                                                    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

//______________________________________________________________________________
TString Path2Name(const char *name, const char *sep, const char *exten)
{
   // Extract name from full path
   // sep is path separator and exten is name extension

   TString outname = TString(name);
   char   *tmpname = new char[strlen(name) + 1];
   char   *delname = tmpname;

   tmpname = strtok(strcpy(tmpname,name),sep);
   while(tmpname) {
      outname = tmpname;
      tmpname = strtok(NULL,sep);
   }//while
      
   if (strcmp(exten,"") != 0) {
      Int_t i = outname.Index(exten);
      if (i > 0) {outname = outname.Remove(i);}
   }//if

   delete [] delname;

   return outname;
}//Path2Name


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// MyFrame                                                              //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

//______________________________________________________________________________
MyFrame::MyFrame(const TGWindow *window, UInt_t w, UInt_t h)
{
   if(kCS) cout << "------MyFrame::MyFrame------" << endl;

   TGLayoutHints *hint = 0;

   fTrash = new TList();

   fMain = new TGMainFrame(window, w, h);
   fMain->Connect("CloseWindow()", "MyFrame", this, "DoCloseWindow()");

// Create menus
   this->CreateMenuBar();

// Create shutter
   fHF1 = new TGHorizontalFrame(fMain, 600, 400);
   hint = new TGLayoutHints(kLHintsTop | kLHintsExpandX | kLHintsExpandY);
   fMain->AddFrame(fHF1, hint);
   fTrash->Add(hint);

   this->CreateShutter(fHF1);

// Create shutter frames
   fVF1 = new TGVerticalFrame(fHF1, 600, 200);
   hint = new TGLayoutHints(kLHintsTop | kLHintsExpandX | kLHintsExpandY);
   fHF1->AddFrame(fVF1, hint);
   fTrash->Add(hint);

   this->CreateShutterFrames(fVF1);

// Main settings
   fMain->SetWindowName("MyGui");
   fMain->MapSubwindows();
   fMain->Resize(600, 400);

   // need call HideFrame() for all subframes hidden at startup 
   this->HideSubFrames();
//   fMain->SetWMPosition(140,120); 
   fMain->MapWindow();
}//Constructor

//______________________________________________________________________________
MyFrame::~MyFrame()
{
   if(kCS) cout << "------MyFrame::~MyFrame------" << endl;

   this->DeleteShutterFrames();
   delete fVF1;

   this->DeleteShutter();
   delete fHF1;

   this->DeleteMenuBar();

   fTrash->Delete();
   delete fTrash;

   delete fMain;
}//Destructor

//______________________________________________________________________________
void MyFrame::HideSubFrames()
{
   if(kCS) cout << "------MyFrame::HideSubFrames------" << endl;

   fSubFrame->HideSubFrames();
}//HideSubFrames

//______________________________________________________________________________
void MyFrame::DisplayMessage(const char *title, const char *msg, Int_t id,
              EMsgBoxIcon icon)
{
   if(kCS) cout << "------MyFrame::DisplayMessage------" << endl;

   Int_t retcode = 0;
   char buf[512];

   switch (id) {
      case 11:
         sprintf(buf, "Selected ROOT file is <%s>.", msg);
         break;

      default:
         if (strcmp(msg, "") == 0) {strcpy((char*)buf, "An error has occured");}
         else                      {sprintf(buf, msg);}
   }//switch

   new TGMsgBox(gClient->GetRoot(), fMain, title, buf, icon, kMBOk, &retcode);
}//DisplayMessage

//______________________________________________________________________________
void MyFrame::FileDialog(EFileDialogMode mode, TGFileInfo *fi)
{
   if(kCS) cout << "------MyFrame::FileDialog------" << endl;

   static TString sDir(".");

   fi->fIniDir = StrDup(sDir.Data());

   new TGFileDialog(gClient->GetRoot(), fMain, mode, fi);

   sDir = fi->fIniDir;
}//FileDialog

//______________________________________________________________________________
void MyFrame::DoCloseWindow()
{
   if(kCS) cout << "------MyFrame::DoCloseWindow------" << endl;

   gApplication->Terminate(0);
}//DoCloseWindow

//______________________________________________________________________________
void MyFrame::DoMenu(Int_t id)
{
   if(kCS) cout << "------MyFrame::DoMenu------" << endl;

   switch (id) {
   // File menu
      case M_FILE_OPEN:
         fSubFrame->DoMenu(id);
         break;

      case M_FILE_EXIT:
         this->DoCloseWindow();
         break;

   // Tools menu
      case M_TOOLS_BROWSER:
         new TBrowser();
//?         TBrowser *browser = new TBrowser();
         break;

      default:
         printf("Error: <MyFrame::DoMenu> Unknown ID %d selected\n", id);
         break;
   }//switch
}//DoMenu

//______________________________________________________________________________
void MyFrame::DoShutter(Int_t id)
{
   if(kCS) cout << "------MyFrame::DoShutter------" << endl;

   if (id == -1) {
      TGButton *btn = (TGButton*)gTQSender;
      id = btn->WidgetId();
   }//if

//   if (id == fShutterId) return;

//   fSubFrame->ShowFrame(kFALSE);

   switch (id) {
      case S_SHUT1_A:
      case S_SHUT1_B:
//         fSubFrame->ShowFrame(kTRUE);
         fSubFrame->HandleShutter(id);
         break;

      case S_SHUT2_A:
      case S_SHUT2_B:
         break;

      default:
         printf("Error: <XPSFrame::DoShutter> Unknown ID %d selected\n", id);
         break;
   }//switch

//   fShutterId = id;
   fShutter->ProcessMessage(0, id, 0);
}//DoShutter

//______________________________________________________________________________
void MyFrame::AddShutterItem(const char *name, ShutterData_t data[], Int_t id)
{
   if(kCS) cout << "------MyFrame::AddShutterItem------" << endl;

   TGShutterItem    *item;
   TGCompositeFrame *container;
   TGButton         *button;
   const TGPicture  *buttonpic;
   TGLayoutHints    *hint;

   hint = new TGLayoutHints(kLHintsTop | kLHintsCenterX, 5, 5, 5, 0);
   fTrash->Add(hint);

   item = new TGShutterItem(fShutter, new TGHotString(name), id);
   container = (TGCompositeFrame*)item->GetContainer();

   for (Int_t i=0; data[i].sPixmap_name != 0; i++) {
      buttonpic = gClient->GetPicture(data[i].sPixmap_name);
      if (!buttonpic) {
         printf("Shutter: missing pixmap \"%s\", using default",
                data[i].sPixmap_name);
         buttonpic = fDefaultPic;
      }//if

      button = new TGPictureButton(container, buttonpic, data[i].sId);
      button->Connect("Clicked()", "MyFrame", this, "DoShutter()");
      button->SetToolTipText(data[i].sTip_text);
      data[i].sButton = button;
      container->AddFrame(button, hint);
      fTrash->Add(button);
   }//for_i

   fShutter->AddItem(item);
   fTrash->Add(item);
}//AddShutterItem

//______________________________________________________________________________
void MyFrame::CreateMenuBar()
{
   if(kCS) cout << "------MyFrame::CreateMenuBar------" << endl;

   TGLayoutHints *hint = 0;

// File menu
   fMenuFile = new TGPopupMenu(gClient->GetRoot());
   fMenuFile->AddEntry("&Open...", M_FILE_OPEN);
   fMenuFile->AddEntry("&Exit",    M_FILE_EXIT);

// Tools menu
   fMenuTool = new TGPopupMenu(gClient->GetRoot());
   fMenuTool->AddEntry("&Browser", M_TOOLS_BROWSER);

// Connect menus to HandleMenu method
   fMenuFile->Connect("Activated(Int_t)","MyFrame",this,"DoMenu(Int_t)");
   fMenuTool->Connect("Activated(Int_t)","MyFrame",this,"DoMenu(Int_t)");

// Create menubar layout hints
   fMenuBarLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 0, 0, 1, 1);
   fMenuBarItemLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 4, 0, 0);
   fMenuBarHelpLayout = new TGLayoutHints(kLHintsTop | kLHintsRight);

// Add menus to MenuBar
   fMenuBar = new TGMenuBar(fMain, 1, 1, kHorizontalFrame);
   fMenuBar->AddPopup("&File",  fMenuFile, fMenuBarItemLayout);
   fMenuBar->AddPopup("&Tools", fMenuTool, fMenuBarItemLayout);

   fMain->AddFrame(fMenuBar, fMenuBarLayout);

// Line to separate menubar
   fLineH1 = new TGHorizontal3DLine(fMain);
   hint = new TGLayoutHints(kLHintsTop | kLHintsExpandX);
   fMain->AddFrame(fLineH1, hint);
   fTrash->Add(hint);
   fLineH1->DrawBorder();
}//CreateMenuBar

//______________________________________________________________________________
void MyFrame::DeleteMenuBar()
{
   if(kCS) cout << "------MyFrame::DeleteMenuBar------" << endl;

   delete fLineH1; 
   delete fMenuBar;

   delete fMenuBarHelpLayout; delete fMenuBarItemLayout; delete fMenuBarLayout;

   delete fMenuTool; delete fMenuFile; 
}//DeleteMenuBar

//______________________________________________________________________________
void MyFrame::CreateShutter(TGCompositeFrame *parent)
{
   if(kCS) cout << "------MyFrame::CreateShutter------" << endl;

   fDefaultPic = gClient->GetPicture("folder_s.xpm");
   fShutter = new TGShutter(parent, kSunkenFrame | kFixedWidth | kDoubleBorder);

   this->AddShutterItem(kShutterName[0], kItems1, S_SHUT1);
   this->AddShutterItem(kShutterName[1], kItems2, S_SHUT2);

   TGLayoutHints *hint = 0;
   hint = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandY);
   fTrash->Add(hint);
   parent->AddFrame(fShutter, hint);
   fShutter->Resize(100, 400);
}//CreateShutter

//______________________________________________________________________________
void MyFrame::DeleteShutter()
{
   if(kCS) cout << "------MyFrame::DeleteShutter------" << endl;

   delete fShutter;
   gClient->FreePicture(fDefaultPic);
}//DeleteShutter

//______________________________________________________________________________
void MyFrame::CreateShutterFrames(TGCompositeFrame *parent)
{
   if(kCS) cout << "------MyFrame::CreateShutterFrames------" << endl;

   fSubFrame = new SubFrame(parent, this, 0, 0);
}//CreateShutterFrames

//______________________________________________________________________________
void MyFrame::DeleteShutterFrames()
{
   if(kCS) cout << "------MyFrame::DeleteShutterFrames------" << endl;

   delete fSubFrame;
}//DeleteShutterFrames


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// SubFrame                                                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

//______________________________________________________________________________
SubFrame::SubFrame(TGCompositeFrame *parent, MyFrame *main, UInt_t w, UInt_t h)
{
   if(kCS) cout << "------SubFrame::SubFrame------" << endl;

   TGLayoutHints *hint = 0;

   fMyFrame = main;
   fTrash = new TList();

// Subframe for frame containing different shutter frames
   fShutterFrame = new TGCompositeFrame(parent, w, h);
   hint = new TGLayoutHints(kLHintsTop | kLHintsExpandX | kLHintsExpandY);
   parent->AddFrame(fShutterFrame, hint);
   fTrash->Add(hint);

// Create shutter subframes
   this->CreateShutterItemFrames(fShutterFrame);
}//Constructor

//______________________________________________________________________________
SubFrame::~SubFrame()
{
   if(kCS) cout << "------SubFrame::~SubFrame------" << endl;

   this->DeleteShutterItemFrames();

   fTrash->Delete();
   delete fTrash;

   delete fShutterFrame;

   fMyFrame = 0;
}//Destructor

//______________________________________________________________________________
void SubFrame::HideSubFrames()
{
   if(kCS) cout << "------SubFrame::HideSubFrames------" << endl;

// Hide shutter frames
//   fShutterFrame->HideFrame(fFrameA->GetMain());
   fShutterFrame->HideFrame(fFrameB->GetMain());
}//HideSubFrames

//______________________________________________________________________________
void SubFrame::HandleShutter(Int_t id)
{
   if(kCS) cout << "------SubFrame::HandleShutter------" << endl;

   fShutterFrame->HideFrame(fFrameA->GetMain());
   fShutterFrame->HideFrame(fFrameB->GetMain());

// Show frame for id
   switch (id) {
      case S_SHUT1_A:
         fShutterFrame->ShowFrame(fFrameA->GetMain());
         break;

      case S_SHUT1_B:
         fShutterFrame->ShowFrame(fFrameB->GetMain());
         break;

      default:
         printf("Error: <XDataFrame::HandleShutter> Unknown ID %d selected\n", id);
         break;
   }//switch

   fShutterFrame->Layout();
}//HandleShutter

//______________________________________________________________________________
void SubFrame::DoMenu(Int_t id)
{
   // Handle menu items
   if(kCS) cout << "------SubFrame::DoMenu------" << endl;

   switch (id) {
   // File menu
      case M_FILE_OPEN:
         // display dialogbox to open file
         fFrameA->DoSelectOpenFile(id);
         break;

      default:
         printf("Error: <SubFrame::DoMenu> Unknown ID %d selected\n", id);
         break;
   }//switch
}//DoMenu

//______________________________________________________________________________
void SubFrame::CreateShutterItemFrames(TGCompositeFrame *parent)
{
   if(kCS) cout << "------SubFrame::CreateShutterItemFrames------" << endl;

   fFrameA = new FrameA(parent, fMyFrame, 0, 0);
   fFrameB = new FrameB(parent, fMyFrame, 0, 0);
}//CreateShutterItemFrames

//______________________________________________________________________________
void SubFrame::DeleteShutterItemFrames()
{
   if(kCS) cout << "------SubFrame::DeleteShutterItemFrames------" << endl;

   delete fFrameB; delete fFrameA;
}//DeleteShutterItemFrames


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// FrameA                                                               //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

//______________________________________________________________________________
FrameA::FrameA(TGCompositeFrame *parent, MyFrame *main, UInt_t w, UInt_t h)
{
   if(kCS) cout << "------FrameA::FrameA------" << endl;

   TGLayoutHints *hint = 0;

   fMyFrame = main;
   fTrash = new TList();

   // Create tabs in canvas
   fFrame  = new TGVerticalFrame(parent, 0, 0);
   fCanvas = new TGCanvas(fFrame, 10, 10, 0);
   fTab    = new TGTab(fCanvas->GetViewPort(), 200, 20);
//   fTab->Connect("Selected(Int_t)", "FrameA", this, "DoSelectTab(Int_t)");
   fTab->Associate(parent);  //?
   fCanvas->SetContainer(fTab);

   // Create tabs
   this->CreateTabA(fTab);
   this->CreateTabB(fTab);

   hint = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY);
   fFrame->AddFrame(fCanvas, hint);
   fTrash->Add(hint);

   hint = new TGLayoutHints(kLHintsRight | kLHintsExpandX | kLHintsExpandY);
   parent->AddFrame(fFrame, hint);
   fTrash->Add(hint);
}//Constructor

//______________________________________________________________________________
FrameA::~FrameA()
{
   if(kCS) cout << "------FrameA::~FrameA------" << endl;

   this->DeleteTabB();
   this->DeleteTabA();

   delete fTab; delete fCanvas; delete fFrame;

   fTrash->Delete();
   delete fTrash;

   fMyFrame = 0;
}//Destructor

//______________________________________________________________________________
void FrameA::DoSelectOpenFile(Int_t id)
{
   if(kCS) cout << "------FrameA::DoSelectOpenFile------" << endl;

   if (id == -1) {
      TGButton *btn = (TGButton*)gTQSender;
      id = btn->WidgetId();
   }//if

   char filename[1024];

   TGFileInfo fi;
   fi.fFileTypes   = kOpenTypes;
   fi.fFileTypeIdx = 2;   //"ROOT files"
   fi.fIniDir      = 0;
   fi.fFilename    = 0;

   fMyFrame->FileDialog(kFDOpen, &fi);

// Cancel
   if (!fi.fFilename) return;

// OK
   sprintf(filename,"%s",fi.fFilename);

   TString str = Path2Name(filename, ".", "");
   if(strcmp(str.Data(),"root") != 0) {
      fMyFrame->DisplayMessage("Error Message", "Selected file is not a root file!");
      return;
   }//if

   str = Path2Name(filename, "/", "");
   fMyFrame->DisplayMessage("Note", str, 11);
}//DoSelectOpenFile

//______________________________________________________________________________
void FrameA::CreateTabA(TGTab *tab)
{
   if(kCS) cout << "------FrameA::CreateTabA------" << endl;

   TGLayoutHints    *hint     = 0;
   TGCompositeFrame *tabframe = 0;

// Tab A
   tabframe = tab->AddTab("Tab A");
   fFTabA = new TGCompositeFrame(tabframe, 60, 20, kVerticalFrame);
   hint = new TGLayoutHints(kLHintsTop | kLHintsLeft, 2, 2, 5, 2);
   tabframe->AddFrame(fFTabA, hint);
   fTrash->Add(hint);

// Group A
   fFGroupA = new TGGroupFrame(fFTabA, "Group for Tab A", kVerticalFrame);
   hint = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 2, 2, 5, 2);
   fFTabA->AddFrame(fFGroupA, hint);
   fTrash->Add(hint);
}//CreateTabA

//______________________________________________________________________________
void FrameA::DeleteTabA()
{
   if(kCS) cout << "------FrameA::DeleteTabA------" << endl;

   delete fFGroupA; delete fFTabA;
}//DeleteTabA

//______________________________________________________________________________
void FrameA::CreateTabB(TGTab *tab)
{
   if(kCS) cout << "------FrameA::CreateTabB------" << endl;

   TGLayoutHints    *hint     = 0;
   TGCompositeFrame *tabframe = 0;

// Tab B
   tabframe = tab->AddTab("Tab B");
   fFTabB = new TGCompositeFrame(tabframe, 60, 20, kVerticalFrame);
   hint = new TGLayoutHints(kLHintsTop | kLHintsLeft, 2, 2, 5, 2);
   tabframe->AddFrame(fFTabB, hint);
   fTrash->Add(hint);

// Group B
   fFGroupB = new TGGroupFrame(fFTabB, "Group for Tab B", kVerticalFrame);
   hint = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 2, 2, 5, 2);
   fFTabB->AddFrame(fFGroupB, hint);
   fTrash->Add(hint);
}//CreateTabB

//______________________________________________________________________________
void FrameA::DeleteTabB()
{
   if(kCS) cout << "------FrameA::DeleteTabB------" << endl;

   delete fFGroupB; delete fFTabB;
}//DeleteTabB


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// FrameB                                                               //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

//______________________________________________________________________________
FrameB::FrameB(TGCompositeFrame *parent, MyFrame *main, UInt_t w, UInt_t h)
{
   if(kCS) cout << "------FrameB::FrameB------" << endl;

   TGLayoutHints *hint = 0;

   fMyFrame = main;
   fTrash = new TList();

   fFrame = new TGCompositeFrame(parent,0,0, kHorizontalFrame);
   hint = new TGLayoutHints(kLHintsTop | kLHintsExpandX | kLHintsExpandY);
   parent->AddFrame(fFrame, hint);
   fTrash->Add(hint);

   fFG1 = new TGGroupFrame(fFrame, "Group frame for B", kVerticalFrame);
   hint = new TGLayoutHints(kLHintsTop | kLHintsExpandX | kLHintsExpandY);
   fFrame->AddFrame(fFG1, hint);
   fTrash->Add(hint);
}//Constructor

//______________________________________________________________________________
FrameB::~FrameB()
{
   if(kCS) cout << "------FrameB::~FrameB------" << endl;

   delete fFG1; delete fFrame;

   fTrash->Delete();
   delete fTrash;

   fMyFrame = 0;
}//Destructor


//______________________________________________________________________________
//______________________________________________________________________________
void MyGui()
{
   new MyFrame(0, 400, 220);
}

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Main program                                                         //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#ifdef STANDALONE
int main(int argc, char **argv)
{
   TApplication theApp("App", &argc, argv);

   if (gROOT->IsBatch()) {
      fprintf(stderr, "%s: Cannot run in batch mode\n", argv[0]);
      return 1;
   }
/*
   MyFrame *myApp = new MyFrame(0, 400, 220);
//   MyFrame *myApp = new MyFrame(gClient->GetRoot(), 400, 220);

   theApp.Run(kTRUE);  //kTRUE needed in order to delete myApp!

   delete myApp;
*/
   MyGui();

   theApp.Run();

   cout << "MyApp successfully terminated." << endl;
   return 0;
}//main
#endif