---

/Go4GUI/TGo4WindowEditSlots.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 "TGo4WindowEditSlots.h"

#include <iostream.h>

#include "TPad.h"
#include "TCanvas.h"
#include "TPaveText.h"
#include "TRefArray.h"

#include "Go4GUIRegistry/TGo4GUIRegistry.h"
#include "Go4LockGuard/TGo4LockGuard.h"
#include "Go4StatusBase/TGo4Status.h"
#include "Go4ConditionsBase/TGo4Condition.h"
#include "Go4ConditionsBase/TGo4CondArray.h"
#include "Go4ConditionsBase/TGo4WinCond.h"
#include "Go4ConditionsBase/TGo4PolyCond.h"
#include "Go4CommandsAnalysis/TGo4ComGetObject.h"
#include "Go4CommandsAnalysis/TGo4ComGetCondition.h"
#include "Go4CommandsAnalysis/TGo4ComSetCondition.h"
#include "TGo4WindowEdit.h"
#include "TGo4PreviewPanel.h"
#include "TGo4PreviewPanelSlots.h"
#include "TGo4PadOptions.h"
#include "TGo4MainWindow.h"
#include "TGo4BrowserSlots.h"
#include "TGo4Browser.h"
#include "Go4QtBaseWidgets/TGo4QItem.h"
#include "Go4QtBaseWidgets/TGo4QPicItem.h"
#include "TGo4WindowEditStatus.h"

TGo4WindowEditSlots::TGo4WindowEditSlots(const char * name, const char * title,  TGo4WindowEdit * p)
:TGo4SlotsBaseClass(name , title),
   fxTGo4GUIRegistry(0),fxTGo4WindowEdit(p),fxTGo4WindowEditStatus(0),
   fxView(0),fxWorkView(0), fiCurrentPad(0), fiNumPads(1), fxHisto(0),
   fbHideAll(kFALSE),
   fiMouseMode(kMouseROOT),
   fbPickArray(kFALSE), fuPickCounter(0),
   fbInitDone(kFALSE), fbNeedsUpdate(kFALSE)

{
   TGo4LockGuard Global;
   fxPad.clear();
   for(Int_t ix=0; ix<fiNumPads; ++ix) fxPad.push_back(0);
   char StatusName[256];
   fxTGo4GUIRegistry=TGo4GUIRegistry::Instance();
   snprintf(StatusName,255,"%s%s",name,"_Status" );
   fxTGo4WindowEditStatus= new TGo4WindowEditStatus(StatusName, "Cond. Status");
   fxTGo4WindowEditStatus->SetSlot(this);
   fxTGo4GUIRegistry->RegisterSlotClass(this, fxTGo4WindowEditStatus, p);
   TGo4MainWindow* mw= (TGo4MainWindow*) fxTGo4GUIRegistry->GetMainWindow();
   mw->RegisterWindowEditSlots(this);
}

TGo4WindowEditSlots::~TGo4WindowEditSlots()
{
   TGo4MainWindow* mw= (TGo4MainWindow*) fxTGo4GUIRegistry->GetMainWindow();
   mw->UnregisterWindowEditSlots(this);
   // cleanup viewpanel mousemode on exit:
   TGo4PreviewPanelSlots* wvslots=0;
   if(fxWorkView) wvslots=fxWorkView->GetSlots();
   if(wvslots) wvslots->SetMouseMode(kMouseROOT);   
   TPad* wpad=WorkingPad();
   if(wpad)
   {
      TPad* savepad= (TPad*) gPad;
      wpad->cd(); // set gPad for correct conditionpainter dtors
      delete fxTGo4WindowEditStatus;
      wpad->Modified();
      wpad->Update();  // clear our graphical objects before leaving
      savepad->cd();
   }
   else
   {
      //cout << "wwwwwwww TGo4WindowEditSlots::~TGo4WindowEditSlots() with zero workingpad" << endl;
      delete fxTGo4WindowEditStatus;
   }
//   cout << "TGo4WindowEditSlots::~TGo4WindowEditSlots() End " << endl;
}

TGo4Status* TGo4WindowEditSlots::GetStatus() 
{
   return fxTGo4WindowEditStatus;
}


