---

/Go4GUI/TGo4PreviewPanel.ui.h

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 <iostream.h>

void TGo4PreviewPanel::init()

{
   // TGo4LockGuard glob;
    //setAutoMask(false);
//    setWFlags(Qt::WType_TopLevel);
    char SlotName[256];
    char StatusName[256];
    fbTypingMode=true;
    fbFreezeTitle=false;
    fbMarkEditorVisible=false;
    fbEditorFrameVisible=false;
    fbNeedsMemSync=false; // for automatic sync of new histograms from canvas popup
    fxTGo4GUIRegistry = TGo4GUIRegistry::Instance();
    snprintf(SlotName,255,"%s%s",name(),"_Slots" );
    snprintf(StatusName,255,"%s%s",name(),"_Status" );
    fxTGo4PreviewPanelSlots = (TGo4PreviewPanelSlots *) fxTGo4GUIRegistry->GetSlotClass(SlotName);
    if(fxTGo4PreviewPanelSlots !=0) {
       fxTGo4PreviewPanelSlots->SetGUI(this);
    }else{
       fxTGo4PreviewPanelSlots = new TGo4PreviewPanelSlots (SlotName, name(), this);
    }
    
    fxTGo4PreviewPanelStatus = (TGo4PreviewPanelStatus *)  fxTGo4PreviewPanelSlots->GetStatus();

    setCaption( trUtf8( name(), "" ) );

    fxTGo4WorkSpace= dynamic_cast <TGo4WorkSpace *> (parentWidget());

    connect(C,SIGNAL(SelectedPadChanged(TPad*)),this,SLOT(SetActivePad(TPad*)));
    connect(C,SIGNAL(DropToPad(TPad *)),this,SLOT(DropToPadAction(TPad *)));
    connect(C,SIGNAL(PadClicked(TPad *)),this,SLOT(ClickOnPad(TPad *)));

    ActivePad=(TPad *)C->GetCanvas();
    SetCrosshairDefault(false);   // property maybe overwritten in Mainwindow slot
    SetPadFillColor(18); // property maybe overwritten in Mainwindow slot
    InitPad(ActivePad);
    ApplyToAll =false;
    fbRepaintEnabled=true;
//    menubar
    menubar = new QMenuBar( this, "menubar" );
    menubar->setFrameShape(QFrame::NoFrame);
    //File Menu
    FileMenu = new QPopupMenu( this );
    menubar->insertItem( "F&ile",FileMenu); // avoid conflict with mainwindow shortcut!
    FileMenu->insertItem("&Save as...", this, SLOT(SaveCanvas()));
    FileMenu->insertItem("&Print...", this, SLOT(PrintCanvas()));
    FileMenu->insertItem("Copy to T&Canvas in Memory", this, SLOT(SendToBrowser()));
    FileMenu->insertItem("&Load marker setup...", this, SLOT(LoadMarkers()));
    FileMenu->insertItem("Save &marker setup...", this, SLOT(SaveMarkers()));
    FileMenu->insertItem("Cl&ose", this, SLOT(close()));

    //Edit Menu
    EditMenu = new QPopupMenu( this );
    menubar->insertItem( "&Edit",EditMenu);
    ShowMarkEditorId = EditMenu->insertItem("Show Marker &editor", this, SLOT(SetMarkerPanel()));
    EditMenu->setItemChecked(ShowMarkEditorId, fbMarkEditorVisible);
    ShowRootEditorId =EditMenu->insertItem("Show &ROOT Attributes Editor", this, SLOT(StartEditor()));
    EditMenu->setItemChecked(ShowRootEditorId, false);
    EditMenu->insertItem("&Condition Editor...", this, SLOT(StartConditionEditor()));
    EditMenu->insertSeparator();
    EditMenu->insertItem("&1:1 coordinates ratio", this, SLOT(RectangularRatio()));
    EditMenu->insertItem("&Default pad margins", this, SLOT(DefaultPadMargin()));
    EditMenu->insertSeparator();
    EditMenu->insertItem("Clear &Markers", this, SLOT(ClearAllMarkers()));
//    EditMenu->insertItem("Clear Pad", this, SLOT(ClearPad()));
    EditMenu->insertItem("Clear &Pad", this, SLOT(ClearAllPads()));
    EditMenu->insertItem("Clear C&anvas", this, SLOT(ClearCanvas()));

    //Options Menu
    OptionsMenu = new QPopupMenu( this );
    menubar->insertItem( "&Options",OptionsMenu);
    connect(OptionsMenu, SIGNAL(aboutToShow()), this, SLOT(AboutToShowOptionsMenu()));

    EventStatusId = OptionsMenu->insertItem("&Event Status", this, SLOT(ShowEventStatus()));
    OptionsMenu->setItemChecked(EventStatusId, false);
    CrosshairId = OptionsMenu->insertItem("&Crosshair", this, SLOT(SetCrosshair()));
    StatisticsId = OptionsMenu->insertItem("Histogram &Statistics", this, SLOT(SetStatistics()));
    TitleId = OptionsMenu->insertItem("Histogram &Title", this, SLOT(SetHistoTitle()));
    LegendId = OptionsMenu->insertItem("Multiplot &Legend", this, SLOT(SetLegend()));
    FreezeTitleId = OptionsMenu->insertItem("&Keep Viewpanel Title", this, SLOT(SetFreezeTitle()));
    OptionsMenu->setItemChecked(FreezeTitleId, false);
    OptionsMenu->insertItem("Set &Viewpanel Title...", this, SLOT(SetViewpanelTitle()));
    SuperImposeId = OptionsMenu->insertItem("Super &Impose", this, SLOT(SetSuperImpose()));
    ApplytoAllId = OptionsMenu->insertItem("Apply to &All Pads", this, SLOT(SetApplyToAll()));
    OptionsMenu->setItemChecked(ApplytoAllId, false);
    ApplyToAllflag= false;
    
    
    
    CanvasStatus= new QStatusBar(this, "Canvas Status");
    TGo4PreviewPanelLayout->addWidget( CanvasStatus,2, 0 );
    fxTGo4WorkSpace->NewViewPanel(this);
    C->setName(name());
    C->GetCanvas()->SetName(name());
    MarkerPanel->setRadioButtonExclusive(false);
    MarkerPanel->setExclusive(false);
    
    fxRooteditor= new TQRootWindow(EditorFrame,"rootwrapperwindow");
    
    QVBoxLayout* gedlayout = new QVBoxLayout(EditorFrame);
    if (fxRooteditor) gedlayout->addWidget(fxRooteditor);
    EditorFrame->polish();
    EditorFrame->update();
    EditorFrame->show();
    EditorFrame->setShown(fbEditorFrameVisible);
    RefreshButtons();
    DisplayPadStatus(ActivePad);
}

void TGo4PreviewPanel::AboutToShowOptionsMenu() 
{
   bool superImpose, showhistostats, showhistotitle, crosshair, legend;
//   bool crosshairdefault=false; // get this from mainwindow later
    
   TGo4PadOptions *fxOptions= fxTGo4PreviewPanelStatus->GetPadOptions(ActivePad);
   if(fxOptions==0){
      superImpose = false;
      showhistostats = true;
      showhistotitle = true;
      crosshair = fbCrosshairDefault;
      legend = true;
      fxTGo4PreviewPanelStatus->SetPadDrawOption(ActivePad,"",superImpose);
      fxTGo4PreviewPanelStatus->SetPadHistogramStats(ActivePad,showhistostats);
      fxTGo4PreviewPanelStatus->SetPadHistogramTitle(ActivePad,showhistotitle);
      fxTGo4PreviewPanelStatus->SetPadCrosshair(ActivePad,crosshair);
      fxTGo4PreviewPanelStatus->SetPadLegend(ActivePad, legend);
    } else {
      superImpose = fxOptions->DragAddOption();
      showhistostats = fxOptions->IsHisStats();
      showhistotitle = fxOptions->IsHisTitle();
      crosshair = fxOptions->IsCrosshair();
      legend = fxOptions->IsLegendDraw();
    }
    OptionsMenu->setItemChecked(SuperImposeId, superImpose);
    OptionsMenu->setItemChecked(StatisticsId, showhistostats);
    OptionsMenu->setItemChecked(TitleId, showhistotitle);
    OptionsMenu->setItemChecked(CrosshairId, crosshair);
    OptionsMenu->setItemChecked(LegendId, legend);
}

void TGo4PreviewPanel::InitPad( TPad * pad )
{
    if(pad==0) return;
    //cout <<"InitPad for "<<pad << endl;
    fxTGo4PreviewPanelStatus->SetPadDrawOption(pad,"hist",FALSE );
    pad->SetCrosshair(fbCrosshairDefault);
    fxTGo4PreviewPanelStatus->SetPadCrosshair(pad,fbCrosshairDefault);
    pad->SetFillColor(fiPadFillColor);
}

void TGo4PreviewPanel::PrintCanvas()
{
      // TGo4LockGuard glob;
   TGo4PrintWidget fxPrint;
   if (!fxPrint.exec()) return; 
   QString PdefName= fxPrint.GetPrinter();
   QString PdefProg = fxPrint.GetPrintProg();
   TCanvas *fxCanvas = C->GetCanvas();
   fxCanvas->Print("~/go4printout.ps");
   QString PrnCmd = PdefProg;
   PrnCmd.append(" -P ");
   PrnCmd.append(PdefName);
   PrnCmd.append(" ~/go4printout.ps");
   gSystem->Exec(PrnCmd.data());
   gSystem->Exec("rm -f ~/go4printout.ps");
}

void TGo4PreviewPanel::StartEditor()
{
//cout <<"TGo4PreviewPanel::StartEditor()" << endl;
fbEditorFrameVisible = !EditMenu->isItemChecked(ShowRootEditorId);
EditMenu->setItemChecked(ShowRootEditorId,fbEditorFrameVisible);
EditorFrame->setShown(fbEditorFrameVisible);
//EditorFrame->setUpdatesEnabled(false);
C->GetCanvas()->cd(); // assign this canvas to the editor
fxTGo4PreviewPanelSlots->BuildPadEditor(fxRooteditor);
//repaint();
//EditorFrame->setUpdatesEnabled(true);
//EditorFrame->repaint(false);
//polish();
//update();
//show();
}

void TGo4PreviewPanel::RectangularRatio() 
{
   TPad *pad = GetActivePad();
   if (pad==0) return;
 
   double dx = fabs(pad->AbsPixeltoX(1) - pad->AbsPixeltoX(0));
   double dy = fabs(pad->AbsPixeltoY(1) - pad->AbsPixeltoY(0));

   if ((dx<=0) || (dy<=0)) return;
   
   double ratio = dx / dy;
   
   if (ratio<1.) {
     double left = pad->GetLeftMargin();
     double right = pad->GetRightMargin();
     double change = (1.-left-right)*(1-ratio);
     pad->SetLeftMargin(left+change/2.);
     pad->SetRightMargin(right+change/2.);
   } else {
     double bottom = pad->GetBottomMargin();
     double top = pad->GetTopMargin();
     double change = (1.-bottom-top)*(1.-1/ratio);
     pad->SetTopMargin(top + change/2.);
     pad->SetBottomMargin(bottom + change/2.);
   }
   
   RedrawPad(pad); 
}

