// File created: 01/20/2004                          last modified: 01/16/2005
// Author: Christian Stratowa 
//
// Test gui for selection of trees in TGListBox

//#ifndef __CINT__
#include "RQ_OBJECT.h"
#include "TG3DLine.h"
#include "TGButton.h"
#include "TGButtonGroup.h"
#include "TGFileDialog.h"
#include "TGFrame.h"
#include "TGLabel.h"
#include "TGLayout.h"
#include "TGListBox.h"
#include "TGMenu.h"
#include "TGMsgBox.h"
#include "TGTab.h"
#include "TGTableLayout.h"
#include "TGTextBuffer.h"
#include "TGTextEntry.h"

#include "TKey.h"
#include "TList.h"
#include "TObjString.h"
#include "TString.h"
#include "TROOT.h"
#include "TSystem.h"
//#endif
#include <Riostream.h>

enum EMenuCommands {
   M_FILE,
   M_FILE_OPEN,
   M_FILE_EXIT,
};

enum EButtonIds {
   B_ADD_G1,
   B_REMOVE_G1,
   B_REMOVE_G1_ALL,
   B_RESET_GROUP2,

   L_TREEBOX_SELECT,
   L_TREEBOX_GROUP1,

   C_GROUP2SET,
};

class XFilterFrame {

   RQ_OBJECT("XFilterFrame")

   private:
      TGMainFrame        *fMain;

      TGPopupMenu        *fMenuFile;
      TGMenuBar          *fMenuBar;
      TGHorizontal3DLine *fLineH1;

      TGHorizontalFrame  *fHF1;
      TGVerticalFrame     *fVF1;
      TGCompositeFrame    *fFrame;

      TGCompositeFrame   *fFTwoGrps;
      TGCanvas           *fCanvas2G;
      TGTab              *fTab2G;
      TGCompositeFrame    *fFT2Grps;      //Tab Groups
      TGGroupFrame         *fFG2Grps;
      TGListBox             *fSelTreeBox;
      TGTextButton          *fAddG1Btn;
      TGTextButton          *fRmvG1Btn;
      TGTextButton          *fAllG1Btn;
      TGListBox             *fG1TreeBox;
      TGTextButton          *fRst2GBtn;
      TGCheckButton         *fCheckPat;
      TGGroupFrame         *fFGGrpPat;
      TGCompositeFrame      *fCFPat;
      TGLabel                *fLabP;
      TGTextEntry            *fTxtP;
      TGTextBuffer           *fBufP;
      TGButton               *fBrowsePBtn;
      TGCompositeFrame      *fCFSelPat;
      TGLabel                *fLabS;
      TGComboBox             *fGrpPatBox;
      TGButton               *fHlpPatBtn;
      TGCompositeFrame    *fFTUTest;      //Tab Test
      TGGroupFrame         *fFGUTst;

      TGLayoutHints      *fMenuBarLayout;
      TGLayoutHints      *fMenuBarItemLayout;
      TGLayoutHints      *fMenuBarHelpLayout;
      TGLayoutHints      *fLineLayout;
      TGLayoutHints      *fLayout;

      TGLayoutHints      *fHintTL;
      TGLayoutHints      *fHintTX;
      TGLayoutHints      *fHintTXY;
      TGLayoutHints      *fHintRXY;
      TGLayoutHints      *fHintLY;
      TGLayoutHints      *fHintXY;

      TList   *fTrash;
      Int_t    fNumSelG1;
      TList   *fSelections;       //list of selected trees

   public:
      XFilterFrame() {}
      XFilterFrame(const TGWindow *window, UInt_t w, UInt_t h);
      virtual ~XFilterFrame();

      void FileDialog(EFileDialogMode mode, TGFileInfo *fi);
      TFile *OpenFile(const char *name);
      void OpenFile();
      void AddTrees2ListBox();

      void DoMenu(Int_t id);
      void DoCloseWindow();
      void DoSelectTrees(Int_t id = -1);
      void DoSelectGroup(Int_t id = -1);

   private:
      Bool_t HasEntry(TGListBox *listbox, const char *name);

