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
//
 
// system include files
#include <string>
#include <vector>
#include "FWCore/Reflection/interface/TypeWithDict.h"
#include <memory>
#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,
              std::shared_ptr<FWItemAccessorBase> iAccessor,
              const FWPhysicsObjectDesc& iDesc,
              const FWConfiguration* pbConf = nullptr);
  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;
 
  void resetColor();
  //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 nullptr != 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);
 
  void setData(const edm::ObjectWithDict&) const;
 
  void getPrimaryData() const;
  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(bool k = false);
 
  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 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;
  std::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;
  edm::TypeWithDict m_wrapperType;
  FWItemValueGetter m_interestingValueGetter;
 
  FWModelFilter m_filter;
  mutable bool m_printedErrorThisEvent;
  mutable std::string m_errorMessage;
 
  bool m_isSelected;
  Color_t m_origColor;
 
  FWProxyBuilderConfiguration* m_proxyBuilderConfig;
};
 
#endif