void TGo4PreviewPanel::DefaultPadMargin()
{
   TPad *pad = GetActivePad();
   if (pad==0) return;
   
   pad->SetLeftMargin(gStyle->GetPadLeftMargin());
   pad->SetRightMargin(gStyle->GetPadRightMargin());
   pad->SetTopMargin(gStyle->GetPadTopMargin());
   pad->SetBottomMargin(gStyle->GetPadBottomMargin());

   RedrawPad(pad); 
}


void TGo4PreviewPanel::ClearPad()
{
   // TGo4LockGuard glob;
   TPad *Pad=GetActivePad();
   fxTGo4PreviewPanelStatus->RemoveSubPads(Pad);
   ClearLegend(Pad,true); 
   Pad->Clear();
   Pad->Update();
   fxTGo4PreviewPanelSlots->InformUpdatePad(Pad);
}
/*
void TGo4PreviewPanel::ClearAllPads()
{
// TGo4LockGuard glob;
   TCanvas* can = C->GetCanvas();
   TList* primlist = can->GetListOfPrimitives();
   if(primlist==0) return;
   TIterator* liter = primlist->MakeIterator();
   TObject* next=0;
   while((next=liter->Next())!=0) {
     if(next->InheritsFrom("TPad")) {
         TPad* subpad=dynamic_cast<TPad*>(next);
         fxTGo4PreviewPanelStatus->RemoveSubPads(subpad); // will also remove subsubpads...
         //fxTGo4PreviewPanelSlots->ClearAllLabels(subpad);
      }
   }
   delete liter;
   fxTGo4PreviewPanelSlots->ClearLegend(0); // remove all legends, since we would lose legends of subsubpads anyway
   C->Clear("D"); // this will not delete direct subpads, but subsubpads!
                 // therefore we removed the subsubpads from status above...
   C->Update();
}
*/

void TGo4PreviewPanel::ProcessPadClear(TPad * pad)
{
   if (pad==0) return; 

   Bool_t isanysubpad = kFALSE;
   TIter iter(pad->GetListOfPrimitives());
   TObject* next = 0;
   while((next=iter()) !=0 ) {
      TPad* subpad=dynamic_cast<TPad*>(next);
      if (subpad!=0) {
         ProcessPadClear(subpad);
         isanysubpad = kTRUE;   
      }
   }
   if (!isanysubpad) {
     fxTGo4PreviewPanelSlots->ClearAllLabels(pad);
     fxTGo4PreviewPanelSlots->ClearLegend(pad, kTRUE);
     pad->Clear();
     pad->Update();
     fxTGo4PreviewPanelSlots->InformUpdatePad(pad);
   }
}

void TGo4PreviewPanel::ClearAllPads()
{
   TPad* pad = GetActivePad(); 
   ProcessPadClear(pad);
   ActivePad = 0;
   if (pad!=GetActivePad()) SetActivePad(pad);
}

void TGo4PreviewPanel::ClearCanvas()
{
   // TGo4LockGuard glob;
   fxTGo4PreviewPanelSlots->InformUpdatePad(0);   
   fxTGo4PreviewPanelSlots->ClearAllLabels(0);
   fxTGo4PreviewPanelSlots->ClearLegend(0);
   C->Clear();   
   fxTGo4PreviewPanelStatus->ResetPadOptionsList();
   ActivePad=GetCanvas();
   InitPad(ActivePad);
   ActivePad=0; // emulate change of active pad to have menus updated
   SetActivePad(GetCanvas());
   C->Update();   
   RefreshButtons();
}

bool TGo4PreviewPanel::GetShowEventStatus()
{
   // TGo4LockGuard glob;
   return OptionsMenu->isItemChecked(EventStatusId);
}

void TGo4PreviewPanel::ShowEventStatus()
{
   // TGo4LockGuard glob;
   bool s = !OptionsMenu->isItemChecked(EventStatusId);
   OptionsMenu->setItemChecked(EventStatusId,s);
   C->SetShowEventStatus(s);
   if(!s)   DisplayPadStatus(ActivePad);
}
void TGo4PreviewPanel::DisplayEventStatus(const char *Message)
{
   // TGo4LockGuard glob;
   CanvasStatus->message(Message);
}

void TGo4PreviewPanel::ChangeSuperImpose(bool superimpose) 
{
   TPad* SelectedPad = GetActivePad();
   if(!ApplyToAllPads()) {
       fxTGo4PreviewPanelStatus->SetPadDrawOption(SelectedPad, "hist", superimpose);
    } else {
       TObject *entry=0;
       TRefArray *ListOfPads = new TRefArray;
       ListOfPads->AddAll(GetListOfPads());
       TIter Padlistiter(ListOfPads);
       while((entry= Padlistiter.Next()) !=0) {
          TPad *pad=dynamic_cast <TPad *>(entry);
          fxTGo4PreviewPanelStatus->SetPadDrawOption(pad, "hist", superimpose);
       }
       ListOfPads->Clear("nodelete");
       delete ListOfPads; 
        
    }
    DisplayPadStatus(SelectedPad);
}


void TGo4PreviewPanel::SetSuperImpose() 
{
   // TGo4LockGuard glob;
   bool s = !OptionsMenu->isItemChecked(SuperImposeId);
   ChangeSuperImpose(s);
}

void TGo4PreviewPanel::SetApplyToAll()
{
   // TGo4LockGuard glob;
   bool s = !OptionsMenu->isItemChecked(ApplytoAllId);
   OptionsMenu->setItemChecked(ApplytoAllId,s);
//    TPad *RootSelectedPad=dynamic_cast <TPad *>(gROOT->GetSelectedPad());
//     fxTGo4PreviewPanelStatus->SetPadDrawOption(RootSelectedPad,"hist",s);
     ApplyToAllflag=s;
    DisplayPadStatus(ActivePad);
}


void TGo4PreviewPanel::SetStatistics() 
{
   bool s = !OptionsMenu->isItemChecked(StatisticsId);
   TPad* activepad=GetActivePad();
   if(!ApplyToAllPads()) {
      fxTGo4PreviewPanelStatus->SetPadHistogramStats(activepad,s);
      TH1* his=GetPadHistogram(activepad);
      if(his) his->SetStats(s);
      activepad->Modified();
      activepad->Update();
   } else {
     TObject *entry=0;     
     TRefArray *ListOfPads = new TRefArray;
     ListOfPads->AddAll(GetListOfPads());
     TIter Padlistiter(ListOfPads);
     while((entry= Padlistiter.Next()) !=0) {
        TPad *pad=dynamic_cast <TPad *>(entry);
        fxTGo4PreviewPanelStatus->SetPadHistogramStats(pad,s);
        TH1* his=GetPadHistogram(pad);
        if(his) his->SetStats(s);
        pad->Modified();
        pad->Update();
     }
     ListOfPads->Clear("nodelete");
     delete ListOfPads;
   }
}

void TGo4PreviewPanel::SetHistoTitle()
{
   bool s = !OptionsMenu->isItemChecked(TitleId);
   TPad* activepad=GetActivePad();
   if(!ApplyToAllPads()) {
      fxTGo4PreviewPanelStatus->SetPadHistogramTitle(activepad,s);
      Redraw();
   } else {
      TObject *entry=0;
      TRefArray *ListOfPads = new TRefArray;
      ListOfPads->AddAll(GetListOfPads());
      TIter Padlistiter(ListOfPads);      
      while((entry= Padlistiter.Next()) !=0) {
         TPad *pad=dynamic_cast <TPad *>(entry);
         fxTGo4PreviewPanelStatus->SetPadHistogramTitle(pad,s);
         SetActivePad(pad);
         Redraw();
      }
      SetActivePad(activepad);
      GetCanvas()->Update();
      ListOfPads->Clear("nodelete");
      delete ListOfPads;
   }
}

void TGo4PreviewPanel::SetLegend()
{
    bool s = !OptionsMenu->isItemChecked(LegendId);
    TPad* activepad = GetActivePad();
    if(!ApplyToAllPads()) {
       fxTGo4PreviewPanelStatus->SetPadLegend(activepad,s);
       Redraw();
    } else {
       TObject *entry=0;
       TRefArray *ListOfPads = new TRefArray;
       ListOfPads->AddAll(GetListOfPads());
       TIter Padlistiter(ListOfPads);       
       while((entry= Padlistiter.Next()) !=0) {
         TPad *pad = dynamic_cast <TPad *>(entry);
         if (pad!=0) {
            fxTGo4PreviewPanelStatus->SetPadLegend(pad,s);
            SetActivePad(pad);
            Redraw();
         }
       }
       SetActivePad(activepad);
       GetCanvas()->Update();
       ListOfPads->Clear("nodelete");
       delete ListOfPads;
    }
}
void TGo4PreviewPanel::SetCrosshair()
{
   bool s = !OptionsMenu->isItemChecked(CrosshairId);

   #if __GO4ROOTVERSION__ < 40008

   TPad* activepad=GetActivePad();
   if(!ApplyToAllPads()) {
      fxTGo4PreviewPanelStatus->SetPadCrosshair(activepad,s);
   } else {
      TObject *entry=0;
       TRefArray *ListOfPads = new TRefArray;
       ListOfPads->AddAll(GetListOfPads());
       TIter Padlistiter(ListOfPads);
      while((entry= Padlistiter.Next()) !=0) {
         TPad *pad = dynamic_cast <TPad *>(entry);
         if (pad!=0)
            fxTGo4PreviewPanelStatus->SetPadCrosshair(pad,s);
      }
      ListOfPads->Clear("nodelete");
      delete ListOfPads;
   }
   
   #else
   
      fxTGo4PreviewPanelStatus->SetPadCrosshair(GetCanvas(),s);
   
   #endif
}

void TGo4PreviewPanel::destroy()
{
    TGo4LockGuard glob;
    fxTGo4GUIRegistry->UnRegisterClass(fxTGo4PreviewPanelSlots,fxTGo4PreviewPanelStatus);
    fxTGo4WorkSpace->DelViewPanel(this);
    delete menubar;
    delete  fxTGo4PreviewPanelSlots;
}


void TGo4PreviewPanel::closeEvent( QCloseEvent* ce )
{
   // TGo4LockGuard glob;
    // clean up possible images here before Qt deletes Canvas::
    TObject *entry=0;
    TRefArray *ListOfPads = new TRefArray;
    ListOfPads->AddAll(GetListOfPads());
    TIter Padlistiter(ListOfPads);
    while((entry= Padlistiter.Next()) !=0)
        {
//            cout << name()<<"::closeEvent scanning padentry: "<<entry<<" ,"<<entry->GetName()<<", class: "<<entry->IsA()->GetName();
//            cout <<" UID:"<<ListOfPads->GetUID(ListOfPads->IndexOf(entry)) << endl;
            TPad *pad=dynamic_cast <TPad *>(entry);
            #ifdef __GO4USEASIMAGE__
            TGo4ASImage* im=GetPadImage(pad);
            if(im) delete im;
            #endif
        }
    ListOfPads->Clear("nodelete");
    delete ListOfPads;
    ce->accept();
    delete this;
}