      void CreateMenuBar();
      void DeleteMenuBar();
      void CreateFrameTwoGroups(TGCompositeFrame *parent);
      void DeleteFrameTwoGroups();
      void CreateTabSelectGroups(TGTab *tab);
      void DeleteTabSelectGroups();
      void CreateFrameSelectGroups(TGCompositeFrame *parent);
      void DeleteFrameSelectGroups();
      void CreateFrameImportGroupSet(TGCompositeFrame *parent);
      void DeleteFrameImportGroupSet();
      void CreateTabTest(TGTab *tab);
      void DeleteTabTest();

#if !defined (__CINT__) || defined (__MAKECINT__)
      ClassDef(XFilterFrame,0) //FilterFrame
#endif
};

//______________________________________________________________________________
//______________________________________________________________________________

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

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

#if !defined (__CINT__) || defined (__MAKECINT__)
ClassImp(XFilterFrame);
#endif

const Int_t kMaxEntries = 999999;
const Int_t kBufSize = 512;


//______________________________________________________________________________
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


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// XFilterFrame                                                         //
//                                                                      //
// Subframe for shutter Filter                                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

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

   fSelections = new TList();
   fNumSelG1   = 0;

   fTrash   = new TList();
   fHintTL  = new TGLayoutHints(kLHintsTop | kLHintsLeft);
   fHintTX  = new TGLayoutHints(kLHintsTop | kLHintsExpandX);
   fHintTXY = new TGLayoutHints(kLHintsTop | kLHintsExpandX | kLHintsExpandY);
   fHintRXY = new TGLayoutHints(kLHintsRight | kLHintsExpandX | kLHintsExpandY);
   fHintLY  = new TGLayoutHints(kLHintsLeft | kLHintsExpandY);
   fHintXY  = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY);

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

   CreateMenuBar();

   fLayout = new TGLayoutHints(kLHintsTop | kLHintsExpandX | kLHintsExpandY);
   fHF1 = new TGHorizontalFrame(fMain, 20, 20);
   fMain->AddFrame(fHF1, fLayout);

   fVF1 = new TGVerticalFrame(fHF1, 500, 200);
   fHF1->AddFrame(fVF1, fLayout);
   CreateFrameTwoGroups(fVF1);

   fMain->SetWindowName("Groups");
   fMain->MapSubwindows();
   fMain->Resize(640, 620);

   fFT2Grps->HideFrame(fFGGrpPat);

   fMain->MapWindow();
   fMain->Move(420, 20);
}//Constructor

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

   if(fSelections) {
      if (fSelections->GetSize() > 0) fSelections->Delete();
      delete fSelections;
      fSelections = 0;
   }//if

   DeleteFrameTwoGroups();
   DeleteMenuBar();

   delete fLayout;
   delete fHintTL; delete fHintTX; delete fHintTXY;
   delete fHintRXY; delete fHintLY; delete fHintXY;

   delete fHF1; 
   delete fVF1; 

   fTrash->Delete();
   delete fTrash;

   delete fMain;
}//Destructor

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

   static TString sDir(".");

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

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

   sDir = fi->fIniDir;
}//FileDialog

//______________________________________________________________________________
TFile *XFilterFrame::OpenFile(const char *name)
{
   if(kCS) cout << "------*XFilterFrame::OpenFile------" << endl;

   TFile *file = 0;

   file = gROOT->GetFile(name);
   if (!file) file = TFile::Open(name, "READ");

   if (!file || file->IsZombie()) {
      if (file) delete file;
      file = 0;
      char buf[256];
      sprintf(buf, "Could not open file <%s>.", name);
      return 0;
   }//if

   return file;
}//OpenFile

//______________________________________________________________________________
void XFilterFrame::OpenFile()
{
   if(kCS) cout << "------XFilterFrame::OpenFile------" << endl;

   char filename[256];

   TGFileInfo fi;
   fi.fFileTypes = kOpenTypes;

   FileDialog(kFDOpen, &fi);

   if (!fi.fFilename) return;

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

   if(strstr(filename,".root") == 0) {
      cout << "Selected file <" << filename << "> is not a ROOT file." << endl;
      return;
   }//if

   TFile *file = OpenFile(filename);
   if (!file) return;

   fSelections->RemoveAll();

   const char *treename;
   char *fullname = new char[4096];
   TObjString *objstr = 0;

   Int_t id = 0; //for uniqueId
   TKey *key = 0;
   TIter next(file->GetListOfKeys());
   while ((key = (TKey*)next())) {
      if (strcmp(key->GetClassName(), "TTree") != 0) continue;

      treename = key->GetName();
      sprintf(fullname, "%s/%s", filename, treename);
      objstr = new TObjString(fullname);
      objstr->SetUniqueID(id++);
      fSelections->Add(objstr);
   }//while

   AddTrees2ListBox();
}//OpenFile

