---

/Go4GUI/TGo4PreviewPanelSlots.cxx

Go to the documentation of this file.

//---------------------------------------------------------------
//        Go4 Release Package v2.10-5 (build 21005) 
//                      03-Nov-2005
//---------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//       Experiment Data Processing at DVEE department, GSI
//---------------------------------------------------------------
//
//Copyright (C) 2000- Gesellschaft f. Schwerionenforschung, GSI
//                    Planckstr. 1, 64291 Darmstadt, Germany
//Contact:            http://go4.gsi.de
//----------------------------------------------------------------
//This software can be used under the license agreements as stated
//in Go4License.txt file which is part of the distribution.
//----------------------------------------------------------------
#include "TGo4PreviewPanelSlots.h"

#include <iostream.h>

#include "TH1.h"
#include "TH2.h"
#include "TArrow.h"
#include "THStack.h"
#include "TMultiGraph.h"
#include "TCanvas.h"
#include "TFrame.h"
#include "TAxis.h"
#include "TLatex.h"
#include "TLegend.h"
#include "TLegendEntry.h"
#include "TKey.h"
#include "TFile.h"
#include "TProcessID.h"
#include "TGLabel.h"

#include "qstring.h"
#include "qinputdialog.h"

#include "qtroot/interface/tqrootwindow.h"
#include "Go4GUIRegistry/TGo4GUIRegistry.h"
#include "Go4ConditionsBase/TGo4WinCond.h"
#include "Go4ConditionsBase/TGo4WinCondView.h"
#include "Go4ConditionsBase/TGo4PolyCond.h"
#include "Go4ConditionsBase/TGo4PolyCondView.h"
#include "Go4ConditionsBase/TGo4Marker.h"
#include "TGo4PadOptions.h"
#include "TGo4MarkerSetup.h"
#include "TGo4PreviewPanelStatus.h"
#include "Go4FitGUI/TGo4FitPanelSlots.h"
#include "Go4FitGUI/TGo4FitGUIArrow.h"
#include "TGo4PreviewPanel.h"

#if __GO4ROOTVERSION__ > 40006
#include "TVirtualPadEditor.h"
#endif


TGo4PreviewPanelSlots::TGo4PreviewPanelSlots(const char * name, const char * title, TGo4PreviewPanel * p)
                       :TGo4SlotsBaseClass(name , title), fxTGo4PreviewPanel (p),
                      fiMouseMode(kMouseROOT), fuPickCounter(0),
                      fbTwoDimRegion(kFALSE) ,fbPickAgain(kFALSE), fbCreateNewMarker(kTRUE)
#if __GO4ROOTVERSION__ > 40006
                      , fxPeditor(0)
#endif
{
   // TGo4LockGuard Global;
      char StatusName[256];
   fxTGo4GUIRegistry = TGo4GUIRegistry::Instance();
   snprintf(StatusName,255,"%s%s",title,"_Status" );
   fxTGo4PreviewPanelStatus= new TGo4PreviewPanelStatus((Text_t *)StatusName,(Text_t *) title);
   fxTGo4PreviewPanelStatus->SetSlots(this);
   fxTGo4GUIRegistry->RegisterSlotClass(this, fxTGo4PreviewPanelStatus, p);
   fxMarkerList= new TList;
   gROOT->GetListOfCleanups()->Add(fxMarkerList);
   fxRegionList= new TList;
   gROOT->GetListOfCleanups()->Add(fxRegionList);
   fxPolygonList= new TList;
   gROOT->GetListOfCleanups()->Add(fxPolygonList);
   fxLateXList= new TList;
   fxLateXCleanups= new TList;
   gROOT->GetListOfCleanups()->Add(fxLateXCleanups);
   fxArrowList= new TList;
   fxArrowCleanups= new TList;
   gROOT->GetListOfCleanups()->Add(fxArrowCleanups);
   fxLegendCleanups= new TList;
   gROOT->GetListOfCleanups()->Add(fxLegendCleanups);

}

TGo4Status * TGo4PreviewPanelSlots::GetStatus()
{
   return fxTGo4PreviewPanelStatus;
}

void TGo4PreviewPanelSlots::SetGUI(TGo4PreviewPanel *GUI )
{
   fxTGo4PreviewPanel = GUI;
   fxTGo4GUIRegistry->GuiIsChanged(this, GUI);
}

void TGo4PreviewPanelSlots::DivideCanvas(int X, int Y)
{
   // TGo4LockGuard Global;
    fxTGo4PreviewPanel->Divide(X,Y);
}
TCanvas *TGo4PreviewPanelSlots::GetCanvas()
{
   return fxTGo4PreviewPanel->GetCanvas();
}
TGo4PreviewPanelSlots::~TGo4PreviewPanelSlots()
{

   // TGo4LockGuard Global;
   fxMarkerList->Delete();
   gROOT->GetListOfCleanups()->Remove(fxMarkerList);
   delete fxMarkerList;
   fxRegionList->Delete();
   gROOT->GetListOfCleanups()->Remove(fxRegionList);
   delete fxRegionList;
   fxPolygonList->Delete();
   gROOT->GetListOfCleanups()->Remove(fxPolygonList);
   delete fxPolygonList;
   gROOT->GetListOfCleanups()->Remove(fxLateXCleanups);
   delete fxLateXCleanups;
   fxLateXList->Delete();
   delete fxLateXList;
   gROOT->GetListOfCleanups()->Remove(fxArrowCleanups);
   delete fxArrowCleanups;
   fxArrowList->Delete();
   delete fxArrowList;
   fxLegendCleanups->Delete();
   gROOT->GetListOfCleanups()->Remove(fxLegendCleanups);
   delete fxLegendCleanups;
#if __GO4ROOTVERSION__ > 40006
   if(fxPeditor) fxPeditor->DeleteEditors(); // prevent problems with root's subeditor cache
   delete fxPeditor;   
#endif
   //delete fxEditorFrame;
   delete fxTGo4PreviewPanelStatus;
}