void TGo4PreviewPanel::dragMoveEvent( QDragMoveEvent* )
{
 //cout<<"TGo4PreviewPanel::dragMoveEvent( QDragMoveEvent * )"<<endl;
}

void TGo4PreviewPanel::dropEvent( QDropEvent *Event )
{
   // TGo4LockGuard glob;
   QString str;
   if ( QTextDrag::decode( Event, str ) ) {
      return;
   }
}

void TGo4PreviewPanel::dragEnterEvent( QDragEnterEvent *e )
{
   // TGo4LockGuard glob;
    if ( QTextDrag::canDecode( e ))   {

   e->accept();
    }

}


void TGo4PreviewPanel::Redraw() {
   RedrawPad(GetActivePad());
}

void TGo4PreviewPanel::RedrawPad(TPad *CanvasSelectedPad) {
    // TGo4LockGuard glob;
    if (CanvasSelectedPad==0) return;
    fxTGo4PreviewPanelSlots->ScanMarkers(CanvasSelectedPad);
    TH1 *h1=0;
    THStack *hs=0;
    TGraph *gr=0;
    TMultiGraph *mg=0;
    TGo4ASImage *ai=0;
    TObject *entry = 0;
    TIter iter(CanvasSelectedPad->GetListOfPrimitives());
    while((entry = iter()) != 0) {
       if (entry->InheritsFrom("TH1")){
          h1 = dynamic_cast<TH1*> (entry);
       } else
       if(entry->InheritsFrom("THStack")) {
         hs = dynamic_cast<THStack*> (entry);
       } else
       if(entry->InheritsFrom("TGraph") && !entry->InheritsFrom("TCutG")) {
          // suppress cutgs for the condition editor case
          gr = dynamic_cast<TGraph*> (entry);
       } else
       if(entry->InheritsFrom("TMultiGraph")){
          mg = dynamic_cast<TMultiGraph*> (entry);
       } 
#ifdef __GO4USEASIMAGE__      
       else if(entry->InheritsFrom("TGo4ASImage")){
         ai = dynamic_cast<TGo4ASImage*> (entry);
       }
#endif

    } // while

    bool cross = fxTGo4PreviewPanelStatus->GetPadCrosshair(CanvasSelectedPad);
    CanvasSelectedPad->SetCrosshair(cross);

    if(mg!=0) {
      RedrawMultiGraph(mg,CanvasSelectedPad);
    } else
    if(gr!=0) {
      RedrawGraph(gr,CanvasSelectedPad);
    } else
    if(ai!=0) {
      RedrawImage(ai,CanvasSelectedPad);
    } else
    if(h1!=0) {
      h1->SetBit(kCanDelete,0);
      RedrawHistogram(h1,CanvasSelectedPad);
    } else
    if(hs!=0) {
      RedrawStack(hs,CanvasSelectedPad);
    }
    CanvasSelectedPad->Update();
}


void TGo4PreviewPanel::RedrawHistogram( TH1 * his, TPad * pad )
{
if(his==0 || pad==0) return;
gROOT->SetSelectedPad(pad);
QString poptions=fxTGo4PreviewPanelStatus->GetPadStringDrawOption(pad);
#ifdef __GO4USEASIMAGE__

if(poptions.contains("asimage",false) && his->InheritsFrom("TH2"))
    // non case sensitive
    {
        //cout <<"RedrawHistogram with asi" << endl;
        TH2* map=dynamic_cast<TH2*>(his);
        TGo4ASImage* pic=new TGo4ASImage(map);
        // scale setup of image is done in ctor
        pad->Clear();
        pic->Draw();
        UpdatePad(pad, his, false); // copy range to padoptions, but  not draw style.
    }
else
#endif //__GO4USEASIMAGE__ 
    {
        //cout <<"RedrawHistogram normal" << endl;
        bool histostats=fxTGo4PreviewPanelStatus->GetPadHistogramStats(pad);
        his->SetStats(histostats);
        bool histotitle=fxTGo4PreviewPanelStatus->GetPadHistogramTitle(pad);
        his->SetBit(TH1::kNoTitle,!histotitle);
        his->Draw(poptions.ascii());
        UpdatePad(pad, his, true); // copy range to padoptions and draw style.
    }
}

void TGo4PreviewPanel::RedrawImage( TGo4ASImage * im, TPad * pad )
{
#ifdef __GO4USEASIMAGE__

if(im==0 || pad==0) return;
gROOT->SetSelectedPad(pad);
QString poptions=fxTGo4PreviewPanelStatus->GetPadStringDrawOption(pad);
if(poptions.contains("asimage",false)) // non case sensitive
    {
         //cout <<"RedrawImage with asi" << endl;
         im->Draw();
         pad->Update();
         fxTGo4PreviewPanelSlots->RedrawAllLabels(pad);
    }
else
    {
       //cout <<"RedrawImage as histogram" << endl;
       ClearPad();
       // check here if histogram is still in browser?
       // otherwise, user may have deleted it already, dead pointer!
       TH2* histo=im->GetHistogram();
       TGo4MainWindow* mw= (TGo4MainWindow*) fxTGo4GUIRegistry->GetMainWindow();
       if(mw->CheckHistogram(im->GetName(),histo))
           {
               im->SetHistogramRanges(histo);
               delete im;
               RedrawHistogram(histo,pad);
           }
    }
#else
    return; // dummy for QtSlots
#endif
}


void TGo4PreviewPanel::RedrawGraph( TGraph * gr, TPad * pad )
{
if(gr==0 || pad==0) return;
gROOT->SetSelectedPad(pad);
QString PadOptions;
    // note that string options for TGraph are different than for TH1
    // for the moment, we do not use padoptions here!
PadOptions.prepend(" \"AP,");
PadOptions.append("\"");
bool histostats=fxTGo4PreviewPanelStatus->GetPadHistogramStats(pad);
bool histotitle=fxTGo4PreviewPanelStatus->GetPadHistogramTitle(pad);
TH1* framehisto=gr->GetHistogram();
framehisto->SetStats(histostats);
framehisto->SetBit(TH1::kNoTitle,!histotitle);
gr->Draw(PadOptions.data());
fxTGo4PreviewPanelSlots->RedrawAllLabels(pad);
//pad->Update();
}

void TGo4PreviewPanel::RedrawStack( THStack * hs, TPad * pad )
{
   if(hs==0 || pad==0) return;
   gROOT->SetSelectedPad(pad);
   QString PadOptions = fxTGo4PreviewPanelStatus->GetPadStringDrawOption(pad);
   PadOptions.prepend(" \"nostack ,");
   PadOptions.append("\"");
// change of statistics and title visibility:
   bool histostats = false; // never draw statistics with stack
   fxTGo4PreviewPanelStatus->SetPadHistogramStats(pad,histostats);
   bool histotitle = fxTGo4PreviewPanelStatus->GetPadHistogramTitle(pad);
   bool legend = fxTGo4PreviewPanelStatus->GetPadLegend(pad);
   TH1* framehisto=hs->GetHistogram();
   framehisto->SetStats(histostats);
   framehisto->SetBit(TH1::kNoTitle,!histotitle);
   hs->Draw(PadOptions.data());
   if(legend) fxTGo4PreviewPanelSlots->DrawLegend(pad,hs);
         else fxTGo4PreviewPanelSlots->ClearLegend(pad);
   fxTGo4PreviewPanelSlots->RedrawAllLabels(pad);
//pad->Update();
}

void TGo4PreviewPanel::RedrawMultiGraph( TMultiGraph * mg, TPad * pad )
{
   if(mg==0 || pad==0) return;
   gROOT->SetSelectedPad(pad);
   QString PadOptions;
    // note that string options for TGraph are different than for TH1
    // for the moment, we do not use padoptions here!
   PadOptions.prepend(" \"AP,");
   PadOptions.append("\"");
   bool histostats = false; // never draw statistics with multigraph
   fxTGo4PreviewPanelStatus->SetPadHistogramStats(pad,histostats);
   bool histotitle = fxTGo4PreviewPanelStatus->GetPadHistogramTitle(pad);
   bool legend = fxTGo4PreviewPanelStatus->GetPadLegend(pad);
   TH1* framehisto = mg->GetHistogram();
   framehisto->SetStats(histostats);
   framehisto->SetBit(TH1::kNoTitle,!histotitle);
   mg->Draw(PadOptions.data());
   if(legend) fxTGo4PreviewPanelSlots->DrawLegend(pad,mg);
         else fxTGo4PreviewPanelSlots->ClearLegend(pad); 
   fxTGo4PreviewPanelSlots->RedrawAllLabels(pad);
//pad->Update();
}


void TGo4PreviewPanel::ClearLegend( TPad * pad, bool del )
{
    fxTGo4PreviewPanelSlots->ClearLegend(pad,del); 
}




void TGo4PreviewPanel::Divide( int X, int Y )
{
    // TGo4LockGuard glob;
if(ActivePad!=0)
    {
        //cout <<"Divide to "<<X<<","<<Y << endl;
        fxTGo4PreviewPanelStatus->RemoveSubPads(ActivePad);
        // remove subpads wil not cleanup labels of this pad:
        fxTGo4PreviewPanelSlots->ClearAllLabels(ActivePad); 
        fxTGo4PreviewPanelSlots->ClearLegend(ActivePad, kTRUE);
        ActivePad->Clear();
        if(!(X==1 && Y==1)) // this would create pad on whole canvas 
            {
            ActivePad->Divide(X, Y);       
            for(int No=0; No<= X*Y;No++)
                {
                    TPad* sub=dynamic_cast<TPad*>(ActivePad->GetPad(No));
                    InitPad(sub);
                }
            }
        ActivePad->Update();
       // note: number of pads will be changed in list of previewpanelstatus by InitPad     
       RefreshButtons();
    }
}

TCanvas *TGo4PreviewPanel::GetCanvas()
{
   // TGo4LockGuard glob;
    return C->GetCanvas();
}

