---

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

#include <iostream.h>

#include "TDataMember.h"
#include "TBaseClass.h"
#include "TFile.h"
#include "TObjString.h"
#include "TClass.h"

#include "Go4LockGuard/TGo4LockGuard.h"
#include "Go4StatusBase/TGo4Parameter.h"
#include "Go4Fit/TGo4Fitter.h"


TGo4ParaEditStatus::TGo4ParaEditStatus(const char* name, const char* title) :
     TGo4Status(name, title), fxPara(0), fxParaClass(0) ,fiMemNum(0),
     fxDataFloat(0),fxDataDouble(0), fxDataInt(0),fxDataUInt(0), fxDataShort(0),
     fxDataChar(0), fxDataLong(0), fxDataBool(0), fxDataUShort(0),
     fxDataUChar(0), fxDataULong(0), fxDataString(0),fxFitPointer(0), fiDatatypeSize(0),fxNextParaClass(0)
{
   TGo4LockGuard Global;
   BuildParameterList();
   fxPara=new TGo4Parameter("defaultname");
   UpdateMemberLists();
}

TGo4ParaEditStatus::~TGo4ParaEditStatus()
{
   TGo4LockGuard Global;
   delete fxPara;
   delete fxNextParaClass;
}

void TGo4ParaEditStatus::UpdateParameter(TGo4Parameter* source)
{
   if(source==0) return;
     {
          TGo4LockGuard Global;
          delete fxPara;
          fxPara=dynamic_cast<TGo4Parameter*> (source->Clone());
     } // TGo4LockGuard
   UpdateMemberLists();
}

void TGo4ParaEditStatus::UpdateLastFitter(TGo4Fitter* source)
{
if(source==0) return;
TGo4LockGuard Global;
if(fxFitPointer)
 {
    if(*fxFitPointer) delete *fxFitPointer;
    *fxFitPointer=dynamic_cast<TGo4Fitter*> (source->Clone());
 }
}


void TGo4ParaEditStatus::SetParaName(const Text_t* name)
{
 if(name==0) return;
 if(fxPara)
   {
       fxPara->SetName(name);
   }

}

void TGo4ParaEditStatus::SetParaClass(const Text_t* name)
{
 if(name==0) return;
 TGo4LockGuard Global;
 TClass* nclass=gROOT->GetClass(name);
 if(nclass)
    {
       snprintf(fcTextBuffer,256,"%s",fxPara->GetName());
       delete fxPara;
       fxPara= (TGo4Parameter*) nclass->New();
       fxPara->SetName(fcTextBuffer); // preserve old parameter name
       UpdateMemberLists();
    }
 else
   {
      cout <<"Could not set parameter to class "<< name << endl;
   }

}


const Text_t* TGo4ParaEditStatus::GetParaName()
{
   if(fxPara==0) return 0;
   return fxPara->GetName();
}

const Text_t* TGo4ParaEditStatus::GetParaClass()
{
   if(fxParaClass==0) return 0;
   return fxParaClass->GetName();
}

const Text_t* TGo4ParaEditStatus::GetParaMember(Int_t i)
{
   if ((i>fiMemNum) || (i<0)) return 0;
   TGo4LockGuard Global;
   const Text_t* rev;
   TObjString* memname=dynamic_cast<TObjString*>(fxNames[i]);
   if(memname)
   {
      rev=memname->GetName();
   }
   else
   {
      rev=0;
   }
   return rev;
}

const Text_t* TGo4ParaEditStatus::GetParaMemType(Int_t i)
{
   if ((i>fiMemNum) || (i<0)) return 0;
   TGo4LockGuard Global;
   const Text_t* rev;
   TObjString* memtype=dynamic_cast<TObjString*>(fxTypes[i]);
   if(memtype)
   {
      rev=memtype->GetName();
   }
   else
   {
      rev=0;
   }
   return rev;
}

const Text_t* TGo4ParaEditStatus::GetParaMemVal(Int_t i)
{
   if ((i>fiMemNum) || (i<0)) return 0;
   TGo4LockGuard Global;
   Long_t address=fxAddress[i];
   const Text_t* memtype=GetParaMemType(i);
   const Text_t* value=ValueString(memtype,address);
   //cout <<"GetParaMemVal["<<i<<"]="<<address <<" , val="<<value<< endl;
   return value;
}