void TGo4PreviewPanelSlots::UpdatePad(TPad *Pad, TH1 *h1, Bool_t updatemarkers, Bool_t updateoptions)
{
   // TGo4LockGuard Global;
   Int_t Ymin;
   Int_t Ymax;
   Int_t Xmin;
   Int_t Xmax;
   QString Vtitle;
   if(h1!=0){
      Xmin   = 1 ;
      Xmax   = h1->GetNbinsX();
      if(h1->InheritsFrom("TH2")){
         Ymin   = 1;
         Ymax   = ((TH2 *)h1)->GetNbinsY();
      }else {
         Ymin   =(Int_t) h1->GetMinimum();
         Ymax   =(Int_t) (1.1 *(h1->GetMaximum()));
     }
      fxTGo4PreviewPanelStatus->SetPadDrawOption(Pad, Xmin, Xmax, Ymin, Ymax);
      //cout << "TGo4PreviewPanelSlots sees " << h1->GetDrawOption() << endl;
      if(updateoptions)
         fxTGo4PreviewPanelStatus->SetPadDrawOption(Pad, h1->GetDrawOption());
      if(!fxTGo4PreviewPanel->IsFreezeTitle())
         {
            Vtitle= fxTGo4PreviewPanel->name();
            Vtitle.append(h1->GetName());
            fxTGo4PreviewPanel->setCaption(Vtitle);
         }
   }else{
      if(updateoptions) fxTGo4PreviewPanelStatus->SetPadDrawOption(Pad,"");
   }
   if(updatemarkers) {
      ScanMarkers(Pad);
      SetMarkersHistogram();
      SetRegionsHistogram();
      SetPolygonsHistogram();
   }
   
   InformUpdatePad(Pad);   
}


void TGo4PreviewPanelSlots::UpdatePad(TPad *Pad, THStack *h1, Bool_t updatemarkers)
{
   // TGo4LockGuard Global;
   Int_t Ymin=0;
   Int_t Ymax=0;
   Int_t Xmin=0;
   Int_t Xmax=0;
   QString Vtitle;
   if(h1!=0)
      {
         if(h1->GetHists()->GetSize()>0) // check for non empty stack
            {
               Xmin   = 1 ;
               Xmax   = h1->GetXaxis()->GetNbins();
               Ymin   = (Int_t) h1->GetMinimum();
               Ymax   = (Int_t) (1.1 *(h1->GetMaximum()));
            }
         fxTGo4PreviewPanelStatus->SetPadDrawOption(Pad, Xmin, Xmax, Ymin, Ymax);
         fxTGo4PreviewPanelStatus->SetPadDrawOption(Pad, h1->GetDrawOption());
         if(!fxTGo4PreviewPanel->IsFreezeTitle())
            {
               Vtitle= fxTGo4PreviewPanel->name();
               Vtitle.append(h1->GetTitle());
               Vtitle.append(" : ");
               fxTGo4PreviewPanel->setCaption(Vtitle);
            }
      }
   else
      {
         fxTGo4PreviewPanelStatus->SetPadDrawOption(Pad,"");
      } // if(h1!=0)
   if(updatemarkers) 
      {
         ScanMarkers(Pad);
         SetMarkersHistogram();
         SetRegionsHistogram();
         SetPolygonsHistogram();
      }      
   InformUpdatePad(Pad);   
}

void TGo4PreviewPanelSlots::InformUpdatePad(TPad *Pad)
{
   TGo4FitPanelSlots* fitslts = dynamic_cast<TGo4FitPanelSlots*> 
      (fxTGo4GUIRegistry->GetSlotClass("TGo4FitPanelSlots"));
   if (fitslts!=0) {
     if (Pad==0) 
        fitslts->ViewPanelRemoved(fxTGo4PreviewPanel);
     else   
        fitslts->ViewPanelPadUpdate(fxTGo4PreviewPanel, Pad);
   }
}

void TGo4PreviewPanelSlots::AddObject(TNamed* obj, TQRootCanvas *c, TPad *p) 
{
   if (obj==0) return;

   if ((fxTGo4PreviewPanel==0) || (p==0)) return;

   if (obj->InheritsFrom(TGo4Condition::Class())) {
      TGo4PadOptions* opt = fxTGo4PreviewPanelStatus->GetPadOptions(p);
      if (opt)
        opt->SetCondition(dynamic_cast<TGo4Condition*> (obj));
   }

}