void TGo4WindowEditSlots::AddObject(TNamed *fxData)
{
   if(fxData==0) return;
   TGo4LockGuard Global;
//   cout << "TGo4WindowEditSlots::AddObject(TNamed *fxData)"  << fxData->GetName() << endl;
   TGo4Condition* condi=0;
   if(fxData->InheritsFrom("TGo4Condition"))
      {
          condi=dynamic_cast <TGo4Condition*> (fxData->Clone());
          if(fxTGo4WindowEdit==0)
            {
               fxTGo4WindowEdit= new TGo4WindowEdit(fxTGo4GUIRegistry->GetCentralWindow(),fxData->GetName());
               fxTGo4WindowEdit->show();
            }
          else {}
      }
   else
      {
          condi=0;
      }
   ClearConditions(kFALSE);
   fxTGo4WindowEditStatus->SetCondition(condi);
   fbNeedsUpdate=kFALSE;
   // look for linked histogram if existing:
   if(condi && condi->IsHistogramLink() && !fxTGo4WindowEdit->IsCentralMode())
      {
         const Text_t* hname=condi->GetLinkedHistogram();
         // search histogram in local list by name:
         TPad* pad=0;
         TCanvas *can=0;
         TGo4PreviewPanel* viewpanel=0;
         TGo4BrowserSlots* brslot=dynamic_cast<TGo4BrowserSlots*>(fxTGo4GUIRegistry->GetSlotClass("TGo4BrowserSlots"));
         TGo4MainWindow* mw= (TGo4MainWindow*) fxTGo4GUIRegistry->GetMainWindow();
         if(brslot)
            {
            TGo4Browser* brgui=brslot->GetBrowserGUI();
            TGo4QItem* hitem= (TGo4QItem*)  brgui->ListViewLocal->findItem(hname,0);
            if(hitem)
               {
                 // if found, get the pad where it was drawn
                 pad=hitem->GetDrawPad();
                 can=hitem->GetDrawCanvas();
                 viewpanel=hitem->GetDrawPanel();
                 if(!hitem->IsExisting(can, pad))
                    {
                        // create new pad
                        //cout <<"canvas already gone, create new" << endl;
                         viewpanel =mw->ViewPanelSlot(1);
                         hitem->DrawObj(viewpanel);
                         pad=hitem->GetDrawPad();
                         can=hitem->GetDrawCanvas();
                    }
                  // use the pad with the histogram as working pad for
                  // condition editor:
                  if(pad)
                     viewpanel->SetActivePad(pad);
                  SetViewPanel(viewpanel);
                  SetWorkingPad();
               } // if(hitem)
            else
               {
                 //cout <<"item not found" << endl;
               } // if(hitem)
            }// if(brslot)
         else{}
      }//if(condi && condi->IsHistogramLink())
   else {}
   fxTGo4WindowEdit->RefreshDisplay();
   DrawMarkers();
}

void TGo4WindowEditSlots::SendUpdateCommand(const Text_t* newname)
{
   TGo4LockGuard Global;
   TGo4Condition* con=fxTGo4WindowEditStatus->GetCondition();
   if(con)
   {
      Text_t oldname [256];
      if(newname)
         snprintf(oldname,256,"%s",con->GetName());
      TGo4ComSetCondition* com = new  TGo4ComSetCondition();
      if(newname) con->SetName(newname);
      Bool_t multi=con->IsMultiEdit();
      con->SetMultiEdit(kTRUE);// Multiedit mode for condarrays
                               // preserves functionality of old code
                               // we switch to it for compatibility.
      com->SetCondition(con);
      fxTGo4GUIRegistry->SubmitCommand(com);
      if(newname) con->SetName(oldname);
      SetWorkPadCondition(con); // store updated con in viewpanel
      con->SetMultiEdit(multi); // back to old mode for editor
      fbNeedsUpdate=kFALSE;
   }
}