void TGo4PreviewPanel::SaveCanvas()
{
   TCanvas* thiscanvas = C->GetCanvas();
//   Color_t oldfillcol = thiscanvas->GetFillColor();
   QFileDialog* fd = new QFileDialog( this, "Save Canvas", TRUE );
   QString fdCaption = "Save ";
   fdCaption.append(name());
   fdCaption.append("  As");
   fd->setCaption(fdCaption);
   QString EPS ="Encapsulated Post Script (*.eps)";
   QString PS ="Post Script (*.ps)";
   QString GIF="GIF Format  (*.gif)";
   QString CXXM="C++ Macro (*.C)";
   QString ROOTM="root file (*.root)";
   fd->setMode( QFileDialog::AnyFile );
   fd->setName( "Save Canvas ");
   fd->setFilter(EPS);
   fd->addFilter(PS);
   fd->addFilter(GIF);
   fd->addFilter(CXXM);
   fd->addFilter(ROOTM);
   if ( fd->exec() == QDialog::Accepted ) {
       QString filename = fd->selectedFile();
       QString filter = fd->selectedFilter();
       if(filter==EPS) {
          if (!filename.endsWith(".eps")) filename.append(".eps");
       } else 
       if(filter==PS) {
          if (!filename.endsWith(".ps")) filename.append(".ps");
       } else 
       if(filter==GIF) {
          if (!filename.endsWith(".gif")) filename.append(".gif");
       } else 
       if(filter==CXXM) {
          if (!filename.endsWith(".C")) filename.append(".C");
       } else 
       if (filter==ROOTM) {
          if (!filename.endsWith(".root")) filename.append(".root");
          //TCanvas* thiscanvas= (TCanvas*) thiscanvas->Clone();
          fxTGo4PreviewPanelSlots->ResetFillColors(thiscanvas,0);
          //
          // plain root browser might not know the go4 color numbers
         // canvas always saved with white background!
       }
    
       TString oldname = thiscanvas->GetName();
       thiscanvas->SetName("Canvas");
       thiscanvas->Print(filename.data());
       
       thiscanvas->SetName(oldname);
       fxTGo4PreviewPanelStatus->RefreshListOfPads(); // after saving canvas rebuild pad refarray with new object ids
   }
   
   delete fd;
}


TGo4PadOptions * TGo4PreviewPanel::GetPadOptions( TPad *SelectedPad )
{
   // TGo4LockGuard glob;
    return  (fxTGo4PreviewPanelStatus->GetPadOptions(SelectedPad) );
}

void TGo4PreviewPanel::ExpandShiftX(int NewX1,int NewX2, TPad *RootSelectedPad, TH1* h1)
{
   // TGo4LockGuard glob;
   h1->GetXaxis()->SetRange(NewX1,NewX2);
#ifdef __GO4USEASIMAGE__
    TGo4ASImage* im=GetPadImage(RootSelectedPad);
    if(im) im->SetZoom(dynamic_cast<TH2*>(h1));
#endif
   RootSelectedPad->Modified();
   RootSelectedPad->PaintModified();
   RootSelectedPad->Update();

}

void TGo4PreviewPanel::ExpandShiftY(int NewY1,int NewY2, TPad *RootSelectedPad, TH1* h1)
{
   // TGo4LockGuard glob;
// new: treat case of 1d histogram for zoom tools:      
if(NewY1==NewY2) NewY2=NewY1+1;
if(h1->GetDimension()==1)
    {
        bool autoscale=false;
        TGo4PadOptions *padoptions = fxTGo4PreviewPanelStatus->GetPadOptions(RootSelectedPad);
        if(padoptions) autoscale=padoptions->GetAutoScale();
        if(!autoscale)
            {
                h1->SetMinimum(NewY1);
                h1->SetMaximum(NewY2);
            }
    }
else
    {
        h1->GetYaxis()->SetRange(NewY1,NewY2);
#ifdef __GO4USEASIMAGE__
        TGo4ASImage* im=GetPadImage(RootSelectedPad);
        if(im) im->SetZoom(dynamic_cast<TH2*>(h1));
#endif    
    }
   RootSelectedPad->Modified();
   RootSelectedPad->PaintModified();
   RootSelectedPad->Update();
}

void TGo4PreviewPanel::SlotShiftL(int expandfactor)
{
   // TGo4LockGuard glob;
   TPad *RootSelectedPad=GetActivePad();
   Int_t Xfirst;
   Int_t Xlast;
   Int_t Ymin;
   Int_t Ymax;
   if(RootSelectedPad!=0){
      TGo4PadOptions *fxTGo4PadOptions=fxTGo4PreviewPanelStatus->GetPadOptions(RootSelectedPad);
      if(fxTGo4PadOptions!=0){
         fxTGo4PadOptions->GetHistogramFullRange(Xfirst, Xlast, Ymin,Ymax);
      }
      TH1* h1=GetPadHistogram(RootSelectedPad);
      if(h1!=0){
         Int_t first    = h1->GetXaxis()->GetFirst();
         Int_t last     = h1->GetXaxis()->GetLast();
         Int_t Delta    = (last-first);
         Int_t Shift    = Delta*expandfactor/100;
         if(Shift<2) Shift=2; // minimum motion
         Int_t NewX1    = first+ Shift/2;
         Int_t NewX2    = last+ Shift/2;
         if(NewX2 > Xlast){
            NewX1=Xlast-Delta;
            NewX2=Xlast;
         }
         ExpandShiftX(NewX1,NewX2,RootSelectedPad,h1);
      }
   }
}

void TGo4PreviewPanel::SlotShiftR(int expandfactor)
{
   // TGo4LockGuard glob;
   TPad *RootSelectedPad=GetActivePad();
   Int_t Xfirst;
   Int_t Xlast;
   Int_t Ymin;
   Int_t Ymax;
   if(RootSelectedPad!=0){
      TGo4PadOptions *fxTGo4PadOptions=fxTGo4PreviewPanelStatus->GetPadOptions(RootSelectedPad);
      if(fxTGo4PadOptions!=0){
         fxTGo4PadOptions->GetHistogramFullRange(Xfirst, Xlast, Ymin,Ymax);
      }
      TH1* h1=GetPadHistogram(RootSelectedPad);
      if (h1!=0){
         Int_t first   = h1->GetXaxis()->GetFirst();
         Int_t last    = h1->GetXaxis()->GetLast();
         Int_t Delta   =(last-first);
         Int_t Shift   = Delta*expandfactor/100;
         if(Shift<2) Shift=2; // minimum motion
         Int_t NewX1= first-Shift/2;
         Int_t NewX2= last-Shift/2;
         if(NewX1 < Xfirst){
            NewX1=Xfirst;
            NewX2=Xfirst+Delta;
         }
         ExpandShiftX(NewX1,NewX2,RootSelectedPad,h1);
      }
   }

}

void TGo4PreviewPanel::SlotShiftU(int expandfactor)
{
   // TGo4LockGuard glob;
   TPad *RootSelectedPad=GetActivePad();
   Int_t Xfirst;
   Int_t Xlast;
   Int_t Ymin;
   Int_t Ymax;
   if(RootSelectedPad!=0){
      TGo4PadOptions *fxTGo4PadOptions=fxTGo4PreviewPanelStatus->GetPadOptions(RootSelectedPad);
      if(fxTGo4PadOptions!=0){
         fxTGo4PadOptions->GetHistogramFullRange(Xfirst, Xlast, Ymin,Ymax);
      }
      TH1* h1=GetPadHistogram(RootSelectedPad);
      if (h1!=0){
         Int_t Yfirst,Ylast; 
         if(h1->GetDimension()==1)
             {
                Yfirst   = h1->GetMinimum();
                Ylast    = h1->GetMaximum();
             }
         else
             {
                Yfirst   = h1->GetYaxis()->GetFirst();
                Ylast    = h1->GetYaxis()->GetLast();
             }
         Int_t Delta=(Ylast-Yfirst);
         Int_t Shift   = Delta*expandfactor/100;
         if(Shift<2) Shift=2; // minimum motion
         Int_t NewY1= Yfirst-Shift/2;
         Int_t NewY2= Ylast-Shift/2;         
         if(NewY1 < Ymin){
            NewY1=Ymin;
            NewY2=Ymin+Delta;
         }
         
         ExpandShiftY(NewY1,NewY2,RootSelectedPad, h1);
      }
   }
}

void TGo4PreviewPanel::SlotShiftD(int expandfactor)
{
   // TGo4LockGuard glob;
   TPad *RootSelectedPad=GetActivePad();
   Int_t Xfirst;
   Int_t Xlast;
   Int_t Ymin;
   Int_t Ymax;
   if(RootSelectedPad!=0){
      TGo4PadOptions *fxTGo4PadOptions=fxTGo4PreviewPanelStatus->GetPadOptions(RootSelectedPad);
      if(fxTGo4PadOptions!=0){
         fxTGo4PadOptions->GetHistogramFullRange(Xfirst, Xlast, Ymin,Ymax);
      }
      TH1* h1=GetPadHistogram(RootSelectedPad);
      if(h1!=0){
         Int_t Yfirst,Ylast;
         if(h1->GetDimension()==1)
             {
                Yfirst   = h1->GetMinimum();
                Ylast    = h1->GetMaximum();
             }
         else
             {
                Yfirst   = h1->GetYaxis()->GetFirst();
                Ylast    = h1->GetYaxis()->GetLast();
             }
         Int_t Delta=Ylast-Yfirst;
         Int_t Shift   = Delta*expandfactor/100;
         if(Shift<2) Shift=2; // minimum motion
         Int_t NewY1= Yfirst+Shift/2;
         Int_t NewY2= Ylast+Shift/2;         
         if(NewY2 > Ymax) {
            NewY2=Ymax;
            NewY1=Ymax-Delta;
         }
         ExpandShiftY(NewY1,NewY2,RootSelectedPad, h1);
      }
   }
}

void TGo4PreviewPanel::SlotExpandX(int expandfactor)
{
   // TGo4LockGuard glob;
   TPad *RootSelectedPad=GetActivePad();
   Int_t Xfirst;
   Int_t Xlast;
   Int_t Ymin;
   Int_t Ymax;
   if(RootSelectedPad!=0){
      TGo4PadOptions *fxTGo4PadOptions=fxTGo4PreviewPanelStatus->GetPadOptions(RootSelectedPad);
      if(fxTGo4PadOptions!=0){
         fxTGo4PadOptions->GetHistogramFullRange(Xfirst, Xlast, Ymin,Ymax);
      }
      TH1* h1=GetPadHistogram(RootSelectedPad);
      if (h1!=0){
         Int_t first   = h1->GetXaxis()->GetFirst();
         Int_t last    = h1->GetXaxis()->GetLast();
         Int_t Shift   = (last-first)*expandfactor/100;
         if(Shift<2) Shift=2; // minimum motion
         Int_t NewX1= first+Shift/2;
         Int_t NewX2= last-Shift/2;         
         if(NewX1> NewX2){
            NewX1=NewX2;
         }
         ExpandShiftX(NewX1,NewX2,RootSelectedPad,h1);
      }
   }

}

void TGo4PreviewPanel::SlotExpandY(int expandfactor)
{
   // TGo4LockGuard glob;
   TPad *RootSelectedPad=GetActivePad();
   Int_t Xfirst;
   Int_t Xlast;
   Int_t Ymin;
   Int_t Ymax;
   if(RootSelectedPad!=0){
      TGo4PadOptions *fxTGo4PadOptions=fxTGo4PreviewPanelStatus->GetPadOptions(RootSelectedPad);
      if(fxTGo4PadOptions!=0){
         fxTGo4PadOptions->GetHistogramFullRange(Xfirst, Xlast, Ymin,Ymax);
      }
      TH1* h1=GetPadHistogram(RootSelectedPad);
      if(h1!=0){
         Int_t Yfirst,Ylast;
         if(h1->GetDimension()==1)
             {
                Yfirst   = h1->GetMinimum();
                Ylast    = h1->GetMaximum();
             }
         else
             {
                Yfirst   = h1->GetYaxis()->GetFirst();
                Ylast    = h1->GetYaxis()->GetLast();
             }
         Int_t Shift   = (Ylast-Yfirst)*expandfactor/100;
         //if(Shift<2) Shift=2; // minimum motion
         Int_t NewY1= Yfirst+Shift/2;
         Int_t NewY2= Ylast-Shift/2;
         if(NewY1>= NewY2){
            NewY1=NewY2-1;
         }
         ExpandShiftY(NewY1,NewY2,RootSelectedPad, h1);
      }
   }
}