void TGo4PreviewPanelSlots::MouseClick(TPad* pad)
{
//SetMarkersHistogram();
//SetRegionsHistogram();
//SetPolygonsHistogram();
if(pad && pad==gPad)
   {
      Bool_t ok=kFALSE;
      Int_t px = 0;
      Int_t py = 0;
      Double_t x = 0;
      Double_t y = 0;
      Double_t xmin = 0;
      Double_t xmax = 0;
      Double_t ymin = 0;
      Double_t ymax = 0;
      Int_t ix=0;
      TH1* hist;
      TGo4Marker* mark=0;
      TGo4WinCond* conny=0;
      TLatex* latex=0;
      TString name;
      switch(fiMouseMode)
         {
         case kMouseROOT:
            //gROOT->cd(); // set root memory as dir for creating secondary histograms
            gROOT->SetEditorMode("");
            ActivateSelectedObject(pad);            
            break;

         case kMouseConditionEditor:
            // in this mode, picks are controlled from condition editor
            break;

         case kMousePickCursor:
            // we have a click on our working pad, get coordinates:
            gROOT->SetEditorMode("");
            px = pad->GetEventX();
            py = pad->GetEventY();
            x  = pad->PadtoX(pad->AbsPixeltoX(px));
            y  = pad->PadtoY(pad->AbsPixeltoY(py));

            if(IsCreateNewMarker())
               {
                  mark=new TGo4Marker(x,y,28);
                  fxMarkerList->Add(mark);
                  ix=TGo4Marker::GetInstances()-1;
                  mark->SetMarkerColor((ix)%6 +2);
                  mark->SetHistogram(fxTGo4PreviewPanel->GetPadHistogram(pad));
                  mark->Draw();
               }
            else
               {
                  mark= GetActiveMarker(pad);
                  if(mark)
                     {
                        mark->SetX(x);
                        mark->SetY(y);
                     }
               }
            pad->Modified();
            pad->Update();
            if(!IsPickAgain()) fiMouseMode=kMouseROOT; // reset pick
            break;

         case kMousePickLimits:
            gROOT->SetEditorMode("");
            px = pad->GetEventX();
            py = pad->GetEventY();
            x  = pad->PadtoX(pad->AbsPixeltoX(px));
            y  = pad->PadtoY(pad->AbsPixeltoY(py));
            if(fuPickCounter==0)
               {
                   // pick the first time after enabling limits record:
                  if(IsCreateNewMarker())
                     {
                        hist=fxTGo4PreviewPanel->GetPadHistogram(pad);
                        fbTwoDimRegion=(hist && hist->GetDimension()>1);
                        ix=fxRegionList->GetSize();
                        name="Region ";
                        name+=ix;
                        conny=new TGo4WinCond(name.Data());
                        if(fbTwoDimRegion)
                           conny->SetValues(0,0,0,0);
                        else
                           conny->SetValues(0,0);
                        conny->SetLineColor((ix)%6 +2);
                        conny->SetFillColor((ix)%6 +2);
                        conny->SetFillStyle(3002);
                        fxRegionList->Add(conny);
                        conny->SetWorkHistogram(hist);
                        conny->SetYRMSDraw(fbTwoDimRegion  && conny->IsXRMSDraw()); // adjust two dim region to one dim defaults
                        conny->SetYMeanDraw(fbTwoDimRegion && conny->IsXMeanDraw());
                        conny->SetYMaxDraw(fbTwoDimRegion && conny->IsXMaxDraw());
                        conny->Draw();
                     }
                  else
                     {
                        conny= GetActiveRegion(pad);
                     }
                  if(conny==0) return;
                  xmin=x;
                  xmax=x; //xmax=conny->GetXUp();
                  ymin=y;
                  ymax=y; //ymax=conny->GetYUp();
                  fuPickCounter++;
               }
            else if (fuPickCounter==1)
               {
                  conny= GetActiveRegion(pad);
                  if(conny==0) return;
                  xmin=conny->GetXLow();
                  xmax=x;
                  ymin=conny->GetYLow();
                  ymax=y;
                  if(!IsPickAgain()) fiMouseMode=kMouseROOT; // reset pick
                  fuPickCounter=0;
               }
            else
               {
                  cout <<"TGo4PreviewPanelSlots::Click() NEVER COME HERE" << endl;
                  return;
               }
            if(conny->GetDimension()>1) // do not change original condition dimension
               conny->SetValues(xmin,xmax,ymin,ymax);
            else
               conny->SetValues(xmin,xmax);
            break;

         case kMousePickLatex:
            gROOT->SetEditorMode("");
            ScanMarkers(pad);
            px = pad->GetEventX();
            py = pad->GetEventY();
            x  = pad->PadtoX(pad->AbsPixeltoX(px));
            y  = pad->PadtoY(pad->AbsPixeltoY(py));
            if(IsCreateNewMarker())
               {
                  ix=fxLateXList->GetSize();
                  name="Label ";
                  name+=ix;
                  latex=new TLatex(x,y,name.Data());
                  latex->SetName(name.Data());
                  AddLatex(latex,pad);
                  latex->Draw();
                  name = (const char*) QInputDialog::getText(
                          "Enter new LaTeX label text:",
                          name.Data(),
                          QLineEdit::Normal, QString::null, &ok);
                  if ( ok && !name.IsNull() )
                     latex->SetTitle(name.Data()); // user entered something and pressed OK
               }
            else
               {
                  latex=GetActiveLatex(pad);
                  if(latex)
                     {
                        latex->SetX(x);
                        latex->SetY(y);
                     }
               }
            pad->Modified();
            pad->Update();
            if(!IsPickAgain()) fiMouseMode=kMouseROOT;
            break;


         case kMousePickPolygon:
            if(fuPickCounter==0) gROOT->SetEditorMode("CutG");
            fuPickCounter++;
            if(gROOT->GetEditorMode()!=kCutG)
               {
                  // after final doubleclick, root will reset mode!
                  if(IsCreateNewMarker())
                        ScanCutG(pad); // this will create new polycond
                  else
                        ScanCutG(pad,GetActivePolygon(pad));  
                  fuPickCounter=0;
                  if(!IsPickAgain()) fiMouseMode=kMouseROOT; 
               }
            break;

         case kMouseDraw:
            gROOT->SetEditorMode("Arrow");
            if(!IsPickAgain())
               fiMouseMode=kMouseROOT;
            ScanMarkers(pad);
            break;

         default:
            break;

      } // switch(fiMouseMode)
   fxTGo4PreviewPanel->RefreshButtons();
   } //if(pad==gPad)

}

void TGo4PreviewPanelSlots::ScanMarkers(TVirtualPad* pad)
{
   if(pad==0) return;
   TObject *entry = 0;
   TList* primcopy=new TList;
   primcopy->AddAll(pad->GetListOfPrimitives());
   TIter iter(primcopy); // work on copy of primitives list, since Add method might draw inside iterator!
   //TIter iter(pad->GetListOfPrimitives());
   while((entry = iter()) != 0)  {
      if(entry->InheritsFrom("TLatex")) {
         // scan for latex labels that were created with rmb
         // register these as a clone, since Clear will delete original in root
         //cout <<"ScanMarkers found latex "<<entry->GetName()<< ":"<<entry << endl;
         TLatex* latex=dynamic_cast<TLatex*> (entry);
         AddLatex(latex, pad, kTRUE); 
         
       } else 
       if (entry->InheritsFrom("TArrow")) {
          //cout <<"ScanMarkers found arrow "<<entry->GetName() << endl;
          TArrow* arr = dynamic_cast<TArrow*> (entry);
          AddArrow(arr, pad, kTRUE);
       } else 
       if(entry->InheritsFrom("TGo4Marker")) {
          //cout <<"ScanMarkers found marker "<<entry->GetName() << endl;
          TGo4Marker* mark=dynamic_cast<TGo4Marker*> (entry);
          AddMarker(mark, pad, kFALSE);
       } else 
       if(entry->InheritsFrom("TGo4WinCond")) {
          //cout <<"ScanMarkers found window "<<entry->GetName() << endl;
          TGo4WinCond* conny=dynamic_cast<TGo4WinCond*> (entry);
          AddRegion(conny, pad, kFALSE);
       } else 
       if(entry->InheritsFrom("TGo4PolyCond")) {
          //cout <<"ScanMarkers found polygon "<<entry->GetName() << endl;
          TGo4PolyCond* conny=dynamic_cast<TGo4PolyCond*> (entry);
          AddPolygon(conny, pad, kFALSE);
       }   
         
// in principle; however, since insertCanvas clones all primitives,
// the references in loaded legend are wrong, thus causing double
// entries in DrawLegend after next add of superimposed histo . To be solved later... JA
//       else if(entry->InheritsFrom("TLegend"))
//         {
//            TLegend* leg=dynamic_cast<TLegend*> (entry);
//            TLegend* oldleg=0;
//            TGo4PadOptions* pop=fxTGo4PreviewPanelStatus->GetPadOptions((TPad*)pad);
//            if(pop) 
//               {
//                  oldleg=pop->GetLegend();       
//                  if(oldleg!=leg) 
//                     {
//                        pop->SetLegend(leg);
//                        if(fxLegendCleanups->Remove(oldleg)) delete oldleg;
//                        fxLegendCleanups->AddLast(leg);
//                     }
//               }
//         }

   } // while
primcopy->Clear("nodelete");
delete primcopy;
}