void TGo4WindowEditSlots::SendRefreshCommand(const Text_t* newname)
{
   TGo4LockGuard Global;
   const Text_t* name;
   TGo4Condition* con=fxTGo4WindowEditStatus->GetCondition();
   if(con)
      {
         // test if condition has associated histo and request it
         if(con->IsHistogramLink())
            {
                const Text_t* hname=con->GetLinkedHistogram();
                TGo4ComGetObject *hcom = new TGo4ComGetObject(hname);
                fxTGo4GUIRegistry->SubmitCommand(hcom,hname);
                //cout <<"Window editor requests linked histo"<<hname << endl;
            }
         // request current condition
         if(newname)
            name=newname;
         else
            name=con->GetName();
      }
   else
      {
         name=newname;
      }
   TGo4ComGetCondition *com = new TGo4ComGetCondition(name);
   fxTGo4GUIRegistry->SubmitCommand(com,name,this);
}

void TGo4WindowEditSlots::CreateNewCondition(const Text_t* name,
                                    const Text_t* classname, Int_t num, Int_t dim)
{
if(name=="") return;
 TGo4LockGuard main;
 //if(strstr(name,"/")) return; // disable subfolder creation
 //cout <<"new condition for "<<name <<",class "<<classname << endl;
 TGo4Condition* condi;
 TClass* nclass=gROOT->GetClass(classname);
 if(nclass && nclass->InheritsFrom("TGo4Condition"))
    {
       if(num>1)
          {
              // condition array case:
             TGo4CondArray* arconny=new TGo4CondArray(name,num, classname);
             TGo4WinCond* win=0;
             TGo4PolyCond* pol=0;
             Double_t a=100; // width/offset of window condition
             Double_t b=10;  // margin distance of window condition
             Double_t c=60;  //offset between polygon conditons
             Double_t d=200;  // basewidth for polygon triangle
             for(int i=0; i<num; ++i)
                {
                   if((win=arconny->Win(i))!=0) 
                     {
                        win->SetDimension(dim);
                        if(dim>1)
                           win->SetValues(a*i,a*(i+1)-b,a*i,a*(i+1)-b);
                        else
                           win->SetValues(a*i,a*(i+1)-b);
                      }
                   else if ((pol=arconny->Poly(i))!=0)
                     {
                        Double_t initx[4]={c*i, c*i+d, c*i+0.5*d,c*i};
                        Double_t inity[4]={c*i, c*i, c*i+d,c*i};
                        pol->SetValues(initx,inity,4);   
                     } 
                }
             condi=arconny;
          }
       else
          {
             // single condition
             condi= (TGo4Condition*) nclass->New();
             //cout <<"created condition object of class "<<classname << endl;
             condi->SetName(name); // preserve name
          }
      condi->Enable();
      condi->SetDimension(dim);
      condi->SetBit(TGo4Status::kGo4CanDelete); // analysis may delete this one later
      AddObject(condi);
      delete condi;
    }
 else
   {
      //cout <<"Could not set condition to class "<< name << endl;
   }
}


void TGo4WindowEditSlots::SetWorkingPad()
{
TGo4LockGuard Global;
// get active pad pointer from framework:
ClearConditions(kTRUE); // but keep label boxes
fxPad.clear();
fiNumPads=1;
fiCurrentPad=0;
fxWorkView=fxView; // remember viewpanel that contains the pad
if(fxWorkView)
   {
      fxPad[0]=fxWorkView->GetActivePad();
   }
else
   {
      fxPad[0]=0;
   }
SetHistogram();
}

void TGo4WindowEditSlots::SetHistogram()
{
   if(fxWorkView)
      {
         fxHisto= fxWorkView->GetPadHistogram(WorkingPad());
      }
   else
      {
          fxPad[fiCurrentPad]=0;
          fxHisto=0;
      }
}


void TGo4WindowEditSlots::SetViewPanel(TGo4PreviewPanel* view)
{
   fxView=view;
   //cout <<"TGo4WindowEditSlots::SetViewPanel to "<<view << endl;
   SetHistogram(); // redefine histogram whenever mainwindow signals change

}