//______________________________________________________________________________
void XFilterFrame::AddTrees2ListBox()
{
   if(kCS) cout << "------XFilterFrame::AddTrees2ListBox------" << endl;

   fSelTreeBox->RemoveEntries(0, kMaxEntries);

   Int_t idx = 0;
   TIter next(fSelections);
   TObjString *objstr = 0;
   while ((objstr = (TObjString*)next())) {
      TString treename = Path2Name(objstr->GetName(),"/","");

      fSelTreeBox->AddEntry(treename, objstr->GetUniqueID());
      idx++;
   }//while

   fSelTreeBox->MapSubwindows();
   fSelTreeBox->Layout();
}//AddTrees2ListBox

//______________________________________________________________________________
Bool_t XFilterFrame::HasEntry(TGListBox *listbox, const char *name)
{
   if(kCSa) cout << "------XFilterFrame::HasEntry------" << endl;

   TGFrameElement *frel;
   TGTextLBEntry  *entry;

   TList *entries = ((TGLBContainer*)listbox->GetContainer())->GetList();
   TIter  next(entries);
   while ((frel = (TGFrameElement*)next())) {
      entry = (TGTextLBEntry*)frel->fFrame;
      if (strcmp(entry->GetText()->GetString(), name) == 0) return kTRUE;
   }//while

   return kFALSE;
}//HasEntry

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

   switch (id) {
      case M_FILE_OPEN:
         OpenFile();
         break;

      case M_FILE_EXIT:
         DoCloseWindow();
         break;

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

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

   delete this;  //does not exit root
//   gApplication->Terminate(0);  //exit root, needed for standalone App
}//DoCloseWindow

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

   if (id == -1) {
      TGFrame *frm = (TGFrame*)gTQSender;
      if (frm->IsA()->InheritsFrom(TGListBox::Class())) {
         TGListBox *lbx = (TGListBox*)frm;
         id = lbx->WidgetId();
      } else {
         TGButton *btn = (TGButton*)frm;
         id = btn->WidgetId();
      }//if
   }//if

   TGTextLBEntry *entry = 0;
   TString treename;
   Int_t idx;

   TList *selected = new TList();
   TList *selG1    = new TList();

   fSelTreeBox->GetSelectedEntries(selected);
   fG1TreeBox->GetSelectedEntries(selG1);

   TIter next(selected);
   TIter next1(selG1);

   switch (id) {
      case L_TREEBOX_SELECT: {
         if (fSelTreeBox->GetNumberOfEntries() > 0) {
            if (selected->GetSize() > 0) {
               fAddG1Btn->SetState(kButtonUp);
               fRst2GBtn->SetState(kButtonUp);
            } else {
               fAddG1Btn->SetState(kButtonDisabled);
               fRst2GBtn->SetState(kButtonDisabled);
            }//if
         } else {
            fAddG1Btn->SetState(kButtonDisabled);
            fRst2GBtn->SetState(kButtonDisabled);
         }//if
         break;
      }//case

      case L_TREEBOX_GROUP1: {
         fNumSelG1 = selG1->GetSize();
         break;
      }//case

      case B_ADD_G1: {
         while ((entry = (TGTextLBEntry*)next())) {
            treename = entry->GetText()->GetString();
            idx      = entry->EntryId();

            if (!HasEntry(fG1TreeBox, treename)) {
               fG1TreeBox->AddEntry(treename, idx);

               fRmvG1Btn->SetState(kButtonUp);
               fAllG1Btn->SetState(kButtonUp);
            }//if

            fG1TreeBox->Select(idx, kTRUE);
         }//while

         selG1->Clear();
         fG1TreeBox->GetSelectedEntries(selG1);
         fNumSelG1 = selG1->GetSize();

         fG1TreeBox->MapSubwindows();
         fG1TreeBox->Layout();
         break;
      }//case

      case B_REMOVE_G1: {
         while ((entry = (TGTextLBEntry*)next1())) {
            idx = entry->EntryId();
            fG1TreeBox->RemoveEntry(idx);

            fNumSelG1--;
         }//while

         if (fG1TreeBox->GetNumberOfEntries() == 0) {
            fRmvG1Btn->SetState(kButtonDisabled);
            fAllG1Btn->SetState(kButtonDisabled);
         }//if

         fG1TreeBox->MapSubwindows();
         fG1TreeBox->Layout();
         break;
      }//case

      case B_REMOVE_G1_ALL: {
         fG1TreeBox->RemoveEntries(0, kMaxEntries);

         if (fG1TreeBox->GetNumberOfEntries() == 0) {
            fRmvG1Btn->SetState(kButtonDisabled);
            fAllG1Btn->SetState(kButtonDisabled);
         }//if

         fNumSelG1 = 0;

         fG1TreeBox->MapSubwindows();
         fG1TreeBox->Layout();
         break;
      }//case

      case B_RESET_GROUP2:
         while ((entry = (TGTextLBEntry*)next())) {
            fSelTreeBox->Select(entry->EntryId(), kFALSE);
         }//while
         break;

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

   selG1->Clear();
   SafeDelete(selG1);

   selected->Clear();
   SafeDelete(selected);
}//DoSelectTrees

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

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

