EventDisplayBaseCint.cc

Go to the documentation of this file.

// Do NOT change. Changes will be lost next time file is generated

#define R__DICTIONARY_FILENAME dIUsersdImacdevdIworkspacedIbuildmInulitemImatrixdIBUILDTYPEdIdebugdIQUALdIs70mIc2dIlabel1dIswarmdIlabel2dIOSXmI10dO13dIbuilddInutoolsdIv2_24_08dIbuildmIDarwin64bitpL17mIc2mIdebugdInutoolsdIEventDisplayBasedIEventDisplayBaseCint

/*******************************************************************/
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#define G__DICTIONARY
#include "RConfig.h"
#include "TClass.h"
#include "TDictAttributeMap.h"
#include "TInterpreter.h"
#include "TROOT.h"
#include "TBuffer.h"
#include "TMemberInspector.h"
#include "TInterpreter.h"
#include "TVirtualMutex.h"
#include "TError.h"

#ifndef G__ROOT
#define G__ROOT
#endif

#include "RtypesImp.h"
#include "TIsAProxy.h"
#include "TFileMergeInfo.h"
#include <algorithm>
#include "TCollectionProxyInfo.h"
/*******************************************************************/

#include "TDataMember.h"

// Since CINT ignores the std namespace, we need to do so in this file.
namespace std {} using namespace std;

// Header files passed as explicit arguments
#include "nutools/EventDisplayBase/evdb.h"
#include "nutools/EventDisplayBase/WindowMenu.h"
#include "nutools/EventDisplayBase/View3D.h"
#include "nutools/EventDisplayBase/View2D.h"
#include "nutools/EventDisplayBase/ServiceTable.h"
#include "nutools/EventDisplayBase/ScanWindow.h"
#include "nutools/EventDisplayBase/RootEnv.h"
#include "nutools/EventDisplayBase/Reconfigurable.h"
#include "nutools/EventDisplayBase/Printable.h"
#include "nutools/EventDisplayBase/PrintDialog.h"
#include "nutools/EventDisplayBase/ParameterSetEditDialog.h"
#include "nutools/EventDisplayBase/ParameterSetEdit.h"
#include "nutools/EventDisplayBase/ObjListCanvas.h"
#include "nutools/EventDisplayBase/NavState.h"
#include "nutools/EventDisplayBase/MenuBar.h"
#include "nutools/EventDisplayBase/ListWindow.h"
#include "nutools/EventDisplayBase/JobMenu.h"
#include "nutools/EventDisplayBase/HelpMenu.h"
#include "nutools/EventDisplayBase/FileMenu.h"
#include "nutools/EventDisplayBase/EventHolder.h"
#include "nutools/EventDisplayBase/EditMenu.h"
#include "nutools/EventDisplayBase/DisplayWindow.h"
#include "nutools/EventDisplayBase/ColorScale.h"
#include "nutools/EventDisplayBase/Canvas.h"
#include "nutools/EventDisplayBase/ButtonBar.h"

// Header files passed via #pragma extra_include

namespace evdb {
   namespace ROOT {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static TClass *evdb_Dictionary();

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("evdb", 0 /*version*/, "nutools/EventDisplayBase/evdb.h", 16,
                     ::ROOT::Internal::DefineBehavior((void*)0,(void*)0),
                     &evdb_Dictionary, 0);
         return &instance;
      }
      // Insure that the inline function is _not_ optimized away by the compiler
      ::ROOT::TGenericClassInfo *(*_R__UNIQUE_DICT_(InitFunctionKeeper))() = &GenerateInitInstance;  
      // Static variable to force the class initialization
      static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_DICT_(Init));

      // Dictionary for non-ClassDef classes
      static TClass *evdb_Dictionary() {
         return GenerateInitInstance()->GetClass();
      }

   }
}