void TGo4WindowEditSlots::Click(TGo4PreviewPanel* view, TPad* pad)
{
TPad* wpad=WorkingPad();
if(view==fxWorkView && wpad==pad)
   {
      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 mix,ix=0;
      TPad* pad=0;
      switch(fiMouseMode)
         {
         case kMouseROOT:

            break;

         case kMousePickCursor:
            // no cursor anymore in condition editor...
            break;

         case kMousePickLimits:
            pad=wpad;
            px = pad->GetEventX();
            py = pad->GetEventY();
            x  = pad->PadtoX(pad->AbsPixeltoX(px));
            y  = pad->PadtoX(pad->AbsPixeltoY(py));
            xmin=fxTGo4WindowEditStatus->Xmin();
            xmax=fxTGo4WindowEditStatus->Xmax();
            ymin=fxTGo4WindowEditStatus->Ymin();
            ymax=fxTGo4WindowEditStatus->Ymax();
            if(fuPickCounter==2)
               {
                  xmin=x;
                  xmax=x;
                  ymin=y;
                  ymax=y;
               }
            else if (fuPickCounter==1)
               {
                    xmax=x;
                    ymax=y;
               }
            else
               {
                  cout <<"TGo4WindowEditSlots::Click() NEVER COME HERE" << endl;
               }
            SetLimits(xmin,xmax,ymin,ymax);
            DrawConditions();
            if(fuPickCounter==1)
               {
                  if(IsPickArray() && fxTGo4WindowEditStatus->IsArray())
                     {
                         //chose next condition in array
                         ix=fxTGo4WindowEditStatus->GetCurrentIndex();
                         mix=fxTGo4WindowEditStatus->GetNumberOfConditions()-1;
                         if(++ix>mix) ix=mix;
                         fxTGo4WindowEdit->SelectedCond(ix);
                         fuPickCounter=3; // mind the decrement
                     }
                  else
                     {
                        fiMouseMode=kMouseROOT; // reset pick
                     }
               }
            fuPickCounter--;
            fxTGo4WindowEdit->RefreshEditor();
            break;

         case kMouseDraw:

            break;

         default:
            break;

      } // switch(fiMouseMode)
   } //if(fxView==fxWorkView && WorkingPad()!=0)
}

void TGo4WindowEditSlots::RemoveViewPanel(TGo4PreviewPanel* view)
{
if(view==fxWorkView)
   {
    fxPad.clear();
    fiNumPads=1;
    fiCurrentPad=0;
    fxPad[0]=0;
    fxView=0;
    fxWorkView=0;
    if(fxTGo4WindowEdit->IsCentralMode())
      {
         //fxTGo4WindowEdit->SetCentralMode(true); // re-init editor
         fxTGo4WindowEdit->ResetConditionNames();
     }
   }
else if(view==fxView)
   {
      fxView=0;
   }
else {}
SetHistogram();
fxTGo4WindowEdit->RefreshEditor();
}

void TGo4WindowEditSlots::DrawMarkers()
{
DrawConditions();
}


void TGo4WindowEditSlots::DrawConditions()
{
TGo4LockGuard Global;
TPad* wpad=WorkingPad();
if(wpad==0) return;
TPad* savepad= (TPad*) gPad;
wpad->cd();
//cout <<"DrawConditions on pad "<< WorkingPad() << endl;
//if(!fbHideAll)
   {
   TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
   if(conny)
      {
         //conny->UnDraw();
         // <-prevent multiple entries in list yielding multiple conditions when saving and restoring the canvas!
         conny->SetWorkHistogram(fxHisto); // for statistics boxes
         conny->SetLineColor(2);
         conny->SetFillColor(2);
         conny->SetFillStyle(3002);
         //gPad->GetListOfPrimitives()->Remove(conny);
         // <-prevent multiple entries in list yielding multiple conditions when saving and restoring the canvas!
         conny->Draw("fixstyle"); // always use editor styles for graphics, no user colors/style allowed
      }
   else
      {
         //cout <<"Condition editor with no condition, never come here!" << endl;
         // this can happen, if workpad condition is zero!
      }
   if(fxTGo4WindowEditStatus->IsPolygon())
      TGo4PolyCond::CleanupSpecials();
   }
//else
//   {
//   // in hide mode, we refresh nothing; all cleared stays invisible
//   } //if(!fbHideAll)

wpad->Modified();
wpad->Update();
savepad->cd();
}