void TGo4PreviewPanel::SlotUExpandX(int expandfactor)
{
   // TGo4LockGuard glob;
   TPad *RootSelectedPad=GetActivePad();
   Int_t Xfirst;
   Int_t Xlast;
   Int_t Ymin;
   Int_t Ymax;
   if(RootSelectedPad!=0){
      TGo4PadOptions *fxTGo4PadOptions=fxTGo4PreviewPanelStatus->GetPadOptions(RootSelectedPad);
      if(fxTGo4PadOptions!=0){
         fxTGo4PadOptions->GetHistogramFullRange(Xfirst, Xlast, Ymin,Ymax);
      }
      TH1* h1=GetPadHistogram(RootSelectedPad);
      if (h1!=0){
         Int_t first   = h1->GetXaxis()->GetFirst();
         Int_t last    = h1->GetXaxis()->GetLast();
         Int_t Shift   = (last-first)*expandfactor/100;
         if(Shift<2) Shift=2; // minimum motion
         Int_t NewX1= first-Shift/2;
         Int_t NewX2= last+Shift/2;
         if(NewX1 <= Xfirst) {
            NewX1=Xfirst;
         }
         if(NewX2 >= Xlast){
            NewX2=Xlast;
         }
         ExpandShiftX(NewX1,NewX2,RootSelectedPad,h1);
      }
   }
}

void TGo4PreviewPanel::SlotUExpandY(int expandfactor)
{
   // TGo4LockGuard glob;
   TPad *RootSelectedPad=GetActivePad();
   Int_t Xfirst;
   Int_t Xlast;
   Int_t Ymin;
   Int_t Ymax;
   if(RootSelectedPad!=0){
      TGo4PadOptions *fxTGo4PadOptions=fxTGo4PreviewPanelStatus->GetPadOptions(RootSelectedPad);
      if(fxTGo4PadOptions!=0){
         fxTGo4PadOptions->GetHistogramFullRange(Xfirst, Xlast, Ymin,Ymax);
      }
      TH1* h1=GetPadHistogram(RootSelectedPad);
      if(h1!=0){
         Int_t Yfirst,Ylast;
         if(h1->GetDimension()==1)
             {
                Yfirst   = h1->GetMinimum();
                Ylast    = h1->GetMaximum();
             }
         else
             {
                Yfirst   = h1->GetYaxis()->GetFirst();
                Ylast    = h1->GetYaxis()->GetLast();
             }         
         Int_t Shift   = (Ylast-Yfirst)*expandfactor/100;
         if(Shift<2) Shift=2; // minimum motion
         Int_t NewY1= Yfirst-Shift/2;
         Int_t NewY2= Ylast+Shift/2;
         if(NewY1 < Ymin) {
            NewY1=Ymin;
         }
         if(NewY2 > Ymax){
            NewY2=Ymax;
         }
         ExpandShiftY(NewY1,NewY2,RootSelectedPad, h1);
      }
   }
}

TPad * TGo4PreviewPanel::GetActivePad()
{
   // TGo4LockGuard glob;
   if(ActivePad==0) {
      int NoOfPads=0;
      TPad *CanvasSelectedPad=0;

      TCanvas* ThisCanvas= C->GetCanvas();

      TPad* RootSelectedPad=dynamic_cast <TPad *>(gROOT->GetSelectedPad());

      TIter iter(ThisCanvas->GetListOfPrimitives());
      TObject *entry = 0;
      while((entry= iter()) !=0) {
          if(entry->InheritsFrom("TPad")){
            TPad* FoundPad=dynamic_cast <TPad *>(entry);
            NoOfPads++;
            if(FoundPad==RootSelectedPad){
              CanvasSelectedPad=FoundPad;
            }
          }
      }
      if(NoOfPads==0 && CanvasSelectedPad==0)   CanvasSelectedPad =(TPad *) ThisCanvas;
      ActivePad =CanvasSelectedPad;
      //return CanvasSelectedPad;
    } 
    return ActivePad;
}

TH1 * TGo4PreviewPanel::GetPadHistogram( TPad *Pad)
{
   // TGo4LockGuard glob;
    if(Pad==0) return 0;
    TObject *entry;
    TIterator* Padlistiter ;
    TH1 *h1=0;
    THStack *hs=0;
    TGraph *Gr=0;
    TMultiGraph* mg=0;
    TGo4ASImage* im=0;
   TList* primcopy=new TList;
   primcopy->AddAll(Pad->GetListOfPrimitives()); // buffer primitive list access
   Padlistiter = primcopy->MakeIterator();
   while((entry= Padlistiter->Next()) !=0) {
       if (entry->InheritsFrom("TH1")){
         h1 = dynamic_cast<TH1*> (entry);
      }else if(entry->InheritsFrom("THStack")){
         hs = dynamic_cast<THStack*> (entry);
      }else if(entry->InheritsFrom("TGraph")){
         if (dynamic_cast<TCutG*>(entry))
                Gr=0; // suppress getting polycondview volatile cuts
           else
                Gr = dynamic_cast<TGraph*> (entry);
       }else if(entry->InheritsFrom("TMultiGraph")){
         mg = dynamic_cast<TMultiGraph*> (entry);
       }
#ifdef __GO4USEASIMAGE__
       else if(entry->InheritsFrom("TGo4ASImage")){
         im = dynamic_cast<TGo4ASImage*> (entry);
       }
#endif   
   }
   delete Padlistiter;
   primcopy->Clear("nodelete");
   delete primcopy; 
    if(im)
        {
#ifdef __GO4USEASIMAGE__
            h1=im->GetHistogram();
            TGo4MainWindow* mw= (TGo4MainWindow*) fxTGo4GUIRegistry->GetMainWindow();
            if(!mw->CheckHistogram(im->GetName(),h1))
                h1=0;// reset image histogram if not existing anymore
            else
                im->SetHistogramRanges(dynamic_cast<TH2*>(h1)); // update model from view
            //cout <<"GetPadHistogram found histogram of image:"<<h1 << endl;
#endif // __GO4USEASIMAGE__
        }
   if(h1==0  && hs!=0){
      h1=hs->GetHistogram();
   }else if(h1==0  && Gr!=0){
      h1=Gr->GetHistogram();
   }else if(h1==0  && mg!=0){
      h1=mg->GetHistogram();
   }
   return h1;

}


THStack * TGo4PreviewPanel::GetPadTHStack( TPad *Pad )
{
   // TGo4LockGuard glob;
if(Pad==0) return 0;
    TObject *entry;
    TIterator* Padlistiter ;
    THStack *hs=0;
   TList* primcopy=new TList;
   primcopy->AddAll(Pad->GetListOfPrimitives()); // buffer primitive list access
   Padlistiter = primcopy->MakeIterator();
   while((entry= Padlistiter->Next()) !=0) {
      if(entry->InheritsFrom("THStack")){
         hs = dynamic_cast<THStack*> (entry);
      }
   }
   delete Padlistiter;
   primcopy->Clear("nodelete");
   delete primcopy; 
   return hs;
}

TGraph * TGo4PreviewPanel::GetPadTGraph( TPad *Pad )
{
   // TGo4LockGuard glob;
   if(Pad==0) return 0;
   TObject *entry;
   TIterator* Padlistiter ;
   TGraph *Gr=0;
   TList* primcopy=new TList;
   primcopy->AddAll(Pad->GetListOfPrimitives()); // buffer primitive list access
   Padlistiter = primcopy->MakeIterator();
   while((entry= Padlistiter->Next()) !=0) {
      if(entry->InheritsFrom("TGraph")){
         Gr = dynamic_cast<TGraph*> (entry);
      }
   }
   delete Padlistiter;
    primcopy->Clear("nodelete");
   delete primcopy; 
   return Gr;
}

TGo4ASImage* TGo4PreviewPanel::GetPadImage( TPad * pad )
{
#ifdef __GO4USEASIMAGE__
if(pad==0) return 0;    
// TGo4LockGuard glob;
   TObject *entry;
   TIterator* Padlistiter ;
   TGo4ASImage* im=0;
   TList* primcopy=new TList;
   primcopy->AddAll(pad->GetListOfPrimitives()); 
   Padlistiter = primcopy->MakeIterator();
   while((entry= Padlistiter->Next()) !=0) {
      if(entry->InheritsFrom("TGo4ASImage")){
         im = dynamic_cast<TGo4ASImage*> (entry);
      }
   }
   delete Padlistiter;
   primcopy->Clear("nodelete");
   delete primcopy; 
   return im;
#else
   return 0; // dummy for Qt Slots
#endif    
}


void TGo4PreviewPanel::UpdatePad( TPad *Pad, TH1 *h ,bool updateoptions)
{
  // TGo4LockGuard glob;
  fxTGo4PreviewPanelSlots->UpdatePad(Pad, h, true, updateoptions);
  fxTGo4PreviewPanelSlots->RedrawAllLabels(Pad);
}

void TGo4PreviewPanel::UpdatePad( TPad *Pad, THStack *hs )
{
   // TGo4LockGuard glob;
  fxTGo4PreviewPanelSlots->UpdatePad(Pad, hs ); 
  RedrawStack(hs,Pad); // draw legend, suppress histogram statistics box
  
}

void TGo4PreviewPanel::UpdatePad( TPad * Pad, TMultiGraph * mg )
{
  fxTGo4PreviewPanelSlots->UpdatePad(Pad, mg->GetHistogram()); 
  RedrawMultiGraph(mg,Pad); // draw legend, suppress histogram statistics box
 
}

void TGo4PreviewPanel::XaxisStyle( int t)
{
   // TGo4LockGuard glob;
//    double xmin=0, xmax=0, ymin=0, ymax=0, zmin=0, zmax=0;
//    GetRanges(xmin,xmax,ymin,ymax,zmin,zmax);
   TPad* activepad=GetActivePad();
//   if(t>0 && xmin<=0)
//        {
//            double xnewmin=(xmax-xmin)/1000;
//            SetXRange(xnewmin,xmax);
//        }
    if(activepad)
        {
            activepad->SetLogx(t);
            activepad->Modified();
            activepad->Update();
            activepad->Modified();
            activepad->Update(); // second update is for label connector
        }
}