const Text_t* TGo4ParaEditStatus::GetParaMemComment(Int_t i) {
   if ((i>fiMemNum) || (i<0)) return 0;
   TGo4LockGuard Global;
   const Text_t* rev;
   TObjString* memtitle=dynamic_cast<TObjString*>(fxComments[i]);
   if(memtitle)
   {
      rev = memtitle->GetName();
   }
   else
   {
      rev=0;
   }
   return rev;
}

void TGo4ParaEditStatus::SetParaMemVal(Int_t i, const Text_t* val)
{
   if ((i>fiMemNum) || (i<0)) return;
   TGo4LockGuard Global;
   Long_t address=fxAddress[i];
   const Text_t* memtype=GetParaMemType(i);
   SetValue(memtype,val,address);
}

const Int_t TGo4ParaEditStatus::GetParaMemArrIndex(Int_t i)
{
   if ((i>fiMemNum) || (i<0)) return 0;
   TGo4LockGuard Global;
   Int_t index=fxArrayIndex[i];
   return index;
}

const Int_t TGo4ParaEditStatus::GetParaMemArrIndey(Int_t i)
{
   if ((i>fiMemNum) || (i<0)) return 0;
   TGo4LockGuard Global;
   Int_t index=fxArrayIndey[i];
   return index;
}


Bool_t TGo4ParaEditStatus::IsParaMemVisible(Int_t i)
{
   if ((i>fiMemNum) || (i<0)) return kFALSE;
   TGo4LockGuard Global;
   Bool_t visible=fbMemberVisible[i];
   return visible;
}

void TGo4ParaEditStatus::SetParaMemVisible(Int_t i, Bool_t on)
{
   if ((i>fiMemNum) || (i<0)) return;
   TGo4LockGuard Global;
   fbMemberVisible[i]=on;
}

Long_t TGo4ParaEditStatus::GetMemberAddress(Int_t i)
{
   if ((i>fiMemNum) || (i<0)) return 0;
   TGo4LockGuard Global;
   return fxAddress[i];
}

void TGo4ParaEditStatus::UpdateMemberLists()
{
if(fxPara==0) return;
TGo4LockGuard Global;
fxParaClass=fxPara->IsA();
fiMemNum=0;
// empty objarrays here before filling again!
fxAddress.clear();
fxArrayIndex.clear();
fxArrayIndey.clear();
fbMemberVisible.clear();
fxNames.Delete();
fxTypes.Delete();
fxVals.Delete();
fxComments.Delete();
// this will shrink TObjArrays to minimum size
fxNames.Compress();
fxNames.Expand(fxNames.GetLast()+1);
fxTypes.Compress();
fxTypes.Expand(fxTypes.GetLast()+1);
fxVals.Compress();
fxVals.Expand(fxVals.GetLast()+1);
fxComments.Compress();
fxComments.Expand(fxComments.GetLast()+1);

EvalMembers(fxParaClass,0);
}