void TGo4WindowEditSlots::HighlightCondition(Int_t )
{
// highlighting is now done from condarraypainter; need
// special highlighting method in painter for speeding it up?
// so far, we only update the pad -> Paint will repaint complete array
// with newly set active condition
//TGo4LockGuard Global;
TPad* wpad=WorkingPad();
if(wpad==0) return;
wpad->Modified();
wpad->Update();
}






void TGo4WindowEditSlots::ClearConditions(Bool_t keeplabels)
{
TPad* wpad=WorkingPad();
if(wpad==0) return;
TGo4LockGuard Global;
TPad* savepad= (TPad*) gPad;
wpad->cd();
//cout <<"Condition editor changes pad to "<<WorkingPad() << endl;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny)
   {
      if(keeplabels)
         conny->UnDraw("keeplabel");
      else
         conny->UnDraw();
   }
else
   {
      //cout <<"Condition editor with no condition, never come here!" << endl;
      // central editor may have zero condition pointer though...
   }

if(fxTGo4WindowEditStatus->IsPolygon())
   TGo4PolyCond::CleanupSpecials();
wpad->Modified();
wpad->Update();
savepad->cd();
}



void TGo4WindowEditSlots::EnterEvent()
{
//TGo4LockGuard Global;
//cout <<"TGo4WindowEditSlots::EnterEvent()" << endl;
// check if condition was updated from graphics:
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny && conny->IsChanged())
   {
      fbNeedsUpdate=kTRUE;
      conny->SetChanged(kFALSE);
   }
if(fxTGo4WindowEditStatus->IsPolygon())
    TGo4PolyCond::CleanupSpecials();
}

void TGo4WindowEditSlots::ClearCounters()
{
TGo4LockGuard Global;
TGo4Condition* workingcon=fxTGo4WindowEditStatus->GetCondition();
if(workingcon==0) return;
workingcon->ResetCounts();
workingcon->MarkReset(kTRUE);
SendUpdateCommand();
SendRefreshCommand();
}

void TGo4WindowEditSlots::SetLimits(Double_t xmin,
                          Double_t xmax,
                          Double_t ymin, Double_t ymax)
{
TGo4Condition* workingcon=fxTGo4WindowEditStatus->GetCondition();
if(workingcon==0) return;
if(fxTGo4WindowEditStatus->Is2D())
      workingcon->SetValues(xmin,xmax,ymin,ymax);
else
      workingcon->SetValues(xmin,xmax);
// note that condition dimension will be changed due to this call!
// we stick to the initial definition!
}

void TGo4WindowEditSlots::SetResultMode(Int_t mode)
{
TGo4Condition* workingcon=fxTGo4WindowEditStatus->GetCondition();
if(workingcon==0) return;
switch (mode)
   {
   case 0:
       workingcon->Enable();          //condition returns: result
       break;
   case 1:
       workingcon->Disable(kTRUE);   //condition returns: Always true
       break;
   case 2:
       workingcon->Disable(kFALSE );   //condition returns:  Always false
       break;
   default:
       workingcon->Enable();          //condition returns: result
       break;
   }// switch

}

void TGo4WindowEditSlots::SetInvertMode(Int_t mode)
{
TGo4Condition* workingcon=fxTGo4WindowEditStatus->GetCondition();
if(workingcon==0) return;
switch (mode)
   {
         case 0:
             workingcon->Invert(kFALSE); //invert condition false (regular)
             break;
         case 1:
             workingcon->Invert(kTRUE); //invert condition true (invert)
             break;
         default:
             workingcon->Invert(kFALSE); //invert condition false (regular)
             break;

   } // switch
}

Bool_t TGo4WindowEditSlots::IsVisible()
{
   return  fxTGo4WindowEditStatus->IsVisible();
}


void TGo4WindowEditSlots::SetVisible(Bool_t on)
{
TGo4Condition* workingcon=fxTGo4WindowEditStatus->GetCondition();
if(workingcon)
   workingcon->SetVisible(on);
}