void TGo4PreviewPanel::YaxisStyle( int t)
{
   // TGo4LockGuard glob;
// if autoscale is not set!
//   double xmin=0, xmax=0, ymin=0, ymax=0, zmin=0, zmax=0;
//    GetRanges(xmin,xmax,ymin,ymax, zmin, zmax);
//   THStack *hs=GetPadTHStack(activepad);
//    double ynewmin=(ymax-ymin)/1000;
//    if(hs && t>0 && hs->GetMinimum()<=0)
//        {
//            hs->SetMinimum(ynewmin);
//            SetYRange(ynewmin,ymax);
//        }
//    else if(t>0 && ymin<=0)
//        {
//            SetYRange(ynewmin,ymax);
//        }

   TPad* activepad = GetActivePad();
   
   if (activepad==0) return;

   if ((t>0) && !GetAutoScaleOption()) {
      TH1* h1 = GetPadHistogram(activepad);
      if ((h1!=0) && !h1->InheritsFrom("TH2") && 
           !h1->InheritsFrom("TH3")) {
         Double_t ymin = h1->GetMinimum();
         Double_t ymax = h1->GetMaximum();
         if ((ymin==0) && (ymax>0)) {
            ymin = 1.; 
            if (ymin>0.01*ymax) ymin = 0.01*ymax;
            h1->SetMinimum(ymin); 
            h1->SetMaximum(ymax); 
         }
      }
   }
       
   activepad->SetLogy(t);
   activepad->Modified();
   activepad->Update();
   activepad->Modified();
   activepad->Update(); // second update is for label connector
}

void TGo4PreviewPanel::ZaxisStyle( int t)
{
   // TGo4LockGuard glob;
   TPad *RootSelectedPad=GetActivePad();
   TH1* h1=GetPadHistogram(RootSelectedPad);
   if(h1!=0){
      Int_t first   = h1->GetZaxis()->GetFirst();
      Int_t last    = h1->GetZaxis()->GetLast();
      if(first > 0 && last > 0)   {
         if(RootSelectedPad!=0){
            RootSelectedPad->SetLogz(t);
            RootSelectedPad->Modified();
            RootSelectedPad->Update();
         }
      }
   }
}




void TGo4PreviewPanel::mouseDoubleClickEvent( QMouseEvent *e )
{
    // TGo4LockGuard glob;
   if(fxTGo4PreviewPanelStatus->GetNoOfPads()>1){
        QPoint Pos;
      TObject *object=0;
      char SlotName[256];
      char PanelName[256];
      int i=0;
      TPad *pad;
      THStack *THS;
      TH1 *Th1;
      TGo4PreviewPanel *fxPanel;
      char buffer[256];
      char buffer1[256];
      Pos = e->pos();
         pad = GetCanvas()->Pick(Pos.x(), Pos.y(), object);
        if(dynamic_cast<TCutG*>(GetPadTGraph(pad))) return;
            // for polygon condition in pad: doubleclick needed for editor
      Th1 =GetPadHistogram(pad);
      if(Th1!=0){
         do {
            snprintf(PanelName,255,"%s %d %s","V ",i++," :");
            snprintf(SlotName,255,"%s%s",PanelName,"_Slots");
         }while(fxTGo4GUIRegistry->GetSlotClass(SlotName)!=0);

            TGo4MainWindow* mw= (TGo4MainWindow*) fxTGo4GUIRegistry->GetMainWindow();
         fxPanel=mw->ViewPanelSlot();
         THS = GetPadTHStack(pad);
         if (THS==0){
            Th1 =GetPadHistogram(pad);
            fxPanel->GetCanvas()->cd();
            Th1->Draw(fxTGo4PreviewPanelStatus->GetPadStringDrawOption(pad));
            fxPanel->UpdatePad((TPad *)(fxPanel->GetCanvas()), Th1 ,true);
         }else if(THS!=0){
            fxPanel->GetCanvas()->cd();
            snprintf(buffer,255,"%s","\"nostack ,");
            snprintf(buffer,255,"%s",fxTGo4PreviewPanelStatus->GetPadStringDrawOption(pad));
            strcat(buffer, buffer1);
            strcat(buffer,"\"");
             THS->Draw(buffer);
            fxPanel->UpdatePad((TPad *)(fxPanel->GetCanvas()), THS);
         }
      }
   }
}

TGo4QRootCanvas * TGo4PreviewPanel::GetQCanvas()
{
   // TGo4LockGuard glob;
    return C;
}



void TGo4PreviewPanel::SetActivePad( TPad *Pad )
{
    // TGo4LockGuard glob;
    if ((ActivePad != Pad) && (Pad!=0)) {
       ActivePad = Pad;
       ActivePad->cd();
       DisplayPadStatus(ActivePad);
       fxTGo4WorkSpace->ActivePadChanged(this, ActivePad);
    }
}

void TGo4PreviewPanel::DropToPadAction(TPad *Pad)
{
   fxTGo4WorkSpace->ActivePadChanged(this,Pad);
    fxTGo4PreviewPanelSlots->RedrawAllLabels(Pad);
}

void TGo4PreviewPanel::Draw( TObject *, TPad *) //Obj, Pad
{
   // TGo4LockGuard glob;
   //C->DrawHist((TH1 *) (Obj), Pad);
}

void TGo4PreviewPanel::ResizeAll()
{
    // TGo4LockGuard glob;
TPad *RootSelectedPad=GetActivePad();
if(RootSelectedPad!=0)
    {
    TH1* h1=GetPadHistogram(RootSelectedPad);
    if (h1)
        {
        h1->GetXaxis()->UnZoom();
        h1->GetYaxis()->UnZoom();
        #ifdef __GO4USEASIMAGE__
        TGo4ASImage* im=GetPadImage(RootSelectedPad);
        if(im) im->SetZoom(dynamic_cast<TH2*>(h1));
        #endif
        }
    RootSelectedPad->Modified();
    RootSelectedPad->PaintModified();
    RootSelectedPad->Update();
    }
}




int  TGo4PreviewPanel::GetNoOfPads()
{
    return fxTGo4PreviewPanelStatus->GetNoOfPads();    
}



bool TGo4PreviewPanel::ApplyToAllPads()
{
   // TGo4LockGuard glob;
    return ApplyToAllflag;
}

TCutG * TGo4PreviewPanel::GetTCutG()
{
    // TGo4LockGuard glob;
    TObject *entry=0;
    TIterator* Padlistiter=0 ;
    TCutG *CG=0;
    TPad *Pad=GetActivePad();
    TList *ListOfPadPrimatives = Pad->GetListOfPrimitives();
    Padlistiter = ListOfPadPrimatives->MakeIterator();
   while((entry= Padlistiter->Next()) !=0) {
      if(entry->InheritsFrom("TCutG")){
         CG = dynamic_cast<TCutG *> (entry);
      }
   }
   delete Padlistiter;
   return CG;
}
void TGo4PreviewPanel::SendToBrowser()
{
   TGo4BrowserSlots *fxBrowser   = (TGo4BrowserSlots *) fxTGo4GUIRegistry->GetSlotClass("TGo4BrowserSlots");
   gROOT->SetBatch(true); // prevent popup of buffer canvas
   TCanvas *fxC=new TCanvas(); 
   C->InsertCanvas(C->GetCanvas(), fxC, false); 
    //better than Clone, because of UID handling; do not create draw options in mother viewpanel!
   fxC->SetName(caption().data());
   //fxTGo4PreviewPanelStatus->RefreshListOfPads(); // after saving canvas rebuild pad refarray with new object ids
   TGo4CanvasWrapper* cwrap=new TGo4CanvasWrapper(fxC); // canvas is not TNamed, we have to wrap it!
   fxBrowser->AddLocalObject(cwrap);
   //cwrap->SetCanvas(0);// change ownership of canvas back to us
   delete cwrap;
   gROOT->SetBatch(false);

}


void TGo4PreviewPanel::InsertCanvas(TCanvas *fxCanvas)
{
   C->InsertCanvas(fxCanvas, GetActivePad());
}

void TGo4PreviewPanel::SetXRange( double Xmin, double Xmax)
{
    TPad *RootSelectedPad=GetActivePad();
   TH1* h1=GetPadHistogram(RootSelectedPad);
   if(h1!=0){
      h1->GetXaxis()->SetRangeUser(Xmin,Xmax);
      RootSelectedPad->Modified();
      RootSelectedPad->PaintModified();
      RootSelectedPad->Update();
      TGo4PadOptions *fxTGo4PadOptions=fxTGo4PreviewPanelStatus->GetPadOptions(RootSelectedPad);
      if(fxTGo4PadOptions)
        fxTGo4PadOptions->SetUxRange(Xmin,Xmax);

   }
}

void TGo4PreviewPanel::SetYRange( double Ymin, double Ymax)
{
    TPad *RootSelectedPad=GetActivePad();
    //TGo4PadOptions *fxTGo4PadOptions=fxTGo4PreviewPanelStatus->GetPadOptions(RootSelectedPad);
    //bool autoscale=fxTGo4PadOptions->GetAutoScale();
   TH1* h1=GetPadHistogram(RootSelectedPad);
   if(h1!=0){
        if(!h1->InheritsFrom("TH2") && !h1->InheritsFrom("TH3"))
             {
                // 1d histograms: range for autoscale defined by Minimum
                         h1->SetMinimum(Ymin);
                         h1->SetMaximum(Ymax);
             }
        h1->GetYaxis()->SetRangeUser(Ymin,Ymax);
      RootSelectedPad->Modified();
      RootSelectedPad->PaintModified();
      RootSelectedPad->Update();
      TGo4PadOptions *fxTGo4PadOptions=fxTGo4PreviewPanelStatus->GetPadOptions(RootSelectedPad);
      if(fxTGo4PadOptions)
        fxTGo4PadOptions->SetUyRange(Ymin,Ymax);

   }
}

void TGo4PreviewPanel::SetAutoScaleOption( bool AutoScale)
{
TPad *activepad=GetActivePad();
if(!ApplyToAllPads())
    {
        TGo4PadOptions *padoptions=fxTGo4PreviewPanelStatus->GetPadOptions(activepad);
        if(padoptions)
            padoptions->SetAutoScale(AutoScale);
        if(AutoScale)
            {
            // unzoom y in case of 1d histograms::
            TH1* padhis=GetPadHistogram(activepad);
            if(padhis && !padhis->InheritsFrom("TH2") && !padhis->InheritsFrom("TH3"))
                {
                   padhis->SetMinimum();
                   padhis->SetMaximum();
                }
            activepad->Modified();
            activepad->Update();
            }
    }
else
    {
        TObject *entry=0;
//       TList *ListOfPads = new TList;
//       ListOfPads->SetOwner(kFALSE);
//       ListOfPads->AddAll(GetListOfPads());
//       TIter Padlistiter(ListOfPads);
       TRefArray *ListOfPads = new TRefArray;
       ListOfPads->AddAll(GetListOfPads());
       TIter Padlistiter(ListOfPads);
        while((entry= Padlistiter.Next()) !=0)
            {
                TPad *pad=dynamic_cast <TPad *>(entry);
                TGo4PadOptions *padoptions=fxTGo4PreviewPanelStatus->GetPadOptions(pad);
                if(padoptions)
                    padoptions->SetAutoScale(AutoScale);
                if(AutoScale)
                    {
                    // unzoom y in case of 1d histograms::
                    TH1* padhis=GetPadHistogram(pad);
                    if(padhis && !padhis->InheritsFrom("TH2") && !padhis->InheritsFrom("TH3"))
                        {
                           padhis->SetMinimum();
                           padhis->SetMaximum();
                        }
                    pad->Modified();
                    pad->Update();
                    }
            }
        SetActivePad(activepad);
        GetCanvas()->Update();
        ListOfPads->Clear("nodelete");
        delete ListOfPads;
    }
}