void TGo4ParaEditStatus::EvalMembers(TClass* cl, Long_t baseoffset)
{
if(cl)
   {
      TGo4LockGuard glob;
      // first process datamembers of this class itself:
      TList* members =cl->GetListOfDataMembers();
      TIterator* memiter=members->MakeIterator();
      TObject* nob=0;
      Bool_t isvisible=kTRUE;
      while((nob=memiter->Next()) !=0)
      {
         TDataMember* mem=dynamic_cast<TDataMember*>(nob);
         const Text_t*  memtypename=mem->GetFullTypeName();
         if(!strcmp(memtypename,"TClass*")) continue; // do not edit IsA info
         // evaluate array:
         Long_t arrayoffset=0;
         Int_t arrayindex=0;
         Int_t arrayindey=0;
         Int_t arraydim=mem->GetArrayDim();
         Int_t maxindex;
         Int_t maxindey;
         switch(arraydim)
         {
            case 1:
              SetCast(memtypename,0); // find out size of one array element
              maxindex=mem->GetMaxIndex(0);
              maxindey=1;
              break;

            case 2:
              SetCast(memtypename,0); // find out size of one array element
              maxindex=mem->GetMaxIndex(0);
              maxindey=mem->GetMaxIndex(1);
//              cout <<"\nmember type:"<<mem->GetFullTypeName() << endl;
//              cout <<"maxix:"<<maxindex << endl;
//              cout <<"maxiy="<<maxindey << endl;
//              cout << "array dimension="<<arraydim <<endl;
//              cout <<"arraydelta of "<<memtypename<<"="<<fiDatatypeSize << endl;
              break;

            default:
              maxindex=1;
              maxindey=1;
              break;
         } // switch()

         for(Int_t ix=0;ix<maxindex;++ix)
            {
            for(Int_t iy=0;iy<maxindey;++iy)
               {
               arrayoffset=(ix*maxindey + iy) * fiDatatypeSize;
               Long_t offset=baseoffset + mem->GetOffset()+arrayoffset;
               Long_t address=(Long_t) fxPara + offset;
               TObjString* memtype=new TObjString(memtypename);
               TObjString* memval=new TObjString(ValueString(memtypename, address));
               TObjString* memname= new TObjString(mem->GetName());
               TObjString* memtitle = new TObjString(mem->GetTitle());
               switch(arraydim)
                  {
                     case 1:
                        snprintf(fcTextBuffer,256,"%s[%d]",memname->GetName(),ix);
                        memname->SetString(fcTextBuffer);
                        arrayindex=ix;
                        arrayindey=-1;
                        break;
                     case 2:
                        snprintf(fcTextBuffer,256,"%s[%d][%d]",memname->GetName(),ix,iy);
                        memname->SetString(fcTextBuffer);
                        arrayindex=ix;
                        arrayindey=iy;
                        break;
                     default:
                        // no array
                        arrayindex=-1;
                        arrayindey=-1;
                        break;
                  } // switch
               if(ix==0 && iy==0)
                  isvisible=kTRUE; // default: only show first
               else
                  isvisible=kFALSE;
               fxNames.AddAtAndExpand(memname,fiMemNum);
               fxTypes.AddAtAndExpand(memtype,fiMemNum);
               fxVals.AddAtAndExpand(memval,fiMemNum);
               fxComments.AddAtAndExpand(memtitle,fiMemNum);
               fxAddress.push_back(address);
               fxArrayIndex.push_back(arrayindex);
               fxArrayIndey.push_back(arrayindey);
               fbMemberVisible.push_back(isvisible);
               //cout <<"EvalMembers found address:"<<address<<" of "<<fiMemNum << endl;
               fiMemNum++;
               }//for(iy=0;iy<maxindex;++iy)
            } //for(ix=0;ix<maxindex;++ix)
      }// while(nob=memiter->Next() !=0)
      delete memiter;

      // now look for possible base class members:
     TList* baselist=cl->GetListOfBases();
     TIterator* baseiter=baselist->MakeIterator();
     TObject* bob=0;
     while((bob=baseiter->Next()) !=0)
        {
           TBaseClass* baseclass=dynamic_cast<TBaseClass*>(bob);
           if(baseclass)
              {
                  // we have a baseclass
                  TClass* bclass=baseclass->GetClassPointer();
                  if(bclass==0) continue;
                  if(!strcmp(bclass->GetName(),"TGo4Parameter")) continue; // suppress bases above
                  if(!strcmp(bclass->GetName(),"TNamed")) continue; // for bare TGo4Parameter
                  Int_t bdelta=baseclass->GetDelta();
                  EvalMembers(bclass, baseoffset+bdelta);
                     // recursively find out members of all baseclasses
              }
        } // while((bob=baseiter->Next()) !=0)
      delete baseiter;
   } // if(cl)
else
   {
      // never come here, since the parameter is only
      // on gui side if root already had cloned it! But anyway...
      cout <<"Parameter class not known to ROOT!!!" << endl;
      cout <<"Please load library first !!!" << endl;
   }
}