Bool_t TGo4WindowEditSlots::IsHistogramLink()
{
TGo4Condition* workingcon=fxTGo4WindowEditStatus->GetCondition();
// histogramlink always refer to top level condition (e.g. whole array)
if(workingcon)
   return (workingcon->IsHistogramLink());
else
   return kFALSE;
}


void TGo4WindowEditSlots::SetHistogramLink(Bool_t on)
{
TGo4Condition* workingcon=fxTGo4WindowEditStatus->GetCondition();
// histogramlink only for top condition (whole array)
if(workingcon)
   {
      workingcon->SetHistogramLink(on);
      if(on && fxHisto)
         workingcon->SetHistogram(fxHisto->GetName());
   }
}



void TGo4WindowEditSlots::StatusChanged(TGo4Status *status)
{
   // TGo4LockGuard Global;
}



const Text_t* TGo4WindowEditSlots::GetHistogramName()
{
   if(fxHisto)
    return fxHisto->GetName();
   else
    return 0;
}

const Text_t* TGo4WindowEditSlots::GetLinkedHistogramName()
{
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny)
   return conny->GetLinkedHistogram();
else
   return 0;

}

Double_t TGo4WindowEditSlots::GetIntegral()
{
Double_t result=0;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny)
   result=conny->GetIntegral(fxHisto,"");
else
   result=0;
return result;
}

Double_t TGo4WindowEditSlots::GetMean(Int_t axis)
{
Double_t result=0;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny)
   result=conny->GetMean(fxHisto, axis);
else
   result=0;
return result;
}

Double_t TGo4WindowEditSlots::GetRMS(Int_t axis)
{
Double_t result=0;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny)
   result=conny->GetRMS(fxHisto, axis);
else
   result=0;
return result;
}

Double_t TGo4WindowEditSlots::GetXMax()
{
Double_t result=0;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny)
   result=conny->GetXMax(fxHisto);
else
   result=0;
return result;
}

Double_t TGo4WindowEditSlots::GetYMax()
{
Double_t result=0;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny)
   result=conny->GetYMax(fxHisto);
else
   result=0;
return result;
}

Double_t TGo4WindowEditSlots::GetCMax()
{
Double_t result=0;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny)
   result=conny->GetCMax(fxHisto);
else
   result=0;
return result;
}

void TGo4WindowEditSlots::SetLabelDraw(Bool_t on)
{
TGo4Condition* workingcon=fxTGo4WindowEditStatus->GetCondition();
if(workingcon)
   workingcon->SetLabelDraw(on);
}

void TGo4WindowEditSlots::SetLimitsDraw(Bool_t on)
{
TGo4Condition* workingcon=fxTGo4WindowEditStatus->GetCondition();
if(workingcon)
   workingcon->SetLimitsDraw(on);
}


void TGo4WindowEditSlots::SetIntDraw(Bool_t on)
{
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) conny->SetIntDraw(on);
}

void TGo4WindowEditSlots::SetXMeanDraw(Bool_t on)
{
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) conny->SetXMeanDraw(on);
}

void TGo4WindowEditSlots::SetXRMSDraw(Bool_t on)
{
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) conny->SetXRMSDraw(on);
}

void TGo4WindowEditSlots::SetYMeanDraw(Bool_t on)
{
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) conny->SetYMeanDraw(on);
}

void TGo4WindowEditSlots::SetYRMSDraw(Bool_t on)
{
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) conny->SetYRMSDraw(on);
}

void TGo4WindowEditSlots::SetXMaxDraw(Bool_t on)
{
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) conny->SetXMaxDraw(on);
}

void TGo4WindowEditSlots::SetYMaxDraw(Bool_t on)
{
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) conny->SetYMaxDraw(on);
}

void TGo4WindowEditSlots::SetCMaxDraw(Bool_t on)
{
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) conny->SetCMaxDraw(on);
}

Bool_t TGo4WindowEditSlots::IsLabelDraw()
{
Bool_t rev=kFALSE;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) rev=conny->IsLabelDraw();
return rev;
}

Bool_t TGo4WindowEditSlots::IsLimitsDraw()
{
Bool_t rev=kFALSE;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) rev=conny->IsLimitsDraw();
return rev;
}

