ScroomInterfaceImpl Class Reference

Inheritance diagram for ScroomInterfaceImpl:

Collaboration diagram for ScroomInterfaceImpl:

Public Types
using	Ptr = boost::shared_ptr< ScroomInterfaceImpl >
Public Types inherited from ScroomInterface
using	Ptr = boost::shared_ptr< ScroomInterface >

Public Member Functions
PresentationInterface::Ptr	newPresentation (const std::string &name) override
Aggregate::Ptr	newAggregate (const std::string &name) override
PresentationInterface::Ptr	loadPresentation (const std::string &name, const std::string &relativeTo=std::string()) override
void	showPresentation (PresentationInterface::Ptr const &presentation) override

Static Public Member Functions
static Ptr	instance ()

Private Member Functions
	ScroomInterfaceImpl ()=default

Member Typedef Documentation

Ptr

using ScroomInterfaceImpl::Ptr = boost::shared_ptr<ScroomInterfaceImpl>

Constructor & Destructor Documentation

ScroomInterfaceImpl()

ScroomInterfaceImpl::ScroomInterfaceImpl ( )

privatedefault

Referenced by instance().

Here is the caller graph for this function:

Member Function Documentation

instance()

ScroomInterfaceImpl::Ptr ScroomInterfaceImpl::instance ( )

static

{
  static ScroomInterfaceImpl::Ptr const i(new ScroomInterfaceImpl());
  return i;
}

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

loadPresentation()

PresentationInterface::Ptr ScroomInterfaceImpl::loadPresentation ( const std::string &  name, const std::string &  relativeTo = std::string()  )

overridevirtual

Implements ScroomInterface.

{
  boost::filesystem::path       name(n);
  boost::filesystem::path const relativeTo(rt);
 
  if(!name.is_absolute() && relativeTo.has_parent_path())
  {
    name = relativeTo.parent_path() / name;
  }
 
  return ::loadPresentation(name.string());
}

Here is the call graph for this function:

newAggregate()

Aggregate::Ptr ScroomInterfaceImpl::newAggregate ( const std::string &  name )

overridevirtual

Implements ScroomInterface.

{
  std::map<std::string, NewAggregateInterface::Ptr> const& newAggregateInterfaces =
    PluginManager::getInstance()->getNewAggregateInterfaces();
  auto i = newAggregateInterfaces.find(name);
  if(i != newAggregateInterfaces.end())
  {
    Aggregate::Ptr aggregate = i->second->createNew();
    if(aggregate)
    {
      PresentationInterface::Ptr const aggregatePresentation = boost::dynamic_pointer_cast<PresentationInterface>(aggregate);
 
      if(aggregatePresentation)
      {
        on_presentation_created(aggregatePresentation);
      }
 
      return aggregate;
    }
 
    throw std::invalid_argument("Failed to create a new" + name);
  }
  throw std::invalid_argument("Don't know how to create a new " + name);
}

Here is the call graph for this function:

newPresentation()

PresentationInterface::Ptr ScroomInterfaceImpl::newPresentation ( const std::string &  name )

overridevirtual

Implements ScroomInterface.

{
  const std::map<NewPresentationInterface::Ptr, std::string>& newPresentationInterfaces =
    PluginManager::getInstance()->getNewPresentationInterfaces();
 
  for(auto const& p: newPresentationInterfaces)
  {
    if(p.second == name)
    {
      PresentationInterface::Ptr presentation = p.first->createNew();
      if(presentation)
      {
        on_presentation_created(presentation);
        return presentation;
      }
 
      throw std::invalid_argument("Failed to create a new " + name);
    }
  }
 
  throw std::invalid_argument("Don't know how to create a new " + name);
}

Here is the call graph for this function:

showPresentation()

void ScroomInterfaceImpl::showPresentation ( PresentationInterface::Ptr const &  presentation )

overridevirtual

Implements ScroomInterface.

{
  on_presentation_created(presentation);
  find_or_create_scroom(presentation);
}

Here is the call graph for this function:

---

The documentation for this class was generated from the following file:

• gui/src/loader.cc