//   fFT2Grps->HideFrame(fFGGrpPat);

   switch (id) {
      case C_GROUP2SET:
         if (fCheckPat->GetState() == kButtonDown) {
            fFT2Grps->ShowFrame(fFGGrpPat);
         } else {
            fFT2Grps->HideFrame(fFGGrpPat);
         }//if
//not possible to hide fFGGrpPat when:
         fFT2Grps->MapSubwindows();
         fFT2Grps->Layout();
//or:
//         fFTwoGrps->MapSubwindows();
//         fFTwoGrps->Layout();
//this results in *** Break *** segmentation violation
//         fFrame->MapSubwindows();
//         fFrame->Layout();
         break;

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

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

   fMenuFile = new TGPopupMenu(gClient->GetRoot());
   fMenuFile->AddEntry("&Open...", M_FILE_OPEN);
   fMenuFile->AddEntry("&Exit",    M_FILE_EXIT);
   fMenuFile->Connect("Activated(Int_t)","XFilterFrame",this,"DoMenu(Int_t)");

   fMenuBarLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 0, 0, 1, 1);
   fMenuBarItemLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 4, 0, 0);
   fMenuBarHelpLayout = new TGLayoutHints(kLHintsTop | kLHintsRight);

   fMenuBar = new TGMenuBar(fMain, 1, 1, kHorizontalFrame);
   fMenuBar->AddPopup("&File",        fMenuFile, fMenuBarItemLayout);

   fMain->AddFrame(fMenuBar, fMenuBarLayout);

   fLineH1 = new TGHorizontal3DLine(fMain);
   fLineLayout = new TGLayoutHints(kLHintsTop | kLHintsExpandX);
   fMain->AddFrame(fLineH1, fLineLayout);
   fLineH1->DrawBorder();
}//CreateMenuBar

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

   delete fLineLayout;
   delete fLineH1; 

   delete fMenuBarLayout;
   delete fMenuBarItemLayout;
   delete fMenuBarHelpLayout;

   delete fMenuBar;
   delete fMenuFile; 
}//DeleteMenuBar

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

   fFTwoGrps = new TGVerticalFrame(parent, 0, 0);
   fCanvas2G = new TGCanvas(fFTwoGrps, 10, 10, 0);
   fTab2G = new TGTab(fCanvas2G->GetViewPort(), 200, 20);
   fTab2G->Associate(parent);  //?
   fCanvas2G->SetContainer(fTab2G);

   CreateTabSelectGroups(fTab2G);
   CreateTabTest(fTab2G);

   fFTwoGrps->AddFrame(fCanvas2G, fHintXY);
   fFTwoGrps->Resize(200, 260);

   parent->AddFrame(fFTwoGrps, fHintRXY);
//   parent->HideFrame(fFTwoGrps);
}//CreateFrameTwoGroups