const Text_t* TGo4ParaEditStatus::ValueString(const Text_t* memtype,
                                                Long_t address)
{
   TGo4LockGuard glob;
   SetCast(memtype,address);
   if(fxDataFloat) snprintf(fcTextBuffer,256,"%f",*fxDataFloat);
   else if(fxDataDouble) snprintf(fcTextBuffer,256,"%f",*fxDataDouble);
   else if(fxDataInt) snprintf(fcTextBuffer,256,"%d", *fxDataInt);
   else if(fxDataUInt) snprintf(fcTextBuffer,256,"%u", *fxDataUInt);
   else if(fxDataShort) snprintf(fcTextBuffer,256,"%hd", *fxDataShort);
   else if(fxDataChar) snprintf(fcTextBuffer,256,"%hhd", *fxDataChar);
   else if(fxDataLong) snprintf(fcTextBuffer,256,"%ld", *fxDataLong);
   else if(fxDataBool) snprintf(fcTextBuffer,256,"%d", *fxDataBool);
   else if(fxDataUShort)snprintf(fcTextBuffer,256,"%hu", *fxDataUShort);
   else if(fxDataUChar) snprintf(fcTextBuffer,256,"%hhu", *fxDataUChar);
   else if(fxDataULong) snprintf(fcTextBuffer,256,"%lu", *fxDataULong);
   else if(fxDataString) snprintf(fcTextBuffer,256,"%s", (*fxDataString).Data());
   else if(memtype && !strcmp(memtype,"TGo4Fitter*")) snprintf(fcTextBuffer,256,"RMB Edit");
   else snprintf(fcTextBuffer,256,"Unknown type %s",memtype);
   return fcTextBuffer;
}

void TGo4ParaEditStatus::SetCast(const Text_t* memtype,
                                  Long_t address)
{
   if(memtype==0) return;
   fxDataFloat=0;
   fxDataDouble=0;
   fxDataInt=0;
   fxDataShort=0;
   fxDataChar=0;
   fxDataLong=0;
   fxDataBool=0;
   fxDataUInt=0;
   fxDataUShort=0;
   fxDataUChar=0;
   fxDataULong=0;
   fxDataString=0;
   fiDatatypeSize=0;

   if(!strcmp(memtype,"Float_t"))
     {

        fxDataFloat=(Float_t*) (address);
        fiDatatypeSize=sizeof(Float_t);
        //cout<<"SSSSSSetCast  inits Float_t="<< *fxDataFloat<< endl;
     }
   else if (!strcmp(memtype,"Double_t"))
    {
         //cout<<"SSSSSSetCast inits Double_t"<< endl;
         fxDataDouble=(Double_t*) (address);
         fiDatatypeSize=sizeof(Double_t);
    }
  else if (!strcmp(memtype,"Int_t"))
    {
         //cout<<"SSSSSSetCast inits Int_t"<< endl;
         fxDataInt=(Int_t*) (address);
         fiDatatypeSize=sizeof(Int_t);
    }
  else if (!strcmp(memtype,"Short_t"))
    {
         //cout<<"SSSSSSetCast inits Short_t"<< endl;
         fxDataShort=(Short_t*) (address);
         fiDatatypeSize=sizeof(Short_t);
    }
  else if (!strcmp(memtype,"Char_t"))
    {
         //cout<<"SSSSSSetCast inits Char_t"<< endl;
         fxDataChar=(Char_t*) (address);
         fiDatatypeSize=sizeof(Char_t);
    }
  else if (!strcmp(memtype,"Long_t"))
    {
         //cout<<"SSSSSSetCast inits Long_t"<< endl;
         fxDataLong=(Long_t*) (address);
         fiDatatypeSize=sizeof(Long_t);
    }
  else if (!strcmp(memtype,"Bool_t"))
    {
         //cout<<"SSSSSSetCast inits Bool_t"<< endl;
         fxDataBool=(Bool_t*) (address);
         fiDatatypeSize=sizeof(Bool_t);
    }
  else if (!strcmp(memtype,"UInt_t"))
    {
         //cout<<"SSSSSSetCast inits UInt_t"<< endl;
         fxDataUInt=(UInt_t*) (address);
         fiDatatypeSize=sizeof(UInt_t);
    }
  else if (!strcmp(memtype,"UShort_t"))
    {
         //cout<<"SSSSSSetCast inits UShort_t"<< endl;
         fxDataUShort=(UShort_t*) (address);
         fiDatatypeSize=sizeof(UShort_t);
    }
  else if (!strcmp(memtype,"UChar_t"))
    {
         //cout<<"SSSSSSetCast inits UChar_t"<< endl;
         fxDataUChar=(UChar_t*) (address);
         fiDatatypeSize=sizeof(UChar_t);
    }
  else if (!strcmp(memtype,"ULong_t"))
    {
         //cout<<"SSSSSSetCast inits ULong_t"<< endl;
         fxDataULong=(ULong_t*) (address);
         fiDatatypeSize=sizeof(ULong_t);
    }
  else if (!strcmp(memtype,"TString"))
    {
         //cout<<"SSSSSSetCast inits TString"<< endl;
         fxDataString=(TString*) (address);
         fiDatatypeSize=sizeof(TString);
    }
  else if (!strcmp(memtype,"TGo4Fitter*"))
    {
         //cout<<"SSSSSSetCast inits TGo4Fitter*"<< endl;
         fiDatatypeSize=sizeof(TGo4Fitter*);
    }
  else
     {
         //cout<<"SSSSSSetCast inits Int_t as dummy for " <<memtype<< endl;
         //fxDataInt=(Int_t*) (address);
         // no dummy!
     }


}