bool TGo4PreviewPanel::GetPadRanges(TPad *pad,  double &xmin, double &xmax, double &ymin, double &ymax, double &zmin, double &zmax) {
// for the moment we take range from pad/histogram
// later rely on padoptions only?
   bool changed = false;

   TH1* h1 = GetPadHistogram(pad);
   if(h1) {
      TAxis* xax = h1->GetXaxis();
      TAxis* yax = h1->GetYaxis();
      TAxis* zax = h1->GetZaxis();
      if(h1->InheritsFrom("TH3"))
          {
           xmin = xax->GetBinLowEdge(xax->GetFirst());
           xmax = xax->GetBinUpEdge(xax->GetLast());
           ymin = yax->GetBinLowEdge(yax->GetFirst());
           ymax = yax->GetBinUpEdge(yax->GetLast());
           zmin = zax->GetBinLowEdge(zax->GetFirst());
           zmax = zax->GetBinUpEdge(zax->GetLast());
           changed = (xax->GetFirst() > 1) || (xax->GetLast() < xax->GetNbins()) ||
                   (yax->GetFirst() > 1) || (yax->GetLast() < yax->GetNbins()) ||
                   (zax->GetFirst() > 1) || (zax->GetLast() < zax->GetNbins()) ;

          }
      else if (h1->InheritsFrom("TH2"))
          {
             xmin = xax->GetBinLowEdge(xax->GetFirst());
             xmax = xax->GetBinUpEdge(xax->GetLast());
             ymin = yax->GetBinLowEdge(yax->GetFirst());
             ymax = yax->GetBinUpEdge(yax->GetLast());
             zmin = h1->GetMinimum();
             zmax = h1->GetMaximum();
         changed = (xax->GetFirst() > 1) || (xax->GetLast() < xax->GetNbins()) ||
                   (yax->GetFirst() > 1) || (yax->GetLast() < yax->GetNbins());

      } else
      if(h1->InheritsFrom("TH1")) {
         xmin = xax->GetBinLowEdge(xax->GetFirst());
         xmax = xax->GetBinUpEdge(xax->GetLast());
            //xmin=pad->GetUxmin();
            //xmax=pad->GetUxmax();
         ymin = h1->GetMinimum();
         ymax = h1->GetMaximum();
         changed = (xax->GetFirst() > 1) || (xax->GetLast() < xax->GetNbins());
       }
    } else {
       // no histogram there: use padoption ranges
       TGo4PadOptions *padoptions = fxTGo4PreviewPanelStatus->GetPadOptions(pad);
       if(padoptions)
           {
               padoptions->GetUxRange(xmin,xmax);
               padoptions->GetUyRange(ymin,ymax);
               padoptions->GetUzRange(zmin,zmax);
           }
   }
   return changed;
}

void TGo4PreviewPanel::GetRanges( double &xmin, double &xmax, double &ymin, double &ymax , double &zmin, double &zmax) {
// access to ranges of the active pad:
   GetPadRanges(GetActivePad(), xmin, xmax, ymin, ymax, zmin, zmax);
}


void TGo4PreviewPanel::SetScaleRange( double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, bool autoscale) {
   TPad *activepad=GetActivePad();
   if(!ApplyToAllPads()) {  // single pad
      SetPadScaleRange(activepad,xmin,xmax,ymin,ymax,zmin, zmax, autoscale);
   } else {
      
      QApplication::setOverrideCursor( Qt::WaitCursor );
      TObject* entry=0;
      TRefArray *ListOfPads = new TRefArray;
       ListOfPads->AddAll(GetListOfPads());
       TIter Padlistiter(ListOfPads);
      while((entry= Padlistiter.Next()) !=0) {
         TPad *pad=dynamic_cast <TPad *>(entry);
         SetPadScaleRange(pad,xmin,xmax,ymin,ymax,zmin,zmax,autoscale);
      }// while
      ListOfPads->Clear("nodelete");
      delete ListOfPads;
      SetActivePad(activepad);
      GetCanvas()->Update();
      QApplication::restoreOverrideCursor();
   } // if(!fxTGo4PreviewPanel->ApplyToAllPads())
fxTGo4WorkSpace->ActivePadChanged(this, activepad);
}


void TGo4PreviewPanel::SetPadScaleRange( TPad * pad, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, bool autoscale) {
   TGo4PadOptions *padoptions = fxTGo4PreviewPanelStatus->GetPadOptions(pad);
   if(padoptions)
    {
       padoptions->SetAutoScale(autoscale);
       padoptions->SetUxRange(xmin,xmax);
       padoptions->SetUyRange(ymin,ymax);
       padoptions->SetUzRange(zmin,zmax);
    }
   TH1* h1=GetPadHistogram(pad);
   if(h1) {
      h1->GetXaxis()->SetRangeUser(xmin,xmax);
      h1->GetYaxis()->SetRangeUser(ymin,ymax);
      h1->GetZaxis()->SetRangeUser(zmin,zmax);
      Int_t dimension=h1->GetDimension();
      //if(!h1->InheritsFrom("TH2") && !h1->InheritsFrom("TH3")) {
      if(!autoscale)
          {
            if(dimension==1)
                {
                    h1->SetMinimum(ymin);
                    h1->SetMaximum(ymax);
                }
            else if(dimension==2)
                {
                    h1->SetMinimum(zmin);
                    h1->SetMaximum(zmax);
                }
            else
                {
                    h1->SetMinimum();
                    h1->SetMaximum();
                }
          }
      else
          {
            h1->SetMinimum();
            h1->SetMaximum();
          }
      //}
#ifdef __GO4USEASIMAGE__
      TGo4ASImage* im=GetPadImage(pad);
      if(im) im->SetZoom(dynamic_cast<TH2*>(h1));
#endif
      pad->Modified();
      pad->PaintModified();
      pad->Update();
   }
}

bool TGo4PreviewPanel::GetAutoScaleOption()
{
    TPad *RootSelectedPad = GetActivePad();
    TGo4PadOptions *fxTGo4PadOptions = fxTGo4PreviewPanelStatus->GetPadOptions(RootSelectedPad);
    if(fxTGo4PadOptions)
        return (fxTGo4PadOptions->GetAutoScale());
    else
        return true;
}


void TGo4PreviewPanel::SetZRange(double  , double ) //Zmin, Zmax
{

}

double TGo4PreviewPanel::GetXmin()
{
return 0;
}

double TGo4PreviewPanel::GetXmax()
{
return 0;
}

double TGo4PreviewPanel::GetYmin()
{
return 0;
}

double TGo4PreviewPanel::GetYmax()
{
return 0;
}


double TGo4PreviewPanel::GetZmin()
{
return 0;
}

double TGo4PreviewPanel::GetZmax()
{
return 0;
}


TRefArray *  TGo4PreviewPanel::GetListOfPads()
{
   return fxTGo4PreviewPanelStatus->GetListOfPads();
}



void TGo4PreviewPanel::StartConditionEditor()
{
    TGo4MainWindow* mw= (TGo4MainWindow*) fxTGo4GUIRegistry->GetMainWindow();
    mw->ConditionEditSlot(0,this);
}


void TGo4PreviewPanel::enterEvent( QEvent * e )
{
    if(fbEditorFrameVisible
         && fxTGo4WorkSpace->GetLastActiveViewPanel()==this)
        {
             bool isimage=false;
             const char* drawopt = fxTGo4PreviewPanelStatus->GetPadStringDrawOption(ActivePad);
             if ((drawopt!=0) && (strstr(drawopt,"asimage")))
                isimage=true; // if we have asimage before, root editor can not change that style
                              // supress overriding the padoption drawstyle then  
             TH1* his = GetPadHistogram(ActivePad);
             fxTGo4PreviewPanelSlots->UpdatePad(ActivePad,his,true,!isimage);
             bool crosshair = ActivePad->HasCrosshair();
             fxTGo4PreviewPanelStatus->SetPadCrosshair(ActivePad,crosshair);                
             fxTGo4WorkSpace->ActivePadChanged(this, ActivePad);
        }
    EnablePolymarker(fxTGo4PreviewPanelStatus->GetNoOfPads()==1);
    //fxTGo4PreviewPanelStatus->CleanupPadLists(GetCanvas()); // test
    QWidget::enterEvent(e);
}

void TGo4PreviewPanel::leaveEvent( QEvent * e )
{
    #if __GO4ROOTVERSION__ < 40301   
    fxTGo4PreviewPanelSlots->CleanupPadEditor(); //avoid confusion of root TGedEditor cache between different viewpanels
    #endif
    QWidget::leaveEvent(e);
}

void TGo4PreviewPanel::resizeEvent( QResizeEvent * e )
{
//cout <<"Resize event previewpanel " << endl;
   TGo4MainWindow* mw= (TGo4MainWindow*) fxTGo4GUIRegistry->GetMainWindow();
   mw->RememberViewpanelSize(this);
   QWidget::resizeEvent(e);
}

void TGo4PreviewPanel::DisplayPadStatus( TPad * pad )
{
   QString output=pad->GetName();
   output.append(": ");
   TGo4PadOptions *fxOptions= fxTGo4PreviewPanelStatus->GetPadOptions(pad);
   if(fxOptions!=0) {
       bool superImpose = fxOptions->DragAddOption();
       if (superImpose) output.append(" SuperImpose:");
       if (ApplyToAllPads())output.append(" All Pads:");
   }
   output.append(" Ready");
   CanvasStatus->message(output);
}


void TGo4PreviewPanel::SetCrosshairDefault( bool on )
{
    fbCrosshairDefault=on;
}

void TGo4PreviewPanel::SetPadFillColor( int num )
{
    fiPadFillColor=num;
}

TGo4PreviewPanelStatus* TGo4PreviewPanel::GetStatus() {
   return fxTGo4PreviewPanelStatus;
}

TGo4PreviewPanelSlots* TGo4PreviewPanel::GetSlots() {
   return fxTGo4PreviewPanelSlots;
}


void TGo4PreviewPanel::ClickOnPad( TPad * pad )
{
    SetActivePad(pad);// for user convenience, left button or mid button will change focus
    if(fbNeedsMemSync)
    {
        // case after root right mouse menu has been invoked
        TGo4BrowserSlots *fxBrowser   = (TGo4BrowserSlots *) fxTGo4GUIRegistry->GetSlotClass("TGo4BrowserSlots");
        if(fxBrowser) fxBrowser->SynchronizeWithMemory();
        fbNeedsMemSync=false;
        fxTGo4PreviewPanelStatus->UpdateSubPads(GetCanvas());    
        //fxTGo4PreviewPanelStatus->CleanupPadLists(GetCanvas()); //   
        EnablePolymarker(fxTGo4PreviewPanelStatus->GetNoOfPads()==1);
    }
    fxTGo4PreviewPanelSlots->MouseClick(pad);
    
    fxTGo4WorkSpace->PadClicked(this,pad);
}