//______________________________________________________________________________
void XFilterFrame::DeleteFrameTwoGroups()
{
   if(kCS) cout << "------XFilterFrame::DeleteFrameTwoGroups------" << endl;

   DeleteTabTest();
   DeleteTabSelectGroups();

   delete fTab2G; delete fCanvas2G; delete fFTwoGrps;
}//DeleteFrameTwoGroups

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

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

   tabframe = tab->AddTab("Groups");
   fFT2Grps = new TGCompositeFrame(tabframe, 20, 20, kVerticalFrame);
   hint = new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 10, 5);
   tabframe->AddFrame(fFT2Grps, hint);
   fTrash->Add(hint);

   CreateFrameSelectGroups(fFT2Grps);
   CreateFrameImportGroupSet(fFT2Grps);

//   fFT2Grps->HideFrame(fFGGrpPat);
}//CreateTabSelectGroups

//______________________________________________________________________________
void XFilterFrame::DeleteTabSelectGroups()
{
   if(kCS) cout << "------XFilterFrame::DeleteTabSelectGroups------" << endl;

   DeleteFrameImportGroupSet();
   DeleteFrameSelectGroups();

   delete fFT2Grps;
}//DeleteTabSelectGroups

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

   TGTableLayout      *layout = 0;
   TGTableLayoutHints *thint  = 0;

   fFG2Grps = new TGGroupFrame(parent, "Select Groups");
   layout = new TGTableLayout(fFG2Grps, 10, 6);
   fFG2Grps->SetLayoutManager(layout);  //layout deleted by fFT2Grps!
   parent->AddFrame(fFG2Grps, fHintTL);

   fSelTreeBox = new TGListBox(fFG2Grps, L_TREEBOX_SELECT);
   fSelTreeBox->SetMultipleSelections(kTRUE);
   fSelTreeBox->Connect("SelectionChanged()", "XFilterFrame", this, "DoSelectTrees()");
//   fSelTreeBox->Connect("SelectionChanged()", "XFilterFrame", this, "DoSelectTreeBox(Int_t)");
//   fSelTreeBox->Connect("Selected(Int_t)", "XFilterFrame", this, "DoSelectTrees()");
   thint = new TGTableLayoutHints(0,3, 0,8, kLHintsLeft, 7,7,10,5);
   fFG2Grps->AddFrame(fSelTreeBox, thint);
   fSelTreeBox->Resize(230,317);
   fTrash->Add(thint);

   fAddG1Btn = new TGTextButton(fFG2Grps, "   >   ", B_ADD_G1);
   fAddG1Btn->Connect("Clicked()", "XFilterFrame", this, "DoSelectTrees()");
   fAddG1Btn->SetToolTipText("Add trees to control group");
   fAddG1Btn->SetState(kButtonDisabled);
   thint = new TGTableLayoutHints(3,4, 1,2, kLHintsLeft, 20,20,15,5);
   fFG2Grps->AddFrame(fAddG1Btn, thint);
   fTrash->Add(thint);

   fRmvG1Btn = new TGTextButton(fFG2Grps, "   <   ", B_REMOVE_G1);
   fRmvG1Btn->Connect("Clicked()", "XFilterFrame", this, "DoSelectTrees()");
   fRmvG1Btn->SetToolTipText("Remove tree from control group");
   fRmvG1Btn->SetState(kButtonDisabled);
   thint = new TGTableLayoutHints(3,4, 2,3, kLHintsLeft, 20,20,5,5);
   fFG2Grps->AddFrame(fRmvG1Btn, thint);
   fTrash->Add(thint);

   fAllG1Btn = new TGTextButton(fFG2Grps, "  <<  ", B_REMOVE_G1_ALL);
   fAllG1Btn->Connect("Clicked()", "XFilterFrame", this, "DoSelectTrees()");
   fAllG1Btn->SetToolTipText("Remove all trees from control group");
   fAllG1Btn->SetState(kButtonDisabled);
   thint = new TGTableLayoutHints(3,4, 3,4, kLHintsLeft, 20,20,5,5);
   fFG2Grps->AddFrame(fAllG1Btn, thint);
   fTrash->Add(thint);

   fG1TreeBox = new TGListBox(fFG2Grps, L_TREEBOX_GROUP1);
   fG1TreeBox->SetMultipleSelections(kTRUE);
   fG1TreeBox->Connect("SelectionChanged()", "XFilterFrame", this, "DoSelectTrees(Int_t)");