void TGo4PreviewPanelSlots::ScanCutG(TVirtualPad* pad, TGo4PolyCond* toupdate)
{
if(pad==0) return;
TVirtualPad* padsav=gPad;
pad->cd();
TObject *entry = 0;
TList* primlist=pad->GetListOfPrimitives();
TIter iter(primlist);
TCutG* CG=0;
TCutG* newcut=0;
while((entry = iter()) != 0)
   {
      if(entry->InheritsFrom("TCutG"))
            {
               CG = dynamic_cast<TCutG *> (entry);
               if(CG && CG->GetLineColor()==1)
                  {
                     // root always (?) sets color of new edited cut to black
                     // our old cuts are never black! ergo:
                     newcut=CG;
                     break;
                  }
            }
   }
if (newcut)
   {
      TH1* hist=fxTGo4PreviewPanel->GetPadHistogram((TPad*)pad);         
      TGo4PolyCond* conny=0;
      if(toupdate)
         { 
            conny=toupdate;
            conny->SetValues(newcut);
         }
      else
         {
            Int_t ix=fxPolygonList->GetSize();
            TString name="Polygon ";
            name+=ix;                     
            conny=new TGo4PolyCond(name.Data());
            conny->SetValues(newcut); // do this before setting new colors!
            conny->SetLineColor((ix)%6 +2);
            conny->SetFillColor((ix)%6 +2);
            conny->SetFillStyle(3002); 
            fxPolygonList->AddLast(conny);
         }         
      delete newcut;                 
      conny->SetWorkHistogram(hist);      
      if(toupdate==0) conny->Draw();         
   }
padsav->cd();
}

Bool_t TGo4PreviewPanelSlots::AddLatex(TLatex* lax, TVirtualPad* pad, Bool_t clone)
{
if(lax==0 || pad==0) return kTRUE;
// do we already have this latex in our list?
TVirtualPad* padsav=gPad;
pad->cd();
Bool_t alreadythere=kFALSE;
TIterator* liter=fxLateXList->MakeIterator();
TObject* ob=0;
TGo4LateXEntry* lentry=0;
while((ob=liter->Next())!=0)
{
   lentry=dynamic_cast<TGo4LateXEntry*>(ob);
   if(lax==lentry->GetLateX())
      {
         lentry->fxPad=pad;
         alreadythere=kTRUE;
         break;
      }
}
delete liter;
if(!alreadythere)
   {
      TLatex* novum=lax;
      if(clone)
        {
            novum= (TLatex*) lax->Clone();
            delete lax; // we continue working on the clone
            novum->Draw();
        }
      fxLateXList->AddLast( new TGo4LateXEntry(novum,pad));
      fxLateXCleanups->AddLast(novum);

   }
padsav->cd();
return alreadythere;
}

Bool_t TGo4PreviewPanelSlots::AddArrow(TArrow* arr, TVirtualPad* pad, Bool_t clone)
{
if(arr==0 || pad==0) return kTRUE;

// supress stealing arrows from fitgui
if (dynamic_cast<TGo4FitGUIArrow*>(arr)!=0) return kTRUE;
// if(arr->InheritsFrom("TGo4FitGUIArrow")) return;
 
// do we already have this latex in our list?
TVirtualPad* padsav=gPad;
pad->cd();
Bool_t alreadythere=kFALSE;
TIterator* liter=fxArrowList->MakeIterator();
TObject* ob=0;
TGo4ArrowEntry* arentry=0;
while((ob=liter->Next())!=0)
{
   arentry=dynamic_cast<TGo4ArrowEntry*>(ob);
   if(arr==arentry->GetArrow())
      {
         arentry->fxPad=pad;
         alreadythere=kTRUE;
         break;
      }
}
delete liter;
if(!alreadythere)
   {
      TArrow* novum=arr;
      if(clone)
        {
            novum= (TArrow*) arr->Clone();
            delete arr; // we continue working on the clone
            novum->Draw();
        }
      fxArrowList->AddLast( new TGo4ArrowEntry(novum,pad));
      fxArrowCleanups->AddLast(novum);

   }
padsav->cd();
return alreadythere;
}

Bool_t TGo4PreviewPanelSlots::AddMarker(TGo4Marker* mk, TVirtualPad* pad, Bool_t clone)
{
if(mk==0 || pad==0) return kTRUE;
// do we already have this marker in our list?
TVirtualPad* padsav=gPad;
pad->cd();
Bool_t alreadythere=kFALSE;
TIterator* liter=fxMarkerList->MakeIterator();
TObject* ob=0;
TGo4Marker* old=0;
while((ob=liter->Next())!=0)
{
   old=dynamic_cast<TGo4Marker*>(ob);
   if(mk==old)
      {
         alreadythere=kTRUE;
         break;
      }
}
delete liter;
if(!alreadythere)
   {
      TGo4Marker* novum=mk;
      if(clone)
        {
            novum= (TGo4Marker*) mk->Clone();
            delete mk; // we continue working on the clone
            novum->Draw();
        }
      fxMarkerList->AddLast(novum);

   }
padsav->cd();
return alreadythere;
}

Bool_t TGo4PreviewPanelSlots::AddRegion(TGo4WinCond* con, TVirtualPad* pad, Bool_t clone)
{
if(con==0 || pad==0) return kTRUE;
// test if this region belongs to condition editor:
if(con->IsOwnedByEditor()) return kTRUE;
// do we already have this in our list?
TVirtualPad* padsav=gPad;
pad->cd();
Bool_t alreadythere=kFALSE;
TIterator* liter=fxRegionList->MakeIterator();
TObject* ob=0;
TGo4WinCond* old=0;
while((ob=liter->Next())!=0)
{
   old=dynamic_cast<TGo4WinCond*>(ob);
   if(con==old)
      {
         alreadythere=kTRUE;
         break;
      }
}
delete liter;
if(!alreadythere)
   {
      TGo4WinCond* novum=con;
      if(clone)
        {
            novum= (TGo4WinCond*) con->Clone();
            delete con; // we continue working on the clone
            novum->Draw();
        }
      fxRegionList->AddLast(novum);
   }
padsav->cd();
return alreadythere;
}