void TGo4PreviewPanel::SetCursorMode( bool on )
{
if(!fbTypingMode) return;
if(on)
        fxTGo4PreviewPanelSlots->SetMouseMode(kMousePickCursor);
else
        fxTGo4PreviewPanelSlots->SetMouseMode(kMouseROOT);
RefreshButtons();
}


void TGo4PreviewPanel::SetRegionMode( bool on )
{
if(!fbTypingMode) return;
if(on)
    {
        fxTGo4PreviewPanelSlots->SetMouseMode(kMousePickLimits);
        fxTGo4PreviewPanelSlots->ResetPickCounter();
    }
else
    {
        fxTGo4PreviewPanelSlots->SetMouseMode(kMouseROOT);
    }
RefreshButtons();
}

void TGo4PreviewPanel::SetPolygonMode( bool on )
{
if(!fbTypingMode) return;
if(on)
    {    
        fxTGo4PreviewPanelSlots->SetMouseMode(kMousePickPolygon);
        fxTGo4PreviewPanelSlots->ResetPickCounter();
    }
else
    {
        fxTGo4PreviewPanelSlots->SetMouseMode(kMouseROOT);
    }
RefreshButtons();
}

void TGo4PreviewPanel::SetLateXMode( bool on )
{
if(!fbTypingMode) return;
if(on)
    fxTGo4PreviewPanelSlots->SetMouseMode(kMousePickLatex);
else
    fxTGo4PreviewPanelSlots->SetMouseMode(kMouseROOT);
RefreshButtons();
}


void TGo4PreviewPanel::SetDrawingMode( bool on )
{
if(!fbTypingMode) return;
if(on)
    fxTGo4PreviewPanelSlots->SetMouseMode(kMouseDraw);
else
    fxTGo4PreviewPanelSlots->SetMouseMode(kMouseROOT);
RefreshButtons();
}



void TGo4PreviewPanel::SetFreezeMouseMode( bool on )
{
if(!fbTypingMode) return;
fxTGo4PreviewPanelSlots->SetPickAgain(on);
if(on)
    {
        // set default mode if no go4 mousemode selected:
        if(fxTGo4PreviewPanelSlots->GetMouseMode()==kMouseROOT)
            fxTGo4PreviewPanelSlots->SetMouseMode(kMousePickCursor);
    }
else
    {
        fxTGo4PreviewPanelSlots->SetMouseMode(kMouseROOT);
    }
RefreshButtons();
}


void TGo4PreviewPanel::SetNewMarkerMode( bool on )
{
if(!fbTypingMode) return;
fxTGo4PreviewPanelSlots->SetCreateNewMarker(on);
RefreshButtons();
}


void TGo4PreviewPanel::RefreshButtons()
{
MarkerPanel->setShown(fbMarkEditorVisible);
if(!fbMarkEditorVisible) return;
fbTypingMode=false;
PolyB->setDisabled(fxTGo4PreviewPanelStatus->GetNoOfPads()>1);
QString activename;
bool createnewmarker=fxTGo4PreviewPanelSlots->IsCreateNewMarker();
switch(fxTGo4PreviewPanelSlots->GetMouseMode())
    {
    case kMouseROOT:
        CursorB->setOn(false);
        RegionB->setOn(false);
        LatexB->setOn(false);
        DrawB->setOn(false);
        PolyB->setOn(false);
        activename="ROOT Mouse";
        break;

    case kMousePickCursor:
        CursorB->setOn(true);
        RegionB->setOn(false);
        LatexB->setOn(false);
        DrawB->setOn(false);
        PolyB->setOn(false);
        if(createnewmarker)
           activename="new marker";
        else
           activename=fxTGo4PreviewPanelSlots->GetActiveMarkerName(GetActivePad());
        break;

    case kMousePickLimits:
        CursorB->setOn(false);
        RegionB->setOn(true);
        LatexB->setOn(false);
        DrawB->setOn(false);
        PolyB->setOn(false);
        if(createnewmarker)
            activename="new window";
        else
            activename=fxTGo4PreviewPanelSlots->GetActiveRegionName(GetActivePad());
        break;

    case kMousePickPolygon:
        CursorB->setOn(false);
        RegionB->setOn(false);
        LatexB->setOn(false);
        DrawB->setOn(false);
        PolyB->setOn(true);
        if(createnewmarker)
            activename="new polygon";
        else
            activename=fxTGo4PreviewPanelSlots->GetActivePolygonName(GetActivePad());
        break;


    case kMousePickLatex:
        CursorB->setOn(false);
        RegionB->setOn(false);
        LatexB->setOn(true);
        DrawB->setOn(false);
        PolyB->setOn(false);
        if(createnewmarker)
           activename="new latex";
        else
            activename=fxTGo4PreviewPanelSlots->GetActiveLatexName(GetActivePad());
        break;

    case kMouseDraw:
        // currently, we only draw arrows:
        CursorB->setOn(false);
        RegionB->setOn(false);
        LatexB->setOn(false);
        DrawB->setOn(true);
        PolyB->setOn(false);
        activename="draw arrow";
        break;

    case kMouseSelectObject:
        // this is the case directly after rootmouse selected one of our objects
        activename="selected: ";
        activename.append(fxTGo4PreviewPanelSlots->GetSelectedName());
        fxTGo4PreviewPanelSlots->SetMouseMode(kMouseROOT);
        break;

    case kMouseConditionEditor:
        CursorB->setOn(false);
        RegionB->setOn(false);
        LatexB->setOn(false);
        DrawB->setOn(false);
        PolyB->setOn(false);
        activename="Condition editor";
        break;

    default:
        CursorB->setOn(false);
        RegionB->setOn(false);
        LatexB->setOn(false);
        DrawB->setOn(false);
        PolyB->setOn(false);
        activename="no mousemode!";
        break;

    }; // switch()
ActiveLabel->setText(activename);
FreezeMode->setChecked(fxTGo4PreviewPanelSlots->IsPickAgain());
NewMarkerMode->setChecked(createnewmarker);
polish();
update();
show();
fbTypingMode=true;
}


void TGo4PreviewPanel::SetMarkerPanel()
{
fbMarkEditorVisible= !EditMenu->isItemChecked(ShowMarkEditorId);
EditMenu->setItemChecked(ShowMarkEditorId, fbMarkEditorVisible);
if(!fbMarkEditorVisible)
    { 
         // switch back to normal root mouse when editor is hidden
        fxTGo4PreviewPanelSlots->SetMouseMode(kMouseROOT);
        gROOT->SetEditorMode("");
        fxTGo4PreviewPanelSlots->ResetPickCounter();
    }
RefreshButtons();
}
 



void TGo4PreviewPanel::LogMarkerValues()
{
fxTGo4PreviewPanelSlots->ScanMarkers(GetActivePad());
fxTGo4PreviewPanelSlots->LogMarkers("go4log");
}


void TGo4PreviewPanel::ClearAllMarkers()
{
TPad* activepad=GetActivePad();
if(!ApplyToAllPads()) 
    {
      fxTGo4PreviewPanelSlots->ClearAllLabels(activepad);
      activepad->Modified();
      activepad->Update();
    } 
else 
    {
      TObject *entry=0;
//      TList *ListOfPads = new TList;
//      ListOfPads->SetOwner(kFALSE);
//      ListOfPads->AddAll(GetListOfPads());
//      TIter Padlistiter(ListOfPads);
      TRefArray *ListOfPads = new TRefArray;
       ListOfPads->AddAll(GetListOfPads());
       TIter Padlistiter(ListOfPads);      
      while((entry= Padlistiter.Next()) !=0) {
         TPad *pad=dynamic_cast <TPad *>(entry);         
         pad->cd(); // needed for UnDraw of conditions...
         fxTGo4PreviewPanelSlots->ClearAllLabels(pad);
         pad->Modified();
         pad->Update();
      }
      activepad->cd();
      ListOfPads->Clear("nodelete");
      delete ListOfPads;
   }
}


void TGo4PreviewPanel::SaveMarkers()
{
    QFileDialog* fd = new QFileDialog( this, "Save Markers", TRUE );
    fd->setCaption("Save Markers of active pad into ");
    fd->setMode( QFileDialog::AnyFile);
    fd->setName( "Save to file: ");
    fd->setFilter( "ROOT file (*.root)");
    if ( fd->exec() == QDialog::Accepted ) {
       QString filename = fd->selectedFile();
       if (!filename.endsWith(".root")) filename.append(".root");
       fxTGo4PreviewPanelSlots->SaveMarkerSetup(filename,"Markersetup");
    }
    delete fd;
}

void TGo4PreviewPanel::LoadMarkers()
{
    QFileDialog* fd = new QFileDialog( this, "Load Markers", TRUE );
    fd->setCaption("Load Marker setup from:");
    fd->setMode( QFileDialog::ExistingFile );
    fd->setName( "Load from file: ");
    fd->setFilter( "ROOT file (*.root)");
    if ( fd->exec() == QDialog::Accepted ) {
        QString filename = fd->selectedFile();
        fxTGo4PreviewPanelSlots->LoadMarkerSetup(filename,"Markersetup");
    }
    delete fd;
}


void TGo4PreviewPanel::SyncRootMemory()
{
fbNeedsMemSync=true;
}


void TGo4PreviewPanel::SetViewpanelTitle()
{
bool ok=false;
QString mycaption=caption();
QString oldtitle=mycaption.remove(name());
QString text = QInputDialog::getText(
            name(), "Enter Viewpanel Title:", QLineEdit::Normal,
            oldtitle, &ok, this );
if ( ok && !text.isEmpty() )
    {
    // user entered something and pressed OK
       mycaption=name();
       mycaption.append(text);
       setCaption(mycaption);
       fbFreezeTitle=kTRUE; // automatic freeze when user sets title
       OptionsMenu->setItemChecked(FreezeTitleId,fbFreezeTitle);
    }
else
    {
        // user entered nothing or pressed Cancel
    }
}


bool TGo4PreviewPanel::IsFreezeTitle()
{
return fbFreezeTitle;
}


void TGo4PreviewPanel::SetFreezeTitle()
{
fbFreezeTitle = !OptionsMenu->isItemChecked(FreezeTitleId);
OptionsMenu->setItemChecked(FreezeTitleId,fbFreezeTitle);
}


void TGo4PreviewPanel::UpdateMarkersHistogram()
{
// called by TGo4QItem before updating the pad (e.g. monitoring mode)
//fxTGo4PreviewPanelSlots->SetMarkersHistogram();
//fxTGo4PreviewPanelSlots->SetRegionsHistogram();
fxTGo4PreviewPanelSlots->SetPolygonsHistogram();
}


void TGo4PreviewPanel::EnablePolymarker( bool on )
{
PolyB->setDisabled(!on); 
if( !on && fxTGo4PreviewPanelSlots->GetMouseMode()==kMousePickPolygon)
    fxTGo4PreviewPanelSlots->SetMouseMode(kMouseROOT); // prevent polygon edit in subpads
 
}

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

---