Bool_t TGo4WindowEditSlots::IsIntDraw()
{
Bool_t rev=kFALSE;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) rev=conny->IsIntDraw();
return rev;
}

Bool_t TGo4WindowEditSlots::IsXMeanDraw()
{
Bool_t rev=kFALSE;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) rev=conny->IsXMeanDraw();
return rev;
}

Bool_t TGo4WindowEditSlots::IsXRMSDraw()
{
Bool_t rev=kFALSE;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) rev=conny->IsXRMSDraw();
return rev;
}

Bool_t TGo4WindowEditSlots::IsYMeanDraw()
{
Bool_t rev=kFALSE;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) rev=conny->IsYMeanDraw();
return rev;
}

Bool_t TGo4WindowEditSlots::IsYRMSDraw()
{
Bool_t rev=kFALSE;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) rev=conny->IsYRMSDraw();
return rev;
}

Bool_t TGo4WindowEditSlots::IsXMaxDraw()
{
Bool_t rev=kFALSE;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) rev=conny->IsXMaxDraw();
return rev;
}

Bool_t TGo4WindowEditSlots::IsYMaxDraw()
{
Bool_t rev=kFALSE;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) rev=conny->IsYMaxDraw();
return rev;
}

Bool_t TGo4WindowEditSlots::IsCMaxDraw()
{
Bool_t rev=kFALSE;
TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
if(conny) rev=conny->IsCMaxDraw();
return rev;
}


void TGo4WindowEditSlots::SetNewTCutG(Bool_t editmode, Bool_t cancel)
{
TPad* wpad=WorkingPad();
   if(wpad==0 || !fxTGo4WindowEditStatus->IsPolygon() ) return;
   TGo4LockGuard glob;
   TPad* savepad = (TPad*) gPad;
   wpad->cd();
   TGo4PreviewPanelSlots* wvslots=0;
   if(fxWorkView) wvslots=fxWorkView->GetSlots();
   if(editmode)
   {
      gROOT->SetEditorMode("CutG");
      if(wvslots) wvslots->SetMouseMode(kMouseConditionEditor);
      // set mousemode in fxWorkView
   }
   else
   {
    gROOT->SetEditorMode("");
    if(wvslots) wvslots->SetMouseMode(kMouseROOT);
    TObject *entry=0;
    TCutG *CG=0;
    TCutG* newcut=0;
    TList *ListOfPadPrimitives = wpad->GetListOfPrimitives();
    TIterator* Padlistiter = ListOfPadPrimitives->MakeIterator();
    while((entry= Padlistiter->Next()) !=0)
       {
         if(entry->InheritsFrom("TCutG"))
            {
               CG = dynamic_cast<TCutG *> (entry);
               //cout <<"Found a cutg "<<CG << endl;
               if(CG && CG->GetLineColor()==1)
                  {
                     // root always (?) sets color of new edited cut to black
                     // our old cuts are never black! ergo:
                     //cout <<"!!! Found new cutg "<<CG << endl;
                     newcut=CG;
                     break;
                  }
            }
       }
    delete Padlistiter;
    if (newcut)
       {
         if(!cancel)
         {
            TGo4Condition* conny=fxTGo4WindowEditStatus->GetCondition();
            if(conny)
            {
            TGo4Condition* aconny=conny->GetActiveCondition();
            TGo4PolyCond* pconny=dynamic_cast<TGo4PolyCond*>(aconny);
            if(pconny)
               {
                  pconny->UnDraw();
                  pconny->SetValues(newcut); // clone viewed cut internally
                  pconny->Draw();
               }
            delete newcut;
            }
         }
         else
         {
             delete newcut;
         }
      }
   else
      {
          // if deselected before cut was completed do not change old one
      }
      DrawConditions();
   }// if(editmode)
   savepad->cd();
}

TPad* TGo4WindowEditSlots::FindObjectSubpad(TObject* obj, TPad* parent)
{
TPad* rev=0;
if(parent)
{
 TObject* prim=0;
 TIter iter(parent->GetListOfPrimitives());
 while((prim=iter())!=0)
    {
       if(prim==obj)
          {
          rev=parent;
          break;
          }
       else if(prim->InheritsFrom("TPad"))
       {
          TPad* subpad=dynamic_cast<TPad*>(prim);
          rev=FindObjectSubpad(obj,subpad);
          if(rev) break; // found in subpad
       }
       else
       {
          rev=0;
       }
    }

}

return rev;
}

