ApplicationContext.hpp

#pragma once
#include <score/application/ApplicationComponents.hpp>
 
namespace score
{
class ApplicationComponents;
struct ApplicationSettings;
class SettingsDelegateModel;
class SettingsDelegateFactory;
class DocumentManager;
class MenuManager;
class ToolbarManager;
class ActionManager;
struct DocumentList;
struct DocumentContext;
struct SCORE_LIB_BASE_EXPORT ApplicationContext
{
  explicit ApplicationContext(
      const score::ApplicationSettings&, const ApplicationComponents&, DocumentList& l,
      const std::vector<std::unique_ptr<score::SettingsDelegateModel>>&);
  ApplicationContext(const ApplicationContext&) = delete;
  ApplicationContext(ApplicationContext&&) = delete;
  ApplicationContext& operator=(const ApplicationContext&) = delete;
 
  ~ApplicationContext();
 
  template <typename T>
  T& settings() const
  {
    if(auto c = findSettings<T>())
      return *c;
 
    SCORE_ABORT;
    throw;
  }
 
  template <typename T>
  T* findSettings() const noexcept
  {
    for(auto& elt : this->m_settings)
    {
      if(auto c = dynamic_cast<T*>(elt.get()))
      {
        return c;
      }
    }
    return nullptr;
  }
 
  const auto& allSettings() const noexcept { return m_settings; }
 
  const auto& addons() const { return components.addons(); }
 
  template <typename T>
  const T& interfaces() const
  {
    return components.interfaces<T>();
  }
 
  auto instantiateUndoCommand(const CommandData& cmd) const
  {
    return components.instantiateUndoCommand(cmd);
  }
 
  const score::DocumentContext* currentDocument() const noexcept;
 
  const score::ApplicationSettings& applicationSettings;
 
  const score::ApplicationComponents& components;
 
  DocumentList& documents;
 
private:
  const std::vector<std::unique_ptr<score::SettingsDelegateModel>>& m_settings;
};
 
// By default this is defined in score::Application
SCORE_LIB_BASE_EXPORT const ApplicationContext& AppContext();
}