void TGo4ParaEditStatus::SetValue(const Text_t* memtype,
                                 const Text_t* expression,
                                 Long_t address)
{
   TGo4LockGuard glob;
   SetCast(memtype,address);
   if(fxDataFloat) *fxDataFloat=atof(expression);
   else if(fxDataDouble) *fxDataDouble=atof(expression);
   else if(fxDataInt) *fxDataInt=atoi(expression);
   else if(fxDataUInt) *fxDataUInt=atoi(expression);
   else if(fxDataShort) *fxDataShort=(Short_t) atoi(expression);
   else if(fxDataChar) *fxDataChar=(Char_t) atoi(expression);
   else if(fxDataLong) *fxDataLong=atoi(expression);
   else if(fxDataBool) *fxDataBool= (Bool_t) atoi(expression);
   else if(fxDataUShort)*fxDataUShort=(UShort_t) atoi(expression);
   else if(fxDataUChar) *fxDataUChar=(UChar_t) atoi(expression);
   else if(fxDataULong) *fxDataULong=atoi(expression);
   else if(fxDataString) *fxDataString=expression;
   else ; //cout<< "Unknown type "<<memtype<<endl;
}

Bool_t TGo4ParaEditStatus::LoadParameter(
   const Text_t* filename, const Text_t* parname)
{
//cout << "loading parameter from "<<filename<<endl;
TGo4LockGuard Global;
// open file
TFile parafile(filename,"READ");
if(!parafile.IsOpen()) return kFALSE;
// get object of parname
const Text_t* obname;
if(parname)
   {
      obname=parname;
   }
else
   {
      if(fxPara==0) return kFALSE;
      obname=fxPara->GetName();
   }
TObject* ob=parafile.Get(obname);
// dont check for correct type, we overwrite current para!
if(ob && ob->InheritsFrom("TGo4Parameter"))
      {
      //cout <<"Load object of class "<<ob->IsA()->GetName() << endl;
      UpdateParameter(dynamic_cast<TGo4Parameter*>(ob));
      return kTRUE;
   }
else
   {
      //cout <<"Did not find object "<<obname<<" in file "<<filename << endl;
      return kFALSE;
   }


}


void TGo4ParaEditStatus::BuildParameterList()
{
   TGo4LockGuard Global;
   fxParaClassList.Clear("nodelete"); // classes belong to gROOT
   TSeqCollection* allclasses=gROOT->GetListOfClasses();
   TClass* cl=0;
   TIterator* cliter=allclasses->MakeIterator();
   while((cl=dynamic_cast<TClass*>(cliter->Next())) !=0)
   {
      //cout <<"scanned rootclass "<<cl->GetName() << endl;
      if(cl->InheritsFrom("TGo4Parameter"))
         {
            fxParaClassList.AddLast(cl);
         }
   }
   delete cliter;
   delete fxNextParaClass;
   fxNextParaClass=fxParaClassList.MakeIterator();
}


void TGo4ParaEditStatus::ResetParameterList()
{
    TGo4LockGuard Global;
    if(fxNextParaClass)
    {
       fxNextParaClass->Reset();
       //cout <<"iterator reset." << endl;
    }
}

const Text_t* TGo4ParaEditStatus::NextParameterClass()
{
 TGo4LockGuard Global;
 TClass* nextclass=dynamic_cast<TClass*>(fxNextParaClass->Next());
 if(nextclass)
 {
    //cout <<"found parameter class "<<nextclass->GetName() << endl;
    return nextclass->GetName();
 }
 else
    return 0;
}










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

---