Bool_t TGo4PreviewPanelSlots::AddPolygon(TGo4PolyCond* con, TVirtualPad* pad, Bool_t clone)
{
if(con==0 || pad==0) return kTRUE;
// test if this region belongs to condition editor:
if(con->IsOwnedByEditor()) return kTRUE;
// do we already have this in our list?
TVirtualPad* padsav=gPad;
pad->cd();
Bool_t alreadythere=kFALSE;
TIterator* liter=fxPolygonList->MakeIterator();
TObject* ob=0;
TGo4PolyCond* old=0;
while((ob=liter->Next())!=0)
{
   old=dynamic_cast<TGo4PolyCond*>(ob);
   if(con==old)
      {
         alreadythere=kTRUE;
         break;
      }
}
delete liter;
if(!alreadythere)
   {
      TGo4PolyCond* novum=con;
      if(clone)
        {
            novum= (TGo4PolyCond*) con->Clone();
            delete con; // we continue working on the clone
            novum->Draw();
        }
      fxPolygonList->AddLast(novum);
   }
padsav->cd();
return alreadythere;
}




void TGo4PreviewPanelSlots::ActivateSelectedObject(TVirtualPad* pad)
{
if(pad==0) return;
TObject* selected=pad->GetSelected();
if(selected)
   {
      if(selected->InheritsFrom("TGo4Marker"))
         {
            TIterator* liter=fxMarkerList->MakeIterator();
            TObject* ob=0;
            while((ob=liter->Next())!=0)
               {
                  if(ob==selected)
                     {
                        fxMarkerList->Remove(ob);
                        fxMarkerList->AddLast(ob);
                        fiMouseMode=kMouseSelectObject;
                        fxSelectedName=selected->GetName();
                        break;
                     }
               }
            delete liter;
         }
      else if (selected->InheritsFrom("TGo4WinCondView"))
         {
            TGo4WinCondView* conview=dynamic_cast<TGo4WinCondView*>(selected);
            TObject* conny=conview->GetCondition();
            TIterator* liter=fxRegionList->MakeIterator();
            TObject* ob=0;
            while((ob=liter->Next())!=0)
               {
                  if(ob==conny)
                     {
                        fxRegionList->Remove(ob);
                        fxRegionList->AddLast(ob);
                        fiMouseMode=kMouseSelectObject;
                        fxSelectedName=selected->GetName();
                        break;
                     }
               }
            delete liter;


         }
      else if (selected->InheritsFrom("TGo4PolyCondView"))
         {
            TGo4PolyCondView* conview=dynamic_cast<TGo4PolyCondView*>(selected);
            TObject* conny=conview->GetCondition();
            TIterator* liter=fxPolygonList->MakeIterator();
            TObject* ob=0;
            while((ob=liter->Next())!=0)
               {
                  if(ob==conny)
                     {
                        fxPolygonList->Remove(ob);
                        fxPolygonList->AddLast(ob);
                        fiMouseMode=kMouseSelectObject;
                        fxSelectedName=selected->GetName();
                        break;
                     }
               }
            delete liter;


         }   
         
      else if (selected->InheritsFrom("TLatex"))
         {
            TIter liter(fxLateXList);
            TObject* ob=0;
            while((ob=liter())!=0)
               {
                  TGo4LateXEntry* latexref=dynamic_cast<TGo4LateXEntry*>(ob);
                  if(selected==latexref->fxObject)
                     {
                        fxLateXList->Remove(ob);
                        fxLateXList->AddLast(ob);
                        fiMouseMode=kMouseSelectObject;
                        fxSelectedName=selected->GetTitle();
                        break;
                     }
               } // while
         }
      else
         {
            // not one of our objects
         }

   }

}

TGo4Marker* TGo4PreviewPanelSlots::GetActiveMarker(TVirtualPad* )
{
   return (TGo4Marker*) fxMarkerList->Last();
}

const Text_t* TGo4PreviewPanelSlots::GetActiveMarkerName(TVirtualPad* pad)
{
   TGo4Marker* act=GetActiveMarker(pad);
   if(act)
      return act->GetName();
   else
      return 0;
}

TGo4WinCond* TGo4PreviewPanelSlots::GetActiveRegion(TVirtualPad* )
{
  return (TGo4WinCond*) fxRegionList->Last();
}

const Text_t* TGo4PreviewPanelSlots::GetActiveRegionName(TVirtualPad* pad)
{
   TGo4WinCond* act=GetActiveRegion(pad);
   if(act)
      return act->GetName();
   else
      return 0;
}

TGo4PolyCond* TGo4PreviewPanelSlots::GetActivePolygon(TVirtualPad* )
{
  return (TGo4PolyCond*) fxPolygonList->Last();
}

const Text_t* TGo4PreviewPanelSlots::GetActivePolygonName(TVirtualPad* pad)
{
   TGo4PolyCond* act=GetActivePolygon(pad);
   if(act)
      return act->GetName();
   else
      return 0;
}


TLatex* TGo4PreviewPanelSlots::GetActiveLatex(TVirtualPad* pad)
{
// we search for latest latex object on the working pad pad
TLatex* latex=0;
TObject* ob=0;
TIter liter(fxLateXList, kIterBackward);
while((ob=liter())!=0)
   {
      TGo4LateXEntry* latexref=dynamic_cast<TGo4LateXEntry*>(ob);
      if(pad==latexref->fxPad)
         {
            latex= latexref->GetLateX();
            break;
         }
   } // while
return latex;
}

const Text_t* TGo4PreviewPanelSlots::GetActiveLatexName(TVirtualPad* pad)
{
   TLatex* act=GetActiveLatex(pad);
   if(act)
      return act->GetTitle(); // latex text is root title, not name
   else
      return 0;
}

void TGo4PreviewPanelSlots::SetRegionsHistogram()
{
TPad* workpad=0;
TH1* hist=0;
TIter liter(fxRegionList);
TObject* ob=0;
TGo4Condition* con=0;
while((ob=liter.Next())!=0)
   {
      con=dynamic_cast<TGo4Condition*>(ob);
      workpad= (TPad*) con->GetDrawPad();
      hist=fxTGo4PreviewPanel->GetPadHistogram(workpad);
      con->SetWorkHistogram(hist);
      //cout <<"SetRegionsHistogram for"<<con->GetName() << endl;
   }
}


