PadManager.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-2006 by Olivier Stezowski & Christian Finck        *
 *   stezow(AT)ipnl.in2p3.fr, cfinck(AT)ires.in2p3.fr                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef Gw_PadManager
#define Gw_PadManager

#include <list>

#include "Rtypes.h"
#include "GwLogMessage.h"

#include "TVirtualPad.h"
#include "TList.h"
#include "TObjArray.h"
#include "TH1.h"
#include "TFolder.h"
#include "TRegexp.h"

class TF1;
class TGraph;
class TPolyLine;

namespace Gw {

class PadManager 
{  
public:

   enum EActionMode {kGPad, kAllPad, kNotGPad, kCanvas};
   static EActionMode gActionMode;
   
protected:
        mutable LogMessage fLog;    // log message
        
public:
        PadManager() ;
        virtual ~PadManager() ;
        
        static TH1 * GetHisto(TVirtualPad *pad = 0x0 , Option_t *op = "");
    static TGraph * GetGraph(TVirtualPad *pad = 0x0, Option_t *op = "" );


        // static Bool_t IsActionOn(TVirtualPad *pad, EActionMode);
        // static EActionMode WhatActionOn(TVirtualPad *pad);
        // static EActionMode SetActionOn(TVirtualPad *pad, EActionMode amode);
        
        template <typename Data_T> static void Collect(TList &list, TVirtualPad *pad = 0x0)
        {
                // to get the pad on which the creator is added
                TVirtualPad *locpad = 0x0;
                if ( pad == 0x0 ) 
                        if ( TVirtualPad::Pad() == 0x0 )
                                return ;
                        else 
                                locpad = TVirtualPad::Pad();
                else 
                        locpad = pad;
                
                TObject* obj = 0x0; TIter next(locpad->GetListOfPrimitives());
                while ( (obj = next()) ) { // 
                                if ( obj->InheritsFrom(Data_T::Class_Name()) ) 
                                        list.Add(obj);
                }               
        }
        template <typename Data_T> static void Collect(std::vector<Data_T *> &array, TVirtualPad *pad = 0x0)
        {
                // to get the pad on which the creator is added
                TVirtualPad *locpad = 0x0;
                if ( pad == 0x0 ) 
                        if ( TVirtualPad::Pad() == 0x0 )
                                return ;
                        else 
                                locpad = TVirtualPad::Pad();
                        else 
                                locpad = pad;
                
                TObject* obj = 0x0; TIter next(locpad->GetListOfPrimitives());
                while ( (obj = next()) ) { // 
                        if ( obj->InheritsFrom(Data_T::Class_Name()) ) 
                                array.push_back((Data_T *)obj);
                }               
        }
    template <typename Data_T> static void Collect(TList *collected, TFolder *from,
                                                   const char *inc = "*", const char *exc = "",
                                                   const char *inc_class = "TFH1*", const char *exc_class = "-", Int_t depth = kMaxInt)
    {
        TString include(inc), exclude(exc), include_class(inc_class), exclude_class(exc_class), tmp_obj = "", tmp_token = "", tmp_class = "";
        Bool_t wildcard;
        TIter next(from->GetListOfFolders()); TObject *an_obj = 0x0, *a_token = 0x0;
        
        // collect objects from the current folder. if a folder is found, recursive call of this
        while ( (an_obj=next()) ) {
            
            tmp_obj = an_obj->GetName(); tmp_class = an_obj->ClassName();
           
            // tokenize include and exclude filter
            TObjArray *all_token_include = include.Tokenize(" "),
                        *all_token_exclude = exclude.Tokenize(" "), *all_token_include_class = include_class.Tokenize(" "), *all_token_exclude_class = exclude_class.Tokenize(" ");
            Bool_t add_it = false, exclude_it = false, add_it_class = false, exclude_it_class = false;
            
            // check include
            TIter token_include(all_token_include);
            while ( (a_token = token_include()) ) {
                
                tmp_token = a_token->GetName();
                
                // pattern expression
                wildcard = false;
                if ( tmp_token.Contains("*") )
                    wildcard = true;
                TRegexp kept(tmp_token,wildcard);
                
                if ( tmp_obj.Contains(kept) && an_obj->InheritsFrom(Data_T::Class_Name()) ) {
                    add_it = true;
                    break;
                }
            }
            // check exclude
            TIter token_exclude(all_token_exclude);
            while ( (a_token = token_exclude()) ) {
                
                tmp_token = a_token->GetName();
                
                // pattern expression
                wildcard = false;
                if ( tmp_token.Contains("*") )
                    wildcard = true;
                TRegexp nokept(tmp_token,wildcard);
                
                if ( tmp_obj.Contains(nokept) && an_obj->InheritsFrom(Data_T::Class_Name()) ) {
                    exclude_it = true;
                    break;
                }
            }
            // check include class name
            TIter token_include_class(all_token_include_class);
            while ( (a_token = token_include_class()) ) {
                
                tmp_token = a_token->GetName();
                
                // pattern expression
                wildcard = false;
                if ( tmp_token.Contains("*") )
                    wildcard = true;
                TRegexp kept(tmp_token,wildcard);
                
                if ( tmp_class.Contains(kept) ) {
                    add_it_class = true;
                    break;
                }
            }
            // check exclude
            TIter token_exclude_class(all_token_exclude_class);
            while ( (a_token = token_exclude_class()) ) {
                
                tmp_token = a_token->GetName();
                
                // pattern expression
                wildcard = false;
                if ( tmp_token.Contains("*") )
                    wildcard = true;
                TRegexp nokept(tmp_token,wildcard);
                
                if ( tmp_class.Contains(nokept) ) {
                    exclude_it = true;
                    break;
                }
            }
            
            // it is the charge of the user to delete Tokenized collection
            if ( all_token_include ) {
                delete all_token_include; all_token_include = 0x0;
            }
            if ( all_token_exclude ) {
                delete all_token_exclude; all_token_exclude = 0x0;
            }
            if ( all_token_include_class ) {
                delete all_token_include_class; all_token_include_class = 0x0;
            }
            if ( all_token_exclude_class ) {
                delete all_token_exclude_class; all_token_exclude_class = 0x0;
            }
            
            //printf("%s %s with filter %s , %s , %s , %s \n",tmp_obj.Data(),tmp_class.Data(),inc,exc,inc_class,exc_class);
            // now if it passes the filters, add it
            if ( add_it && !exclude_it && add_it_class && !exclude_it_class && !an_obj->InheritsFrom("TFolder") ) {
                collected->Add(an_obj);
            }
            // and check recursively if it is required
            if ( an_obj->InheritsFrom("TFolder") && depth > 0 ) { // recursive call through the tree
                Collect<Data_T>(collected,(TFolder *)an_obj,inc,exc,inc_class,exc_class,depth--);
                continue;
            }
        }
    }
        
        static TPolyLine *ShowDiff(const TH1 *h, const TF1 *f, Double_t xmin, Double_t xmax);
    

        
        ClassDef(PadManager, 0); // to manage ROOT pads and canvases   
};

} // end namespace

#endif