//   fG1TreeBox->Connect("Selected(Int_t)", "XFilterFrame", this, "DoSelectTrees(Int_t)");
   thint = new TGTableLayoutHints(4,6, 0,8, kLHintsLeft, 5,7,10,5);
   fFG2Grps->AddFrame(fG1TreeBox, thint);
   fG1TreeBox->Resize(230,317);
   fTrash->Add(thint);

   fRst2GBtn = new TGTextButton(fFG2Grps, " &Reset ", B_RESET_GROUP2);
   fRst2GBtn->Connect("Clicked()", "XFilterFrame", this, "DoSelectTrees()");
   fRst2GBtn->SetToolTipText("Unselect all trees");
   fRst2GBtn->SetState(kButtonDisabled);
   thint = new TGTableLayoutHints(1,2, 8,9, kLHintsLeft, 25,5,10,2);
   fFG2Grps->AddFrame(fRst2GBtn, thint);
   fTrash->Add(thint);

   fCheckPat = new TGCheckButton(fFG2Grps, "Select Groups", C_GROUP2SET);
   fCheckPat->SetState(kButtonUp);
   fCheckPat->Connect("Clicked()", "XFilterFrame", this, "DoSelectGroup()");
   thint = new TGTableLayoutHints(4,6, 9,10, kLHintsLeft, 5,5,10,2);
   fFG2Grps->AddFrame(fCheckPat, thint);
   fTrash->Add(thint);
}//CreateFrameSelectGroups

//______________________________________________________________________________
void XFilterFrame::DeleteFrameSelectGroups()
{
   if(kCS) cout << "------XFilterFrame::DeleteFrameSelectGroups------" << endl;

   delete fCheckPat; 
   delete fRst2GBtn; 

   delete fG1TreeBox; 
   delete fAllG1Btn; delete fRmvG1Btn; delete fAddG1Btn;

   delete fSelTreeBox;

   delete fFG2Grps;
}//DeleteFrameSelectGroups

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

   TGLayoutHints *hint = 0;

   fFGGrpPat = new TGGroupFrame(parent, "Group Sets", kVerticalFrame);
   hint = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 0, 0, 10, 10);
   parent->AddFrame(fFGGrpPat, hint);
   fTrash->Add(hint);

   fCFSelPat = new TGCompositeFrame(fFGGrpPat, 60, 20, kHorizontalFrame);
   hint = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX);
   fFGGrpPat->AddFrame(fCFSelPat, hint);
   fTrash->Add(hint);

   fLabS = new TGLabel(fCFSelPat, new TGString("Select Groups:"));
   hint = new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 10, 5);
   fCFSelPat->AddFrame(fLabS,hint);
   fTrash->Add(hint);
}//CreateFrameImportGroupSet

//______________________________________________________________________________
void XFilterFrame::DeleteFrameImportGroupSet()
{
   if(kCS) cout << "------XFilterFrame::DeleteFrameImportGroupSet------" << endl;

   delete fLabS; delete fCFSelPat;
   delete fFGGrpPat;
}//DeleteFrameImportGroupSet

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

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

   tabframe = tab->AddTab("Test");
   fFTUTest = new TGCompositeFrame(tabframe, 20, 20, kVerticalFrame);
   hint = new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 10, 5);
   tabframe->AddFrame(fFTUTest, hint);
   fTrash->Add(hint);

   fFGUTst = new TGGroupFrame(fFTUTest, "Select Test", kVerticalFrame | kFixedSize);
   fFTUTest->AddFrame(fFGUTst, fHintTL);
   fFGUTst->Resize(600,460);
}//CreateTabTest

//______________________________________________________________________________
void XFilterFrame::DeleteTabTest()
{
   if(kCS) cout << "------XFilterFrame::DeleteTabTest------" << endl;

   delete fFGUTst;
   delete fFTUTest;
}//DeleteTabTest

//______________________________________________________________________________
void guiTwoGroupsTest()
{
   new XFilterFrame(0, 400, 220);
//   new XFilterFrame(gClient->GetRoot(), 400, 220);
}