void TGo4PreviewPanelSlots::SetPolygonsHistogram()
{
TPad* workpad=0;
TH1* hist=0;
TIter liter(fxPolygonList);
TObject* ob=0;
TGo4Condition* con=0;
while((ob=liter.Next())!=0)
   {
      con=dynamic_cast<TGo4Condition*>(ob);
      workpad= (TPad*) con->GetDrawPad();
      hist=fxTGo4PreviewPanel->GetPadHistogram(workpad);
      con->SetWorkHistogram(hist);
      //cout <<"SetPolygonsHistogram for"<<con->GetName() << endl;
   }
}

void TGo4PreviewPanelSlots::SetMarkersHistogram()
{
TPad* workpad=0;
TH1* hist=0;
TIter liter(fxMarkerList);
TObject* ob=0;
TGo4Marker* mark=0;
while((ob=liter.Next())!=0)
   {
      mark=dynamic_cast<TGo4Marker*>(ob);
      workpad=(TPad*) mark->GetDrawPad();
      hist=fxTGo4PreviewPanel->GetPadHistogram(workpad);
      mark->SetHistogram(hist);
      //cout <<"SetMarkersHistogram for"<<mark->GetName() << endl;
   }

}

void TGo4PreviewPanelSlots::RedrawAllLabels(TVirtualPad* pad) {
  if(pad==0) return;
  ScanMarkers(pad); // make sure to redraw most recently drawn labels
  
  TVirtualPad* padsav=gPad;
  gPad=pad;
  TIterator* liter=fxMarkerList->MakeIterator();
  TObject* ob=0;
  TGo4Marker* mark=0;
  while((ob=liter->Next())!=0)  {
     mark=dynamic_cast<TGo4Marker*>(ob);
     if(gPad==mark->GetDrawPad()) mark->Draw(); // only restor if this was
                                              // the original draw pad
  }
  delete liter;
  // window conditions:
  liter=fxRegionList->MakeIterator();
  TGo4Condition* con=0;
  while((ob=liter->Next())!=0) {
     con=dynamic_cast<TGo4Condition*>(ob);
     if(gPad==con->GetDrawPad()) con->Draw(); // condition checks if already in primitives list
   }
   delete liter;

   // polygon conditions:
   liter=fxPolygonList->MakeIterator();
   while((ob=liter->Next())!=0) {
      con=dynamic_cast<TGo4Condition*>(ob);
      if(gPad==con->GetDrawPad()) con->Draw();// condition checks if already in primitives list
   }
   delete liter;

   // list of latexes:
   liter=fxLateXList->MakeIterator();
   TGo4LateXEntry* lentry=0;
   while((ob=liter->Next())!=0) {
      lentry=dynamic_cast<TGo4LateXEntry*>(ob);
      if(gPad==lentry->fxPad) {
         TLatex* latex=lentry->GetLateX();
         if(fxLateXCleanups->FindObject(latex))// only redraw if latex still there
            {
               //cout <<"Redraw latex:"<<latex<< " - "<<latex->GetTitle() << endl;
               if(gPad->GetListOfPrimitives()->FindObject(latex)==0)
                  latex->Draw(); // avoid double entries in list of primitives!
            }
         else
            {
               fxLateXList->Remove(ob); // clean list of references
               //cout <<"## Removed latex object: "<<ob<< endl;
               liter->Reset();
            }
      }
   }
   delete liter;

// list of arrows:
   liter=fxArrowList->MakeIterator();
   TGo4ArrowEntry* arentry=0;
   while((ob=liter->Next())!=0) {
      arentry=dynamic_cast<TGo4ArrowEntry*>(ob);
      if(gPad==arentry->fxPad)
      {
         TArrow* arr=arentry->GetArrow();
         if(fxArrowCleanups->FindObject(arr))// only redraw if latex still there
            {
               //cout <<"Redraw arrow:"<<arr<< " - "<<arr->GetTitle() << endl;
               if(gPad->GetListOfPrimitives()->FindObject(arr)==0)
                  arr->Draw(); // avoid double entry in primitives list
            }
         else
            {
               fxArrowList->Remove(ob); // clean list of references
               //cout <<"## Removed arrow object: "<<ob<< endl;
               liter->Reset();
            }
      }
   }
   delete liter;

   pad->Modified();
   pad->Update();
   gPad=padsav;
}

void TGo4PreviewPanelSlots::ClearAllLabels(TVirtualPad* pad)
{
ScanMarkers(pad); // update list to delete most recently created labels
//------- list of cursor markers: ----------------
TIterator* liter=fxMarkerList->MakeIterator();
TObject* ob=0;
TGo4Marker* mark=0;
while((ob=liter->Next())!=0)
{
   mark=dynamic_cast<TGo4Marker*>(ob);
   if(pad == 0 || pad==mark->GetDrawPad())
      {
         fxMarkerList->Remove(mark);
         delete mark;
         liter->Reset();
      }
}
delete liter;
//------- list of window regions: ----------------
liter=fxRegionList->MakeIterator();
TGo4Condition* con=0;
while((ob=liter->Next())!=0)
{
   con=dynamic_cast<TGo4Condition*>(ob);
   if(pad==0 || pad==con->GetDrawPad())
      {
         fxRegionList->Remove(con);
         delete con;
         liter->Reset();
      }
}
delete liter;

//------- list of polygon regions: ----------------
liter=fxPolygonList->MakeIterator();
while((ob=liter->Next())!=0)
{
   con=dynamic_cast<TGo4Condition*>(ob);
   if(pad==0 || pad==con->GetDrawPad())
      {
         fxPolygonList->Remove(con);
         delete con;
         liter->Reset();
      }
}
delete liter;

//------- list of latexes: -----------------------
liter=fxLateXList->MakeIterator();
TGo4LateXEntry* lentry=0;
while((ob=liter->Next())!=0)
{
   lentry=dynamic_cast<TGo4LateXEntry*>(ob);
   if(pad==0 || pad==lentry->fxPad)
      {
         fxLateXList->Remove(lentry);
         if(fxLateXCleanups->Remove(lentry->GetLateX()))
                     delete lentry->GetLateX(); // only delete if still in root
         lentry->fxObject=0; // prevent lentry dtor deleting the latex again
         delete lentry;
         liter->Reset();
      }
}
delete liter;

//------- list of arrows: -----------------------
liter=fxArrowList->MakeIterator();
TGo4ArrowEntry* arentry=0;
while((ob=liter->Next())!=0)
{
   arentry=dynamic_cast<TGo4ArrowEntry*>(ob);
   if(pad==0 || pad==arentry->fxPad)
      {
         fxArrowList->Remove(arentry);
         if(fxArrowCleanups->Remove(arentry->GetArrow()))
                  delete arentry->GetArrow(); // only delete if still in root
         arentry->fxObject=0;
         delete arentry;
         liter->Reset();
      }
}
delete liter;

}