namespace ROOT {
   static TClass *evdbcLcLWindowMenu_Dictionary();
   static void evdbcLcLWindowMenu_TClassManip(TClass*);
   static void delete_evdbcLcLWindowMenu(void *p);
   static void deleteArray_evdbcLcLWindowMenu(void *p);
   static void destruct_evdbcLcLWindowMenu(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evdb::WindowMenu*)
   {
      ::evdb::WindowMenu *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evdb::WindowMenu));
      static ::ROOT::TGenericClassInfo 
         instance("evdb::WindowMenu", "nutools/EventDisplayBase/WindowMenu.h", 19,
                  typeid(::evdb::WindowMenu), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdbcLcLWindowMenu_Dictionary, isa_proxy, 1,
                  sizeof(::evdb::WindowMenu) );
      instance.SetDelete(&delete_evdbcLcLWindowMenu);
      instance.SetDeleteArray(&deleteArray_evdbcLcLWindowMenu);
      instance.SetDestructor(&destruct_evdbcLcLWindowMenu);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evdb::WindowMenu*)
   {
      return GenerateInitInstanceLocal((::evdb::WindowMenu*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::evdb::WindowMenu*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdbcLcLWindowMenu_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::evdb::WindowMenu*)0x0)->GetClass();
      evdbcLcLWindowMenu_TClassManip(theClass);
   return theClass;
   }

   static void evdbcLcLWindowMenu_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *evdbcLcLPrintable_Dictionary();
   static void evdbcLcLPrintable_TClassManip(TClass*);
   static void delete_evdbcLcLPrintable(void *p);
   static void deleteArray_evdbcLcLPrintable(void *p);
   static void destruct_evdbcLcLPrintable(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evdb::Printable*)
   {
      ::evdb::Printable *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evdb::Printable));
      static ::ROOT::TGenericClassInfo 
         instance("evdb::Printable", "nutools/EventDisplayBase/Printable.h", 15,
                  typeid(::evdb::Printable), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdbcLcLPrintable_Dictionary, isa_proxy, 1,
                  sizeof(::evdb::Printable) );
      instance.SetDelete(&delete_evdbcLcLPrintable);
      instance.SetDeleteArray(&deleteArray_evdbcLcLPrintable);
      instance.SetDestructor(&destruct_evdbcLcLPrintable);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evdb::Printable*)
   {
      return GenerateInitInstanceLocal((::evdb::Printable*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::evdb::Printable*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdbcLcLPrintable_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::evdb::Printable*)0x0)->GetClass();
      evdbcLcLPrintable_TClassManip(theClass);
   return theClass;
   }

   static void evdbcLcLPrintable_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *evdbcLcLCanvas_Dictionary();
   static void evdbcLcLCanvas_TClassManip(TClass*);
   static void delete_evdbcLcLCanvas(void *p);
   static void deleteArray_evdbcLcLCanvas(void *p);
   static void destruct_evdbcLcLCanvas(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evdb::Canvas*)
   {
      ::evdb::Canvas *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evdb::Canvas));
      static ::ROOT::TGenericClassInfo 
         instance("evdb::Canvas", "nutools/EventDisplayBase/Canvas.h", 22,
                  typeid(::evdb::Canvas), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdbcLcLCanvas_Dictionary, isa_proxy, 1,
                  sizeof(::evdb::Canvas) );
      instance.SetDelete(&delete_evdbcLcLCanvas);
      instance.SetDeleteArray(&deleteArray_evdbcLcLCanvas);
      instance.SetDestructor(&destruct_evdbcLcLCanvas);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evdb::Canvas*)
   {
      return GenerateInitInstanceLocal((::evdb::Canvas*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::evdb::Canvas*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdbcLcLCanvas_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::evdb::Canvas*)0x0)->GetClass();
      evdbcLcLCanvas_TClassManip(theClass);
   return theClass;
   }

   static void evdbcLcLCanvas_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *evdbcLcLScanFrame_Dictionary();
   static void evdbcLcLScanFrame_TClassManip(TClass*);
   static void delete_evdbcLcLScanFrame(void *p);
   static void deleteArray_evdbcLcLScanFrame(void *p);
   static void destruct_evdbcLcLScanFrame(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evdb::ScanFrame*)
   {
      ::evdb::ScanFrame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evdb::ScanFrame));
      static ::ROOT::TGenericClassInfo 
         instance("evdb::ScanFrame", "nutools/EventDisplayBase/ScanWindow.h", 41,
                  typeid(::evdb::ScanFrame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdbcLcLScanFrame_Dictionary, isa_proxy, 1,
                  sizeof(::evdb::ScanFrame) );
      instance.SetDelete(&delete_evdbcLcLScanFrame);
      instance.SetDeleteArray(&deleteArray_evdbcLcLScanFrame);
      instance.SetDestructor(&destruct_evdbcLcLScanFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evdb::ScanFrame*)
   {
      return GenerateInitInstanceLocal((::evdb::ScanFrame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::evdb::ScanFrame*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdbcLcLScanFrame_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::evdb::ScanFrame*)0x0)->GetClass();
      evdbcLcLScanFrame_TClassManip(theClass);
   return theClass;
   }

   static void evdbcLcLScanFrame_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static void *new_evdbcLcLScanWindow(void *p = 0);
   static void *newArray_evdbcLcLScanWindow(Long_t size, void *p);
   static void delete_evdbcLcLScanWindow(void *p);
   static void deleteArray_evdbcLcLScanWindow(void *p);
   static void destruct_evdbcLcLScanWindow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evdb::ScanWindow*)
   {
      ::evdb::ScanWindow *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::evdb::ScanWindow >(0);
      static ::ROOT::TGenericClassInfo 
         instance("evdb::ScanWindow", ::evdb::ScanWindow::Class_Version(), "nutools/EventDisplayBase/ScanWindow.h", 83,
                  typeid(::evdb::ScanWindow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::evdb::ScanWindow::Dictionary, isa_proxy, 4,
                  sizeof(::evdb::ScanWindow) );
      instance.SetNew(&new_evdbcLcLScanWindow);
      instance.SetNewArray(&newArray_evdbcLcLScanWindow);
      instance.SetDelete(&delete_evdbcLcLScanWindow);
      instance.SetDeleteArray(&deleteArray_evdbcLcLScanWindow);
      instance.SetDestructor(&destruct_evdbcLcLScanWindow);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evdb::ScanWindow*)
   {
      return GenerateInitInstanceLocal((::evdb::ScanWindow*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::evdb::ScanWindow*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_evdbcLcLPrintDialog(void *p = 0);
   static void *newArray_evdbcLcLPrintDialog(Long_t size, void *p);
   static void delete_evdbcLcLPrintDialog(void *p);
   static void deleteArray_evdbcLcLPrintDialog(void *p);
   static void destruct_evdbcLcLPrintDialog(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evdb::PrintDialog*)
   {
      ::evdb::PrintDialog *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::evdb::PrintDialog >(0);
      static ::ROOT::TGenericClassInfo 
         instance("evdb::PrintDialog", ::evdb::PrintDialog::Class_Version(), "nutools/EventDisplayBase/PrintDialog.h", 22,
                  typeid(::evdb::PrintDialog), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::evdb::PrintDialog::Dictionary, isa_proxy, 4,
                  sizeof(::evdb::PrintDialog) );
      instance.SetNew(&new_evdbcLcLPrintDialog);
      instance.SetNewArray(&newArray_evdbcLcLPrintDialog);
      instance.SetDelete(&delete_evdbcLcLPrintDialog);
      instance.SetDeleteArray(&deleteArray_evdbcLcLPrintDialog);
      instance.SetDestructor(&destruct_evdbcLcLPrintDialog);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evdb::PrintDialog*)
   {
      return GenerateInitInstanceLocal((::evdb::PrintDialog*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::evdb::PrintDialog*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static TClass *evdbcLcLParameterSetEditRow_Dictionary();
   static void evdbcLcLParameterSetEditRow_TClassManip(TClass*);
   static void delete_evdbcLcLParameterSetEditRow(void *p);
   static void deleteArray_evdbcLcLParameterSetEditRow(void *p);
   static void destruct_evdbcLcLParameterSetEditRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evdb::ParameterSetEditRow*)
   {
      ::evdb::ParameterSetEditRow *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evdb::ParameterSetEditRow));
      static ::ROOT::TGenericClassInfo 
         instance("evdb::ParameterSetEditRow", "nutools/EventDisplayBase/ParameterSetEditDialog.h", 85,
                  typeid(::evdb::ParameterSetEditRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdbcLcLParameterSetEditRow_Dictionary, isa_proxy, 1,
                  sizeof(::evdb::ParameterSetEditRow) );
      instance.SetDelete(&delete_evdbcLcLParameterSetEditRow);
      instance.SetDeleteArray(&deleteArray_evdbcLcLParameterSetEditRow);
      instance.SetDestructor(&destruct_evdbcLcLParameterSetEditRow);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evdb::ParameterSetEditRow*)
   {
      return GenerateInitInstanceLocal((::evdb::ParameterSetEditRow*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::evdb::ParameterSetEditRow*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdbcLcLParameterSetEditRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::evdb::ParameterSetEditRow*)0x0)->GetClass();
      evdbcLcLParameterSetEditRow_TClassManip(theClass);
   return theClass;
   }

   static void evdbcLcLParameterSetEditRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *evdbcLcLParameterSetEditFrame_Dictionary();
   static void evdbcLcLParameterSetEditFrame_TClassManip(TClass*);
   static void delete_evdbcLcLParameterSetEditFrame(void *p);
   static void deleteArray_evdbcLcLParameterSetEditFrame(void *p);
   static void destruct_evdbcLcLParameterSetEditFrame(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evdb::ParameterSetEditFrame*)
   {
      ::evdb::ParameterSetEditFrame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evdb::ParameterSetEditFrame));
      static ::ROOT::TGenericClassInfo 
         instance("evdb::ParameterSetEditFrame", "nutools/EventDisplayBase/ParameterSetEditDialog.h", 167,
                  typeid(::evdb::ParameterSetEditFrame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdbcLcLParameterSetEditFrame_Dictionary, isa_proxy, 1,
                  sizeof(::evdb::ParameterSetEditFrame) );
      instance.SetDelete(&delete_evdbcLcLParameterSetEditFrame);
      instance.SetDeleteArray(&deleteArray_evdbcLcLParameterSetEditFrame);
      instance.SetDestructor(&destruct_evdbcLcLParameterSetEditFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evdb::ParameterSetEditFrame*)
   {
      return GenerateInitInstanceLocal((::evdb::ParameterSetEditFrame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::evdb::ParameterSetEditFrame*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdbcLcLParameterSetEditFrame_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::evdb::ParameterSetEditFrame*)0x0)->GetClass();
      evdbcLcLParameterSetEditFrame_TClassManip(theClass);
   return theClass;
   }

   static void evdbcLcLParameterSetEditFrame_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static void delete_evdbcLcLParameterSetEditDialog(void *p);
   static void deleteArray_evdbcLcLParameterSetEditDialog(void *p);
   static void destruct_evdbcLcLParameterSetEditDialog(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evdb::ParameterSetEditDialog*)
   {
      ::evdb::ParameterSetEditDialog *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::evdb::ParameterSetEditDialog >(0);
      static ::ROOT::TGenericClassInfo 
         instance("evdb::ParameterSetEditDialog", ::evdb::ParameterSetEditDialog::Class_Version(), "nutools/EventDisplayBase/ParameterSetEditDialog.h", 201,
                  typeid(::evdb::ParameterSetEditDialog), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::evdb::ParameterSetEditDialog::Dictionary, isa_proxy, 4,
                  sizeof(::evdb::ParameterSetEditDialog) );
      instance.SetDelete(&delete_evdbcLcLParameterSetEditDialog);
      instance.SetDeleteArray(&deleteArray_evdbcLcLParameterSetEditDialog);
      instance.SetDestructor(&destruct_evdbcLcLParameterSetEditDialog);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evdb::ParameterSetEditDialog*)
   {
      return GenerateInitInstanceLocal((::evdb::ParameterSetEditDialog*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::evdb::ParameterSetEditDialog*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static TClass *evdbcLcLParamFrame_Dictionary();
   static void evdbcLcLParamFrame_TClassManip(TClass*);
   static void delete_evdbcLcLParamFrame(void *p);
   static void deleteArray_evdbcLcLParamFrame(void *p);
   static void destruct_evdbcLcLParamFrame(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evdb::ParamFrame*)
   {
      ::evdb::ParamFrame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evdb::ParamFrame));
      static ::ROOT::TGenericClassInfo 
         instance("evdb::ParamFrame", "nutools/EventDisplayBase/ParameterSetEdit.h", 21,
                  typeid(::evdb::ParamFrame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdbcLcLParamFrame_Dictionary, isa_proxy, 1,
                  sizeof(::evdb::ParamFrame) );
      instance.SetDelete(&delete_evdbcLcLParamFrame);
      instance.SetDeleteArray(&deleteArray_evdbcLcLParamFrame);
      instance.SetDestructor(&destruct_evdbcLcLParamFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evdb::ParamFrame*)
   {
      return GenerateInitInstanceLocal((::evdb::ParamFrame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::evdb::ParamFrame*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdbcLcLParamFrame_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::evdb::ParamFrame*)0x0)->GetClass();
      evdbcLcLParamFrame_TClassManip(theClass);
   return theClass;
   }

   static void evdbcLcLParamFrame_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static void delete_evdbcLcLParameterSetEdit(void *p);
   static void deleteArray_evdbcLcLParameterSetEdit(void *p);
   static void destruct_evdbcLcLParameterSetEdit(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evdb::ParameterSetEdit*)
   {
      ::evdb::ParameterSetEdit *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::evdb::ParameterSetEdit >(0);
      static ::ROOT::TGenericClassInfo 
         instance("evdb::ParameterSetEdit", ::evdb::ParameterSetEdit::Class_Version(), "nutools/EventDisplayBase/ParameterSetEdit.h", 52,
                  typeid(::evdb::ParameterSetEdit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::evdb::ParameterSetEdit::Dictionary, isa_proxy, 4,
                  sizeof(::evdb::ParameterSetEdit) );
      instance.SetDelete(&delete_evdbcLcLParameterSetEdit);
      instance.SetDeleteArray(&deleteArray_evdbcLcLParameterSetEdit);
      instance.SetDestructor(&destruct_evdbcLcLParameterSetEdit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evdb::ParameterSetEdit*)
   {
      return GenerateInitInstanceLocal((::evdb::ParameterSetEdit*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::evdb::ParameterSetEdit*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static TClass *evdbcLcLJobMenu_Dictionary();
   static void evdbcLcLJobMenu_TClassManip(TClass*);
   static void delete_evdbcLcLJobMenu(void *p);
   static void deleteArray_evdbcLcLJobMenu(void *p);
   static void destruct_evdbcLcLJobMenu(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evdb::JobMenu*)
   {
      ::evdb::JobMenu *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evdb::JobMenu));
      static ::ROOT::TGenericClassInfo 
         instance("evdb::JobMenu", "nutools/EventDisplayBase/JobMenu.h", 22,
                  typeid(::evdb::JobMenu), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdbcLcLJobMenu_Dictionary, isa_proxy, 1,
                  sizeof(::evdb::JobMenu) );
      instance.SetDelete(&delete_evdbcLcLJobMenu);
      instance.SetDeleteArray(&deleteArray_evdbcLcLJobMenu);
      instance.SetDestructor(&destruct_evdbcLcLJobMenu);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evdb::JobMenu*)
   {
      return GenerateInitInstanceLocal((::evdb::JobMenu*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::evdb::JobMenu*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdbcLcLJobMenu_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::evdb::JobMenu*)0x0)->GetClass();
      evdbcLcLJobMenu_TClassManip(theClass);
   return theClass;
   }

   static void evdbcLcLJobMenu_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *evdbcLcLFileMenu_Dictionary();
   static void evdbcLcLFileMenu_TClassManip(TClass*);
   static void delete_evdbcLcLFileMenu(void *p);
   static void deleteArray_evdbcLcLFileMenu(void *p);
   static void destruct_evdbcLcLFileMenu(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evdb::FileMenu*)
   {
      ::evdb::FileMenu *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evdb::FileMenu));
      static ::ROOT::TGenericClassInfo 
         instance("evdb::FileMenu", "nutools/EventDisplayBase/FileMenu.h", 19,
                  typeid(::evdb::FileMenu), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdbcLcLFileMenu_Dictionary, isa_proxy, 1,
                  sizeof(::evdb::FileMenu) );
      instance.SetDelete(&delete_evdbcLcLFileMenu);
      instance.SetDeleteArray(&deleteArray_evdbcLcLFileMenu);
      instance.SetDestructor(&destruct_evdbcLcLFileMenu);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evdb::FileMenu*)
   {
      return GenerateInitInstanceLocal((::evdb::FileMenu*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::evdb::FileMenu*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdbcLcLFileMenu_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::evdb::FileMenu*)0x0)->GetClass();
      evdbcLcLFileMenu_TClassManip(theClass);
   return theClass;
   }

   static void evdbcLcLFileMenu_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *evdbcLcLEditMenu_Dictionary();
   static void evdbcLcLEditMenu_TClassManip(TClass*);
   static void delete_evdbcLcLEditMenu(void *p);
   static void deleteArray_evdbcLcLEditMenu(void *p);
   static void destruct_evdbcLcLEditMenu(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evdb::EditMenu*)
   {
      ::evdb::EditMenu *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evdb::EditMenu));
      static ::ROOT::TGenericClassInfo 
         instance("evdb::EditMenu", "nutools/EventDisplayBase/EditMenu.h", 19,
                  typeid(::evdb::EditMenu), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdbcLcLEditMenu_Dictionary, isa_proxy, 1,
                  sizeof(::evdb::EditMenu) );
      instance.SetDelete(&delete_evdbcLcLEditMenu);
      instance.SetDeleteArray(&deleteArray_evdbcLcLEditMenu);
      instance.SetDestructor(&destruct_evdbcLcLEditMenu);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evdb::EditMenu*)
   {
      return GenerateInitInstanceLocal((::evdb::EditMenu*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::evdb::EditMenu*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdbcLcLEditMenu_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::evdb::EditMenu*)0x0)->GetClass();
      evdbcLcLEditMenu_TClassManip(theClass);
   return theClass;
   }

   static void evdbcLcLEditMenu_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *evdbcLcLDisplayWindow_Dictionary();
   static void evdbcLcLDisplayWindow_TClassManip(TClass*);
   static void *new_evdbcLcLDisplayWindow(void *p = 0);
   static void *newArray_evdbcLcLDisplayWindow(Long_t size, void *p);
   static void delete_evdbcLcLDisplayWindow(void *p);
   static void deleteArray_evdbcLcLDisplayWindow(void *p);
   static void destruct_evdbcLcLDisplayWindow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evdb::DisplayWindow*)
   {
      ::evdb::DisplayWindow *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evdb::DisplayWindow));
      static ::ROOT::TGenericClassInfo 
         instance("evdb::DisplayWindow", "nutools/EventDisplayBase/DisplayWindow.h", 33,
                  typeid(::evdb::DisplayWindow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdbcLcLDisplayWindow_Dictionary, isa_proxy, 4,
                  sizeof(::evdb::DisplayWindow) );
      instance.SetNew(&new_evdbcLcLDisplayWindow);
      instance.SetNewArray(&newArray_evdbcLcLDisplayWindow);
      instance.SetDelete(&delete_evdbcLcLDisplayWindow);
      instance.SetDeleteArray(&deleteArray_evdbcLcLDisplayWindow);
      instance.SetDestructor(&destruct_evdbcLcLDisplayWindow);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evdb::DisplayWindow*)
   {
      return GenerateInitInstanceLocal((::evdb::DisplayWindow*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::evdb::DisplayWindow*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdbcLcLDisplayWindow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::evdb::DisplayWindow*)0x0)->GetClass();
      evdbcLcLDisplayWindow_TClassManip(theClass);
   return theClass;
   }

   static void evdbcLcLDisplayWindow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static void delete_evdbcLcLButtonBar(void *p);
   static void deleteArray_evdbcLcLButtonBar(void *p);
   static void destruct_evdbcLcLButtonBar(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evdb::ButtonBar*)
   {
      ::evdb::ButtonBar *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::evdb::ButtonBar >(0);
      static ::ROOT::TGenericClassInfo 
         instance("evdb::ButtonBar", ::evdb::ButtonBar::Class_Version(), "nutools/EventDisplayBase/ButtonBar.h", 20,
                  typeid(::evdb::ButtonBar), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::evdb::ButtonBar::Dictionary, isa_proxy, 4,
                  sizeof(::evdb::ButtonBar) );
      instance.SetDelete(&delete_evdbcLcLButtonBar);
      instance.SetDeleteArray(&deleteArray_evdbcLcLButtonBar);
      instance.SetDestructor(&destruct_evdbcLcLButtonBar);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evdb::ButtonBar*)
   {
      return GenerateInitInstanceLocal((::evdb::ButtonBar*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::evdb::ButtonBar*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace evdb {
//______________________________________________________________________________
atomic_TClass_ptr ScanWindow::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *ScanWindow::Class_Name()
{
   return "evdb::ScanWindow";
}

//______________________________________________________________________________
const char *ScanWindow::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::evdb::ScanWindow*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int ScanWindow::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::evdb::ScanWindow*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *ScanWindow::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::evdb::ScanWindow*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *ScanWindow::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::evdb::ScanWindow*)0x0)->GetClass(); }
   return fgIsA;
}

} // namespace evdb
namespace evdb {
//______________________________________________________________________________
atomic_TClass_ptr PrintDialog::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PrintDialog::Class_Name()
{
   return "evdb::PrintDialog";
}

//______________________________________________________________________________
const char *PrintDialog::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::evdb::PrintDialog*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PrintDialog::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::evdb::PrintDialog*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *PrintDialog::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::evdb::PrintDialog*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *PrintDialog::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::evdb::PrintDialog*)0x0)->GetClass(); }
   return fgIsA;
}

} // namespace evdb
namespace evdb {
//______________________________________________________________________________
atomic_TClass_ptr ParameterSetEditDialog::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *ParameterSetEditDialog::Class_Name()
{
   return "evdb::ParameterSetEditDialog";
}

//______________________________________________________________________________
const char *ParameterSetEditDialog::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::evdb::ParameterSetEditDialog*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int ParameterSetEditDialog::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::evdb::ParameterSetEditDialog*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *ParameterSetEditDialog::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::evdb::ParameterSetEditDialog*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *ParameterSetEditDialog::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::evdb::ParameterSetEditDialog*)0x0)->GetClass(); }
   return fgIsA;
}

} // namespace evdb
namespace evdb {
//______________________________________________________________________________
atomic_TClass_ptr ParameterSetEdit::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *ParameterSetEdit::Class_Name()
{
   return "evdb::ParameterSetEdit";
}

//______________________________________________________________________________
const char *ParameterSetEdit::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::evdb::ParameterSetEdit*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int ParameterSetEdit::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::evdb::ParameterSetEdit*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *ParameterSetEdit::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::evdb::ParameterSetEdit*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *ParameterSetEdit::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::evdb::ParameterSetEdit*)0x0)->GetClass(); }
   return fgIsA;
}

} // namespace evdb
namespace evdb {
//______________________________________________________________________________
atomic_TClass_ptr ButtonBar::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *ButtonBar::Class_Name()
{
   return "evdb::ButtonBar";
}

//______________________________________________________________________________
const char *ButtonBar::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::evdb::ButtonBar*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int ButtonBar::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::evdb::ButtonBar*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *ButtonBar::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::evdb::ButtonBar*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *ButtonBar::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::evdb::ButtonBar*)0x0)->GetClass(); }
   return fgIsA;
}

} // namespace evdb
namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdbcLcLWindowMenu(void *p) {
      delete ((::evdb::WindowMenu*)p);
   }
   static void deleteArray_evdbcLcLWindowMenu(void *p) {
      delete [] ((::evdb::WindowMenu*)p);
   }
   static void destruct_evdbcLcLWindowMenu(void *p) {
      typedef ::evdb::WindowMenu current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::evdb::WindowMenu

namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdbcLcLPrintable(void *p) {
      delete ((::evdb::Printable*)p);
   }
   static void deleteArray_evdbcLcLPrintable(void *p) {
      delete [] ((::evdb::Printable*)p);
   }
   static void destruct_evdbcLcLPrintable(void *p) {
      typedef ::evdb::Printable current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::evdb::Printable

namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdbcLcLCanvas(void *p) {
      delete ((::evdb::Canvas*)p);
   }
   static void deleteArray_evdbcLcLCanvas(void *p) {
      delete [] ((::evdb::Canvas*)p);
   }
   static void destruct_evdbcLcLCanvas(void *p) {
      typedef ::evdb::Canvas current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::evdb::Canvas

namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdbcLcLScanFrame(void *p) {
      delete ((::evdb::ScanFrame*)p);
   }
   static void deleteArray_evdbcLcLScanFrame(void *p) {
      delete [] ((::evdb::ScanFrame*)p);
   }
   static void destruct_evdbcLcLScanFrame(void *p) {
      typedef ::evdb::ScanFrame current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::evdb::ScanFrame

namespace evdb {
//______________________________________________________________________________
void ScanWindow::Streamer(TBuffer &R__b)
{
   // Stream an object of class evdb::ScanWindow.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(evdb::ScanWindow::Class(),this);
   } else {
      R__b.WriteClassBuffer(evdb::ScanWindow::Class(),this);
   }
}

} // namespace evdb
namespace ROOT {
   // Wrappers around operator new
   static void *new_evdbcLcLScanWindow(void *p) {
      return  p ? new(p) ::evdb::ScanWindow : new ::evdb::ScanWindow;
   }
   static void *newArray_evdbcLcLScanWindow(Long_t nElements, void *p) {
      return p ? new(p) ::evdb::ScanWindow[nElements] : new ::evdb::ScanWindow[nElements];
   }
   // Wrapper around operator delete
   static void delete_evdbcLcLScanWindow(void *p) {
      delete ((::evdb::ScanWindow*)p);
   }
   static void deleteArray_evdbcLcLScanWindow(void *p) {
      delete [] ((::evdb::ScanWindow*)p);
   }
   static void destruct_evdbcLcLScanWindow(void *p) {
      typedef ::evdb::ScanWindow current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::evdb::ScanWindow

namespace evdb {
//______________________________________________________________________________
void PrintDialog::Streamer(TBuffer &R__b)
{
   // Stream an object of class evdb::PrintDialog.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(evdb::PrintDialog::Class(),this);
   } else {
      R__b.WriteClassBuffer(evdb::PrintDialog::Class(),this);
   }
}

} // namespace evdb
namespace ROOT {
   // Wrappers around operator new
   static void *new_evdbcLcLPrintDialog(void *p) {
      return  p ? new(p) ::evdb::PrintDialog : new ::evdb::PrintDialog;
   }
   static void *newArray_evdbcLcLPrintDialog(Long_t nElements, void *p) {
      return p ? new(p) ::evdb::PrintDialog[nElements] : new ::evdb::PrintDialog[nElements];
   }
   // Wrapper around operator delete
   static void delete_evdbcLcLPrintDialog(void *p) {
      delete ((::evdb::PrintDialog*)p);
   }
   static void deleteArray_evdbcLcLPrintDialog(void *p) {
      delete [] ((::evdb::PrintDialog*)p);
   }
   static void destruct_evdbcLcLPrintDialog(void *p) {
      typedef ::evdb::PrintDialog current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::evdb::PrintDialog

namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdbcLcLParameterSetEditRow(void *p) {
      delete ((::evdb::ParameterSetEditRow*)p);
   }
   static void deleteArray_evdbcLcLParameterSetEditRow(void *p) {
      delete [] ((::evdb::ParameterSetEditRow*)p);
   }
   static void destruct_evdbcLcLParameterSetEditRow(void *p) {
      typedef ::evdb::ParameterSetEditRow current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::evdb::ParameterSetEditRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdbcLcLParameterSetEditFrame(void *p) {
      delete ((::evdb::ParameterSetEditFrame*)p);
   }
   static void deleteArray_evdbcLcLParameterSetEditFrame(void *p) {
      delete [] ((::evdb::ParameterSetEditFrame*)p);
   }
   static void destruct_evdbcLcLParameterSetEditFrame(void *p) {
      typedef ::evdb::ParameterSetEditFrame current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::evdb::ParameterSetEditFrame

namespace evdb {
//______________________________________________________________________________
void ParameterSetEditDialog::Streamer(TBuffer &R__b)
{
   // Stream an object of class evdb::ParameterSetEditDialog.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(evdb::ParameterSetEditDialog::Class(),this);
   } else {
      R__b.WriteClassBuffer(evdb::ParameterSetEditDialog::Class(),this);
   }
}

} // namespace evdb
namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdbcLcLParameterSetEditDialog(void *p) {
      delete ((::evdb::ParameterSetEditDialog*)p);
   }
   static void deleteArray_evdbcLcLParameterSetEditDialog(void *p) {
      delete [] ((::evdb::ParameterSetEditDialog*)p);
   }
   static void destruct_evdbcLcLParameterSetEditDialog(void *p) {
      typedef ::evdb::ParameterSetEditDialog current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::evdb::ParameterSetEditDialog

namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdbcLcLParamFrame(void *p) {
      delete ((::evdb::ParamFrame*)p);
   }
   static void deleteArray_evdbcLcLParamFrame(void *p) {
      delete [] ((::evdb::ParamFrame*)p);
   }
   static void destruct_evdbcLcLParamFrame(void *p) {
      typedef ::evdb::ParamFrame current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::evdb::ParamFrame

namespace evdb {
//______________________________________________________________________________
void ParameterSetEdit::Streamer(TBuffer &R__b)
{
   // Stream an object of class evdb::ParameterSetEdit.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(evdb::ParameterSetEdit::Class(),this);
   } else {
      R__b.WriteClassBuffer(evdb::ParameterSetEdit::Class(),this);
   }
}

} // namespace evdb
namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdbcLcLParameterSetEdit(void *p) {
      delete ((::evdb::ParameterSetEdit*)p);
   }
   static void deleteArray_evdbcLcLParameterSetEdit(void *p) {
      delete [] ((::evdb::ParameterSetEdit*)p);
   }
   static void destruct_evdbcLcLParameterSetEdit(void *p) {
      typedef ::evdb::ParameterSetEdit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::evdb::ParameterSetEdit

namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdbcLcLJobMenu(void *p) {
      delete ((::evdb::JobMenu*)p);
   }
   static void deleteArray_evdbcLcLJobMenu(void *p) {
      delete [] ((::evdb::JobMenu*)p);
   }
   static void destruct_evdbcLcLJobMenu(void *p) {
      typedef ::evdb::JobMenu current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::evdb::JobMenu

namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdbcLcLFileMenu(void *p) {
      delete ((::evdb::FileMenu*)p);
   }
   static void deleteArray_evdbcLcLFileMenu(void *p) {
      delete [] ((::evdb::FileMenu*)p);
   }
   static void destruct_evdbcLcLFileMenu(void *p) {
      typedef ::evdb::FileMenu current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::evdb::FileMenu

namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdbcLcLEditMenu(void *p) {
      delete ((::evdb::EditMenu*)p);
   }
   static void deleteArray_evdbcLcLEditMenu(void *p) {
      delete [] ((::evdb::EditMenu*)p);
   }
   static void destruct_evdbcLcLEditMenu(void *p) {
      typedef ::evdb::EditMenu current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::evdb::EditMenu

namespace ROOT {
   // Wrappers around operator new
   static void *new_evdbcLcLDisplayWindow(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::evdb::DisplayWindow : new ::evdb::DisplayWindow;
   }
   static void *newArray_evdbcLcLDisplayWindow(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::evdb::DisplayWindow[nElements] : new ::evdb::DisplayWindow[nElements];
   }
   // Wrapper around operator delete
   static void delete_evdbcLcLDisplayWindow(void *p) {
      delete ((::evdb::DisplayWindow*)p);
   }
   static void deleteArray_evdbcLcLDisplayWindow(void *p) {
      delete [] ((::evdb::DisplayWindow*)p);
   }
   static void destruct_evdbcLcLDisplayWindow(void *p) {
      typedef ::evdb::DisplayWindow current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::evdb::DisplayWindow

namespace evdb {
//______________________________________________________________________________
void ButtonBar::Streamer(TBuffer &R__b)
{
   // Stream an object of class evdb::ButtonBar.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(evdb::ButtonBar::Class(),this);
   } else {
      R__b.WriteClassBuffer(evdb::ButtonBar::Class(),this);
   }
}

} // namespace evdb
namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdbcLcLButtonBar(void *p) {
      delete ((::evdb::ButtonBar*)p);
   }
   static void deleteArray_evdbcLcLButtonBar(void *p) {
      delete [] ((::evdb::ButtonBar*)p);
   }
   static void destruct_evdbcLcLButtonBar(void *p) {
      typedef ::evdb::ButtonBar current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::evdb::ButtonBar

namespace {
  void TriggerDictionaryInitialization_libEventDisplayBase_Impl() {
    static const char* headers[] = {
"nutools/EventDisplayBase/evdb.h",
"nutools/EventDisplayBase/WindowMenu.h",
"nutools/EventDisplayBase/View3D.h",
"nutools/EventDisplayBase/View2D.h",
"nutools/EventDisplayBase/ServiceTable.h",
"nutools/EventDisplayBase/ScanWindow.h",
"nutools/EventDisplayBase/RootEnv.h",
"nutools/EventDisplayBase/Reconfigurable.h",
"nutools/EventDisplayBase/Printable.h",
"nutools/EventDisplayBase/PrintDialog.h",
"nutools/EventDisplayBase/ParameterSetEditDialog.h",
"nutools/EventDisplayBase/ParameterSetEdit.h",
"nutools/EventDisplayBase/ObjListCanvas.h",
"nutools/EventDisplayBase/NavState.h",
"nutools/EventDisplayBase/MenuBar.h",
"nutools/EventDisplayBase/ListWindow.h",
"nutools/EventDisplayBase/JobMenu.h",
"nutools/EventDisplayBase/HelpMenu.h",
"nutools/EventDisplayBase/FileMenu.h",
"nutools/EventDisplayBase/EventHolder.h",
"nutools/EventDisplayBase/EditMenu.h",
"nutools/EventDisplayBase/DisplayWindow.h",
"nutools/EventDisplayBase/ColorScale.h",
"nutools/EventDisplayBase/Canvas.h",
"nutools/EventDisplayBase/ButtonBar.h",
0
    };
    static const char* includePaths[] = {
0
    };
    static const char* fwdDeclCode = R"DICTFWDDCLS(
#line 1 "libEventDisplayBase dictionary forward declarations' payload"
#pragma clang diagnostic ignored "-Wkeyword-compat"
#pragma clang diagnostic ignored "-Wignored-attributes"
#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
extern int __Cling_Autoloading_Map;
namespace evdb{class __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/WindowMenu.h")))  WindowMenu;}
namespace evdb{class __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/Printable.h")))  __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/ScanWindow.h")))  Printable;}
namespace evdb{class __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/Canvas.h")))  __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/ScanWindow.h")))  Canvas;}
namespace evdb{class __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/ScanWindow.h")))  ScanFrame;}
namespace evdb{class __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/ScanWindow.h")))  ScanWindow;}
namespace evdb{class __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/PrintDialog.h")))  PrintDialog;}
namespace evdb{class __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/ParameterSetEditDialog.h")))  ParameterSetEditRow;}
namespace evdb{class __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/ParameterSetEditDialog.h")))  ParameterSetEditFrame;}
namespace evdb{class __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/ParameterSetEditDialog.h")))  ParameterSetEditDialog;}
namespace evdb{class __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/ParameterSetEdit.h")))  ParamFrame;}
namespace evdb{class __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/ParameterSetEdit.h")))  ParameterSetEdit;}
namespace evdb{class __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/JobMenu.h")))  JobMenu;}
namespace evdb{class __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/FileMenu.h")))  FileMenu;}
namespace evdb{class __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/EditMenu.h")))  EditMenu;}
namespace evdb{class __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/DisplayWindow.h")))  DisplayWindow;}
namespace evdb{class __attribute__((annotate("$clingAutoload$nutools/EventDisplayBase/ButtonBar.h")))  ButtonBar;}
)DICTFWDDCLS";
    static const char* payloadCode = R"DICTPAYLOAD(
#line 1 "libEventDisplayBase dictionary payload"

#ifndef G__VECTOR_HAS_CLASS_ITERATOR
  #define G__VECTOR_HAS_CLASS_ITERATOR 1
#endif
#ifndef USE_ROOT
  #define USE_ROOT 1
#endif

#define _BACKWARD_BACKWARD_WARNING_H
#include "nutools/EventDisplayBase/evdb.h"
#include "nutools/EventDisplayBase/WindowMenu.h"
#include "nutools/EventDisplayBase/View3D.h"
#include "nutools/EventDisplayBase/View2D.h"
#include "nutools/EventDisplayBase/ServiceTable.h"
#include "nutools/EventDisplayBase/ScanWindow.h"
#include "nutools/EventDisplayBase/RootEnv.h"
#include "nutools/EventDisplayBase/Reconfigurable.h"
#include "nutools/EventDisplayBase/Printable.h"
#include "nutools/EventDisplayBase/PrintDialog.h"
#include "nutools/EventDisplayBase/ParameterSetEditDialog.h"
#include "nutools/EventDisplayBase/ParameterSetEdit.h"
#include "nutools/EventDisplayBase/ObjListCanvas.h"
#include "nutools/EventDisplayBase/NavState.h"
#include "nutools/EventDisplayBase/MenuBar.h"
#include "nutools/EventDisplayBase/ListWindow.h"
#include "nutools/EventDisplayBase/JobMenu.h"
#include "nutools/EventDisplayBase/HelpMenu.h"
#include "nutools/EventDisplayBase/FileMenu.h"
#include "nutools/EventDisplayBase/EventHolder.h"
#include "nutools/EventDisplayBase/EditMenu.h"
#include "nutools/EventDisplayBase/DisplayWindow.h"
#include "nutools/EventDisplayBase/ColorScale.h"
#include "nutools/EventDisplayBase/Canvas.h"
#include "nutools/EventDisplayBase/ButtonBar.h"

#undef  _BACKWARD_BACKWARD_WARNING_H
)DICTPAYLOAD";
    static const char* classesHeaders[]={
"evdb::ButtonBar", payloadCode, "@",
"evdb::Canvas", payloadCode, "@",
"evdb::DisplayWindow", payloadCode, "@",
"evdb::EditMenu", payloadCode, "@",
"evdb::FileMenu", payloadCode, "@",
"evdb::JobMenu", payloadCode, "@",
"evdb::ParamFrame", payloadCode, "@",
"evdb::ParameterSetEdit", payloadCode, "@",
"evdb::ParameterSetEditDialog", payloadCode, "@",
"evdb::ParameterSetEditFrame", payloadCode, "@",
"evdb::ParameterSetEditRow", payloadCode, "@",
"evdb::PrintDialog", payloadCode, "@",
"evdb::Printable", payloadCode, "@",
"evdb::ScanFrame", payloadCode, "@",
"evdb::ScanWindow", payloadCode, "@",
"evdb::WindowMenu", payloadCode, "@",
nullptr};

    static bool isInitialized = false;
    if (!isInitialized) {
      TROOT::RegisterModule("libEventDisplayBase",
        headers, includePaths, payloadCode, fwdDeclCode,
        TriggerDictionaryInitialization_libEventDisplayBase_Impl, {}, classesHeaders);
      isInitialized = true;
    }
  }
  static struct DictInit {
    DictInit() {
      TriggerDictionaryInitialization_libEventDisplayBase_Impl();
    }
  } __TheDictionaryInitializer;
}
void TriggerDictionaryInitialization_libEventDisplayBase() {
  TriggerDictionaryInitialization_libEventDisplayBase_Impl();
}