FWEventItem.h

Go to the documentation of this file.

#ifndef Fireworks_Core_FWEventItem_h
#define Fireworks_Core_FWEventItem_h
// -*- C++ -*-
//
// Package:     Core
// Class  :     FWEventItem
//
//
// Original Author:  Chris Jones
//         Created:  Thu Jan  3 14:02:21 EST 2008
// $Id: FWEventItem.h,v 1.50 2012/06/26 22:13:03 wmtan Exp $
//

// system include files
#include <string>
#include <vector>
#include "Reflex/Type.h"
#include <boost/shared_ptr.hpp>
#include <sigc++/connection.h>

// user include files
#include "Fireworks/Core/interface/FWDisplayProperties.h"
#include "Fireworks/Core/interface/FWPhysicsObjectDesc.h"
#include "Fireworks/Core/interface/FWModelChangeSignal.h"
#include "Fireworks/Core/interface/FWItemChangeSignal.h"

#include "Fireworks/Core/interface/FWModelFilter.h"
#include "Fireworks/Core/interface/FWItemValueGetter.h"

#include "Fireworks/Core/interface/Context.h"

// forward declarations
class TClass;
class FWModelChangeManager;
class FWSelectionManager;
class FWGeometry;
class TVirtualCollectionProxy;
class FWItemAccessorBase;
class FWProxyBuilderConfiguration;
class FWConfiguration;

namespace edm {
   class EventBase;
}
namespace fireworks {
   class Context;
}

class FWEventItem
{
public:
   struct ModelInfo {
      FWDisplayProperties m_displayProperties;
      bool m_isSelected;
      ModelInfo(const FWDisplayProperties& iProps, bool iIsSelected) :
         m_displayProperties(iProps),
         m_isSelected(iIsSelected) {
      }

      const FWDisplayProperties& displayProperties() const {
         return m_displayProperties;
      }
      bool isSelected() const {
         return m_isSelected;
      }
   };

   FWEventItem(fireworks::Context* iContext,
               unsigned int iItemId,
               boost::shared_ptr<FWItemAccessorBase> iAccessor,
               const FWPhysicsObjectDesc& iDesc,  const FWConfiguration* pbConf = 0);
   virtual ~FWEventItem();

   // ---------- const member functions ---------------------
#if !defined(__CINT__) && !defined(__MAKECINT__)
   template<class T>
   void get(const T*& oData) const {
      oData=reinterpret_cast<const T*>(data(typeid(T)));
   }
#endif
   const void* data(const std::type_info&) const;
   const FWDisplayProperties& defaultDisplayProperties() const;

   int layer() const;
   bool isInFront() const;
   bool isInBack() const;

   const std::string& filterExpression() const;
   unsigned int id() const;
   const std::string& name() const;
   const TClass* type() const;
   const std::string& purpose() const;

   const std::string& moduleLabel() const;
   const std::string& productInstanceLabel() const;
   const std::string& processName() const;

   const TClass* modelType() const;
   ModelInfo modelInfo(int iIndex) const;    //return copy for now since want to be able to change visibility
   size_t size() const;
   const void* modelData(int iIndex) const;
   std::string modelName(int iIndex) const;

  const  FWItemValueGetter& valueGetter() const { return m_interestingValueGetter; }
   bool haveInterestingValue() const;
   const std::string& modelInterestingValueAsString(int iIndex) const;

   bool isCollection() const;

   //convenience methods

   const fireworks::Context& context () const {
      return *m_context;
   }

   FWModelChangeManager* changeManager() const {
      return m_context->modelChangeManager();
   }
   FWSelectionManager* selectionManager() const {
      return m_context->selectionManager();
   }
   
   FWColorManager* colorManager() const {
      return m_context->colorManager();
   }

   bool hasEvent() const {
      return 0 != m_event;
   }

   // hackery methods
   const edm::EventBase *getEvent () const {
      return m_event;
   }


   bool hasError() const;
   const std::string& errorMessage() const;
   
   // ---------- static member functions --------------------

   static int minLayerValue();
   static int maxLayerValue();

   // ---------- member functions ---------------------------
   void setEvent(const edm::EventBase* iEvent);

   const FWGeometry* getGeom() const;
   FWProxyBuilderConfiguration* getConfig() const { return m_proxyBuilderConfig; }

   void setLabels(const std::string& iModule,
                  const std::string& iProductInstance,
                  const std::string& iProcess);
   void setName(const std::string& iName);
   void setDefaultDisplayProperties(const FWDisplayProperties&);
   void setFilterExpression(const std::string& );

   void selectItem();
   void unselectItem();
   void toggleSelectItem();
   bool itemIsSelected() const;
   
   void moveToFront();
   void moveToBack();
   void moveToLayer(int layer);

   void proxyConfigChanged();

   void unselect(int iIndex) const;
   void select(int iIndex) const;
   void toggleSelect(int iIndex) const;
   void setDisplayProperties(int iIndex, const FWDisplayProperties&) const;

   void destroy() const;
   mutable FWModelChangeSignal changed_;

   mutable FWItemChangeSignal itemChanged_;

   mutable FWItemChangeSignal preItemChanged_;

   mutable FWItemChangeSignal defaultDisplayPropertiesChanged_;
   
   mutable FWItemChangeSignal filterChanged_;

   mutable FWItemChangeSignal goingToBeDestroyed_;
private:
   //FWEventItem(const FWEventItem&); // stop default

   //const FWEventItem& operator=(const FWEventItem&); // stop default
   void setData(const Reflex::Object& ) const;

   void getPrimaryData() const;
   void runFilter();
   void handleChange();
   // ---------- member data --------------------------------
   const fireworks::Context* m_context;
   unsigned int m_id;
   std::string m_name;
   const TClass* m_type;
   std::string m_purpose;
   boost::shared_ptr<FWItemAccessorBase> m_accessor;
   FWDisplayProperties m_displayProperties;
   int m_layer;
   mutable std::vector<ModelInfo> m_itemInfos;

   //This will probably moved to a FWEventItemRetriever class
   std::string m_moduleLabel;
   std::string m_productInstanceLabel;
   std::string m_processName;
   const edm::EventBase* m_event;
   Reflex::Type m_wrapperType;
   FWItemValueGetter m_interestingValueGetter;

   FWModelFilter m_filter;
   mutable bool m_printedErrorThisEvent;
   mutable std::string m_errorMessage;
   
   bool m_isSelected;


   FWProxyBuilderConfiguration*  m_proxyBuilderConfig;
};


#endif