void TGo4PreviewPanelSlots::DrawLegend(TVirtualPad* pad, TObject* ob)
{
if(pad==0 || ob==0) return;
TVirtualPad* padsav=gPad;
gPad=pad;   
THStack* st=dynamic_cast<THStack*>(ob);
TMultiGraph* mg=dynamic_cast<TMultiGraph*>(ob);
TList* hlist=0;
TString doption;
//TString header=ob->GetName();
if(st)
   {
      //cout <<"Legend for stack" << endl;      
      hlist=st->GetHists();
      doption="l";    
   }
else if (mg)
   {
      //cout <<"Legend for multigraph" << endl;
      hlist=mg->GetListOfGraphs();
      doption="p"; 
   }
else
   {
      //cout <<"No Legend for "<<ob->IsA()->GetName() << endl;
   } // if(st) etc
if(hlist) 
   {
      TLegend* leg=0;
      TGo4PadOptions* pop=fxTGo4PreviewPanelStatus->GetPadOptions((TPad*)pad);
      if(pop) leg=pop->GetLegend();      
      if(leg==0 || fxLegendCleanups->FindObject(leg)==0)
         {
            // first creation, or existing legend was deleted by root user
            leg=new TLegend(0.6,0.6,0.89,0.89); //(0.4,0.6,0.7,0.89)
            if(pop) pop->SetLegend(leg);
            fxLegendCleanups->AddLast(leg);
            //leg->SetHeader(header.Data());
         }
      else
         {
          // might clear the label here?  
         }
      TList* leglist=leg->GetListOfPrimitives();
      TObject* lob=0;
      TLegendEntry* lentry=0;
      TIter liter(leglist);      
      TObject* stob=0;      
      TIter stiter(hlist);
      while((stob=stiter.Next())!=0)
         {
            // test if this object has already entry in existing legend:
            bool alreadythere=false;
            while((lob=liter.Next())!=0)
               {
                  lentry=dynamic_cast<TLegendEntry*>(lob);
                  if(lentry->GetObject()==stob)
                     {
                        alreadythere=true;
                        break;  
                     }  
               }
            if(!alreadythere)
               leg->AddEntry(stob,stob->GetName(),doption.Data());
         }
      leg->Draw();
   } // if(hlist)      
pad->Modified();
pad->Update();
gPad=padsav;
}

void TGo4PreviewPanelSlots::ClearLegend(TVirtualPad* pad, Bool_t del)
{
if(pad==0)
   {
    // this mode deletes every label in list, for clear canvas functions:  
    fxLegendCleanups->Delete();   
   }
else
   {
   // remove label from given pad. Eventually delete it if del is true
   TList* primlist = pad->GetListOfPrimitives();
   TIterator* liter=primlist->MakeIterator();
   TObject* ob=0;
   TLegend* leg=0;
   while((ob=liter->Next())!=0)
   {
      // note: existing legend is not in list of primitives anymore after stack draw!
      // just for the principle...
      leg=dynamic_cast<TLegend*>(ob);
      if(leg)
         {
            primlist->Remove(leg);
            liter->Reset();
         }
   }
   delete liter;
   // because after Draw of Stack, legend is removed from primlist by root!
   if(del)
      {
           leg=0; 
           TGo4PadOptions* pop=fxTGo4PreviewPanelStatus->GetPadOptions((TPad*)pad);     
           if(pop)
            { 
               leg=pop->GetLegend(); 
               pop->SetLegend(0);
            }
           if(fxLegendCleanups->Remove(leg)) delete leg;
      }
   pad->Modified();
   pad->Update();
   }
}


void TGo4PreviewPanelSlots::LogMarkers(Option_t* opt)
{
//---------- cursor markers:
TIterator* markers=fxMarkerList->MakeIterator();
TObject* ob=0;
while((ob=markers->Next())!=0)
{
   ob->Print(opt);
}
delete markers;
//---------- window regions:
TString option=opt;
option+="-limits-stats";
TIterator* regions=fxRegionList->MakeIterator();
while((ob=regions->Next())!=0)
{
   ob->Print(option.Data());
}
delete regions;

//---------- polygon regions:
regions=fxPolygonList->MakeIterator();
while((ob=regions->Next())!=0)
{
   ob->Print(option.Data());
}
delete regions;

//----------- latex labels:
TIterator* latexts=fxLateXCleanups->MakeIterator();
while((ob=latexts->Next())!=0)
{
   ob->Print(opt);
}
delete latexts;
//----------- arrows :
TIterator* arrows=fxArrowCleanups->MakeIterator();
while((ob=arrows->Next())!=0)
{
   ob->Print(opt);
}
delete arrows;



}

void TGo4PreviewPanelSlots::BuildPadEditor(TQRootWindow* qtframe)
{
#if __GO4ROOTVERSION__ > 40006
if(qtframe==0) return;
if(fxPeditor!=0) return;
qtframe->SetEditable(); // mainframe will adopt pad editor window
fxPeditor=TVirtualPadEditor::LoadEditor();
qtframe->SetEditable(0);// back to window manager as root window         

//TGVButtonGroup *bg = new TGVButtonGroup(qtframe->GetRootFrame()); 
//TGRadioButton* rb= new TGRadioButton(bg,"click for test");
//TGTextButton *button1 = new TGTextButton(bg,"some text");         
//TGTextButton *button2 = new TGTextButton(bg,"another text");  
//qtframe->AddSubFrame(bg);



#endif
   // 31002
}



void TGo4PreviewPanelSlots::CleanupPadEditor()
{
#if __GO4ROOTVERSION__ > 40006
if(fxPeditor) fxPeditor->DeleteEditors();
#endif
   // 31002   
}



void TGo4PreviewPanelSlots::SaveMarkerSetup(const Text_t* filename, const Text_t* statusname, TVirtualPad* pad)
{
TFile outfile(filename, "UPDATE");
TGo4MarkerSetup* state=CreateMarkerSetup(pad);
if(statusname) state->SetName(statusname);
outfile.cd();
state->Write();
outfile.Close();
delete state;
}