TGo4Condition* TGo4WindowEditSlots::GetWorkPadCondition(Int_t index)
{
TGo4Condition* con=0;
if(fxWorkView!=0 && WorkingPad(index)!=0)
   {
      TGo4PadOptions* popt=fxWorkView->GetPadOptions(WorkingPad(index));
      if(popt)
         con=popt->GetCondition();
   }
return con;
}

void TGo4WindowEditSlots::SetWorkPadCondition(TGo4Condition* con)
{
TPad* wpad=WorkingPad();
if(fxWorkView!=0 && wpad!=0)
   {
      TGo4PadOptions* popt=fxWorkView->GetPadOptions(wpad);
      if(popt)
         popt->SetCondition(con);
   }

}

void TGo4WindowEditSlots::SetCurrentPad(Int_t index)
{
   TGo4Condition* con=fxTGo4WindowEditStatus->GetCondition();
   if(con && fiCurrentPad!=index)
      SetWorkPadCondition(con);
         // store previous con in padoptions before changing pad
   ClearConditions(kTRUE); // clean up previous pad
   //ClearCursor(kTRUE);
   Int_t set=0;
   if(index<0)
      set=0;
   else if(index>=fiNumPads)
      set=fiNumPads-1;
   else
      set=index;
   fiCurrentPad=set;

   TGo4Condition* padcon=GetWorkPadCondition(fiCurrentPad);
   if(padcon)
         AddObject(padcon);
   SetHistogram();
}

TPad* TGo4WindowEditSlots::WorkingPad(Int_t index)
{
Int_t selected=0;
if(index<0)
   selected=fiCurrentPad;
else if (index>=fiNumPads)
   selected=fiNumPads-1;
else
   selected=index;

if(fxWorkView && fxPad[selected])
   {
      // assure that working pad was not removed by root methods:
      // e.g. ClearCanvas menu of viewpanel...
      TRefArray* padlist= fxWorkView->GetListOfPads();
      //TList* padlist= fxWorkView->GetListOfPads();
      if(padlist->FindObject(fxPad[selected]))
         {
            //cout <<"workingPad found"<<fxPad[selected]<<" for index:"<<selected << endl;; // ok, the pad is still there
         }
      else
         {
            //cout <<"workingPad resets for index:"<<selected<< endl;; // ok, the pad is still there
            fxPad[selected]=0; // reset pad pointer
         }
   }
return fxPad[selected];
}

void TGo4WindowEditSlots::AssignWorkViewPanel(TGo4PreviewPanel* view)
{
ClearConditions(kTRUE); // clean up previous pad
fxTGo4WindowEditStatus->SetCondition(0); // remove previous condition
fxPad.clear();
fiNumPads=0;
fiCurrentPad=0;
if(view)
   fxWorkView=view; // use given viewpanel
else
   fxWorkView=fxView; // use current viewpanel

if(fxWorkView)
   {
      TRefArray* padlist=fxWorkView->GetListOfPads();
      //TList* padlist=fxWorkView->GetListOfPads();
      if(padlist)
         {
             TIterator* piter=padlist->MakeIterator();
             TObject* ob=0;
             TGo4PadOptions* popt=0;
             while((ob=piter->Next())!=0)
              {
                  TPad* pad=dynamic_cast<TPad*>(ob);
                  if(pad)
                     {
                         popt=fxWorkView->GetPadOptions(pad);
                         TGo4Condition* con=0;
                         if(popt)
                            con=popt->GetCondition();
                         if(con)
                            {
                             // only take pad reference if there is condition
                             fxPad.push_back(pad);
                             fiNumPads++;
                            }
                     }//if(pad)
              }//while
             delete piter;
         } // if(padlist)
   }//if(fxWorkView)
if(fiNumPads==0)
   {
      // no pad with condition found, we make dummy entry:
      fxPad.push_back(0);
      fiNumPads=1;
      AddObject(0);
   }
}






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

---