void TGo4PreviewPanelSlots::LoadMarkerSetup(const Text_t* filename, const Text_t* statusname, TVirtualPad* pad)
{
TFile infile(filename, "READ");
TGo4MarkerSetup* state=0;
if(statusname)
   {
      state= dynamic_cast<TGo4MarkerSetup*>(infile.FindObjectAny(statusname));
   }
else
   {
      TKey* kee=0;
      TIter iter(infile.GetListOfKeys());
      while ( ( kee=dynamic_cast<TKey*>(iter()) ) !=0 )
         {
            state = dynamic_cast<TGo4MarkerSetup*>(kee->ReadObj());
            if (state) break; // we take first status in file, disregarding its name...
         }
   }
SetMarkerSetup(state,pad);
TGo4PolyCond::CleanupSpecials(); 
}

TGo4MarkerSetup* TGo4PreviewPanelSlots::CreateMarkerSetup(TVirtualPad* viewpad)
{
//TVirtualPad* padsav=gPad;
TVirtualPad* pad=viewpad;
if(pad==0) pad= fxTGo4PreviewPanel->GetActivePad();
ScanMarkers(pad); // make sure to redraw most recently drawn labels
TGo4MarkerSetup* state= new TGo4MarkerSetup(GetName());

// markers:
TIterator* liter=fxMarkerList->MakeIterator();
TObject* ob=0;
TGo4Marker* mark=0;
while((ob=liter->Next())!=0)
{
   mark=dynamic_cast<TGo4Marker*>(ob);
   if(pad==mark->GetDrawPad())
         state->fxMarkerList->Add(mark->Clone()); // only save current pad objects
}
delete liter;

// window conditions:
liter=fxRegionList->MakeIterator();
TGo4Condition* con=0;
while((ob=liter->Next())!=0)
{
   con=dynamic_cast<TGo4Condition*>(ob);
   if(pad==con->GetDrawPad())
      state->fxRegionList->Add(con->Clone());
}
delete liter;

// polygon conditions:
liter=fxPolygonList->MakeIterator();
while((ob=liter->Next())!=0)
{
   con=dynamic_cast<TGo4Condition*>(ob);
   if(pad==con->GetDrawPad())
      state->fxPolygonList->Add(con->Clone());
}
delete liter;

// list of latexes:
liter=fxLateXList->MakeIterator();
TGo4LateXEntry* lentry=0;
while((ob=liter->Next())!=0)
{
   lentry=dynamic_cast<TGo4LateXEntry*>(ob);
   if(pad==lentry->fxPad && fxLateXCleanups->FindObject(lentry->GetLateX()))
               state->fxLateXList->Add(lentry->Clone()); // only clone if label is still there
}
// list of arrows:
liter=fxArrowList->MakeIterator();
TGo4ArrowEntry* arentry=0;
while((ob=liter->Next())!=0)
{
   arentry=dynamic_cast<TGo4ArrowEntry*>(ob);
   if(pad==arentry->fxPad && fxArrowCleanups->FindObject(arentry->GetArrow()))
               state->fxArrowList->Add(arentry->Clone());
}
delete liter;
//if(padsav) padsav->cd();
return state;
}

void TGo4PreviewPanelSlots::SetMarkerSetup(TGo4MarkerSetup* state, TVirtualPad* viewpad)
{
if(state==0) return;
TVirtualPad* padsav=gPad;
TVirtualPad* pad=viewpad;
if(pad==0) pad= fxTGo4PreviewPanel->GetActivePad();
pad->cd();
TH1* hist=fxTGo4PreviewPanel->GetPadHistogram((TPad*) pad);
// first delete old markers on work pad:
ClearAllLabels(pad);

TIterator* liter=state->fxMarkerList->MakeIterator();
TObject* ob=0;
while((ob=liter->Next())!=0)
{
   TGo4Marker* mark=dynamic_cast<TGo4Marker*>(ob->Clone());
   fxMarkerList->Add(mark);
   mark->SetHistogram(hist);
   mark->Draw();
}
delete liter;

//gROOT->GetListOfCleanups()->Add(fxRegionList);
liter=state->fxRegionList->MakeIterator();
while((ob=liter->Next())!=0)
{
   TGo4Condition* con=dynamic_cast<TGo4Condition*>(ob->Clone());
   fxRegionList->Add(con);
   con->SetWorkHistogram(hist);
   con->Draw();
}
delete liter;

liter=state->fxPolygonList->MakeIterator();
while((ob=liter->Next())!=0)
{
   TGo4Condition* con=dynamic_cast<TGo4Condition*>(ob->Clone());
   fxPolygonList->Add(con);
   con->SetWorkHistogram(hist);
   con->Draw();
}
delete liter;


liter=state->fxLateXList->MakeIterator();
while((ob=liter->Next())!=0)
{
   TGo4GraphicEntry* gx= (TGo4GraphicEntry*) ob->Clone();
   TObject* lax=gx->fxObject;
   fxLateXList->AddLast(gx);
   fxLateXCleanups->Add(lax);
   gx->fxPad=pad;
   lax->Draw();
}
delete liter;
liter=state->fxArrowList->MakeIterator();
while((ob=liter->Next())!=0)
{
   TGo4GraphicEntry* gx= (TGo4GraphicEntry*) ob->Clone();
   TObject* arrow=gx->fxObject;
   fxArrowList->AddLast(gx);
   fxArrowCleanups->Add(arrow);
   gx->fxPad=pad;
   arrow->Draw();
}
delete liter;
pad->Modified();
pad->Update();
if(padsav) padsav->cd();
}

void TGo4PreviewPanelSlots::ResetFillColors(TVirtualPad* pad, Color_t col)
{
if(pad==0) return;
pad->SetFillColor(col);
TList* primlist=pad->GetListOfPrimitives();
TIterator* piter=primlist->MakeIterator();
TObject*ob=0;
while((ob=piter->Next())!=0)
   {
      TPad* subpad=dynamic_cast<TPad*>(ob);
      TFrame* fram=dynamic_cast<TFrame*>(ob);
      if(subpad)
         ResetFillColors(subpad,col);
      else if(fram)
         fram->SetFillColor(col);
   }
   delete piter;
}





//----------------------------END OF GO4 SOURCE FILE ---------------------

---