PluginManager Class Reference

#include <pluginmanager.hh>

Inheritance diagram for PluginManager:

Collaboration diagram for PluginManager:

Public Types
using	Ptr = boost::shared_ptr< PluginManager >
Public Types inherited from ScroomPluginInterface
using	Ptr = boost::shared_ptr< ScroomPluginInterface >

Public Member Functions
bool	doWork () override
void	addHook (bool devMode)
void	registerNewPresentationInterface (const std::string &identifier, NewPresentationInterface::Ptr newPresentationInterface) override
void	registerNewAggregateInterface (const std::string &identifier, NewAggregateInterface::Ptr newAggregateInterface) override
void	registerOpenPresentationInterface (const std::string &extension, OpenPresentationInterface::Ptr openPresentationInterface) override
void	registerOpenTiledBitmapInterface (const std::string &identifier, boost::shared_ptr< Scroom::TiledBitmap::OpenTiledBitmapInterface > openTiledBitmapInterface) override
void	registerOpenInterface (const std::string &extension, OpenInterface::Ptr openInterface) override
void	registerViewObserver (const std::string &identifier, ViewObserver::Ptr observer) override
void	registerPresentationObserver (const std::string &identifier, PresentationObserver::Ptr observer) override
const std::map< NewPresentationInterface::Ptr, std::string > &	getNewPresentationInterfaces ()
const std::map< std::string, NewAggregateInterface::Ptr > &	getNewAggregateInterfaces ()
const std::map< OpenPresentationInterface::Ptr, std::string > &	getOpenPresentationInterfaces ()
const std::map< Scroom::TiledBitmap::OpenTiledBitmapInterface::Ptr, std::string > &	getOpenTiledBitmapInterfaces ()
const std::map< OpenInterface::Ptr, std::string > &	getOpenInterfaces ()
const std::map< ViewObserver::Ptr, std::string > &	getViewObservers ()
const std::map< PresentationObserver::Ptr, std::string > &	getPresentationObservers ()
Public Member Functions inherited from Scroom::Utils::Base
	Base ()=default
	Base (const Base &)=delete
	Base (Base &&)=delete
Base &	operator= (const Base &)=delete
Base &	operator= (Base &&)=delete
virtual	~Base ()=default
template<typename R >
boost::shared_ptr< R >	shared_from_this ()
template<typename R >
boost::shared_ptr< R const >	shared_from_this () const

Static Public Member Functions
static Ptr	create ()
static PluginManager::Ptr	getInstance ()

Private Types
enum	PluginManagerState { FINDING_DIRECTORIES, SCANNING_DIRECTORIES, LOADING_FILES, DONE }

Private Member Functions
void	setStatusBarMessage (const char *message)
	PluginManager ()=default

Private Attributes
bool	devMode {false}
PluginManagerState	state {FINDING_DIRECTORIES}
std::list< std::string >	dirs
std::list< std::string >::iterator	currentDir
std::list< std::string >	files
std::list< std::string >::iterator	currentFile
std::list< PluginInformation >	pluginInformationList
std::map< NewPresentationInterface::Ptr, std::string >	newPresentationInterfaces
std::map< std::string, NewAggregateInterface::Ptr >	newAggregateInterfaces
std::map< OpenPresentationInterface::Ptr, std::string >	openPresentationInterfaces
std::map< Scroom::TiledBitmap::OpenTiledBitmapInterface::Ptr, std::string >	openTiledBitmapInterfaces
std::map< OpenInterface::Ptr, std::string >	openInterfaces
std::map< ViewObserver::Ptr, std::string >	viewObservers
std::map< PresentationObserver::Ptr, std::string >	presentationObservers

Member Typedef Documentation

Ptr

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

Member Enumeration Documentation

PluginManagerState

enum PluginManager::PluginManagerState

private

Enumerator
FINDING_DIRECTORIES
SCANNING_DIRECTORIES
LOADING_FILES
DONE

  {
    FINDING_DIRECTORIES,
    SCANNING_DIRECTORIES,
    LOADING_FILES,
    DONE
  };

Constructor & Destructor Documentation

PluginManager()

PluginManager::PluginManager ( )

privatedefault

Referenced by create().

Here is the caller graph for this function:

Member Function Documentation

addHook()

void PluginManager::addHook

(

bool

devMode

)

{
  devMode = devMode_;
  gdk_threads_add_idle(on_idle, static_cast<WorkInterface*>(this));
  // progressbar = GTK_PROGRESS_BAR(lookup_widget(scroom, "progressbar"));
  // statusbar = GTK_STATUSBAR(lookup_widget(scroom, "statusbar"));
  //
  // status_context_id = gtk_statusbar_get_context_id(statusbar, "Plugin Manager");
  state = FINDING_DIRECTORIES;
}

Here is the call graph for this function:

create()

PluginManager::Ptr PluginManager::create ( )

static

{ return Ptr(new PluginManager()); }

Here is the call graph for this function:

doWork()

bool PluginManager::doWork ( )

overridevirtual

Implements WorkInterface.

{
  bool retval = true;
 
  switch(state)
  {
  case FINDING_DIRECTORIES:
  {
    setStatusBarMessage("Locating plugin directories");
    char* path = getenv(SCROOM_PLUGIN_DIRS.c_str());
    dirs.clear();
 
    if(!devMode)
    {
#ifdef _WIN32
      // We want to keep everything portable on windows so we look for the plugin folder in the same directory as the .exe
      std::string plugin_path = (boost::dll::program_location().parent_path() / "plugins").generic_string();
      dirs.push_back(plugin_path);
#else
      dirs.emplace_back(PLUGIN_DIR);
#endif
    }
 
    if(path != nullptr)
    {
      spdlog::debug("{} = {}", SCROOM_PLUGIN_DIRS, path);
 
      for(char* i = path; *i != '\0'; i++)
      {
 
// Windows uses semicolons for delimiting environment variables, Linux uses colons
#ifdef _WIN32
        const char envDelim = ';';
#else
        const char envDelim = ':';
#endif
        if(*i != envDelim)
        {
          continue;
        }
 
        *i = '\0';
        dirs.emplace_back(path);
        path = i + 1;
      }
 
      dirs.emplace_back(path);
    }
 
    currentDir = dirs.begin();
    files.clear();
    state = SCANNING_DIRECTORIES;
    break;
  }
 
  case SCANNING_DIRECTORIES:
  {
    setStatusBarMessage("Scanning plugin directories");
    if(currentDir == dirs.end())
    {
      state       = LOADING_FILES;
      currentFile = files.begin();
      break;
    }
 
    spdlog::debug("Scanning directory: {}", *currentDir);
    const char* folder = currentDir->c_str();
    namespace fs       = boost::filesystem;
    boost::system::error_code ec;
 
    if(!fs::is_directory(folder, ec))
    {
      spdlog::error("Can't open directory: {}", folder);
      currentDir++;
      break;
    }
 
    for(const auto& entry: fs::directory_iterator(folder))
    {
      if(fs::is_regular_file(entry) || fs::is_symlink(entry) || fs::is_other(entry))
      {
        files.push_back(entry.path().generic_string());
      }
    }
 
    currentDir++;
    break;
  }
 
  case LOADING_FILES:
  {
    setStatusBarMessage("Loading Plugins");
    if(currentFile == files.end())
    {
      state = DONE;
      break;
    }
 
#ifdef _WIN32
    // Only read .dll files
    if(currentFile->compare(currentFile->size() - 4, 4, ".dll") == 0)
    {
#else
    // Only read .so files
    if(currentFile->compare(currentFile->size() - 3, 3, ".so") == 0)
    {
#endif
      spdlog::debug("Reading file: {}", *currentFile);
      GModule* plugin = g_module_open(currentFile->c_str(), static_cast<GModuleFlags>(0));
      if(plugin)
      {
        gpointer pgpi         = nullptr;
        bool     symbol_found = false;
 
        if(g_module_symbol(plugin, "_Z20getPluginInformationv", &pgpi))
        {
          symbol_found = true;
        }
        else if(g_module_symbol(plugin, "getPluginInformation", &pgpi))
        {
          symbol_found = true;
          spdlog::warn("Plugin {} uses C-style GetPluginInformation - You need to recompile it", *currentFile);
        }
 
        if(symbol_found)
        {
          using PluginFunc = boost::shared_ptr<PluginInformationInterface> (*)();
 
          auto gpi = reinterpret_cast<PluginFunc>(pgpi);
          if(gpi)
          {
            PluginInformationInterface::Ptr pi = (*gpi)();
            if(pi)
            {
              if(pi->pluginApiVersion == PLUGIN_API_VERSION)
              {
                pluginInformationList.emplace_back(plugin, pi);
                pi->registerCapabilities(shared_from_this<PluginManager>());
                plugin = nullptr;
                gpi    = nullptr;
                pi.reset();
              }
              else
              {
                spdlog::error("Plugin {} has incorrect API version {}, instead of {}",
                              *currentFile,
                              pi->pluginApiVersion,
                              PLUGIN_API_VERSION);
              }
            }
            else
            {
              spdlog::error("GetPluginInformation returned NULL for file {}", *currentFile);
            }
          }
          else
          {
            spdlog::error("Can't find the getPluginInterface function in file {}: {}", *currentFile, g_module_error());
          }
        }
        else
        {
          spdlog::warn("Can't lookup symbols in file {}: {}", *currentFile, g_module_error());
        }
 
        if(plugin)
        {
          g_module_close(plugin);
        }
      }
      else
      {
        spdlog::error("Something went wrong for file {}: {}", *currentFile, g_module_error());
      }
    }
    currentFile++;
    break;
  }
  case DONE:
  {
    setStatusBarMessage("Done loading plugins");
 
    std::vector<std::pair<std::string, std::string>> pluginInfo;
    pluginInfo.reserve(pluginInformationList.size());
    size_t maxPluginNameLength = 0;
    for(const auto& plugin: pluginInformationList)
    {
      pluginInfo.emplace_back(plugin.pluginInformation->getPluginName(), plugin.pluginInformation->getPluginVersion());
      maxPluginNameLength = std::max(maxPluginNameLength, plugin.pluginInformation->getPluginName().size());
    }
    std::sort(pluginInfo.begin(), pluginInfo.end());
    spdlog::info("Loaded plugins:");
    for(const auto& [name, version]: pluginInfo)
    {
      spdlog::info("  {:{}} : {}", name, maxPluginNameLength, version);
    }
 
    on_done_loading_plugins();
    retval = false;
    break;
  }
  }
  return retval;
}

Here is the call graph for this function:

getInstance()

PluginManager::Ptr PluginManager::getInstance ( )

static

{ return pluginManager; }

Referenced by load(), loadPresentation(), ScroomInterfaceImpl::newAggregate(), ScroomInterfaceImpl::newPresentation(), on_done_loading_plugins(), on_open_activate(), on_presentation_added_to_view(), on_presentation_created(), and on_presentation_possibly_destroyed().

Here is the caller graph for this function:

getNewAggregateInterfaces()

const std::map< std::string, NewAggregateInterface::Ptr > & PluginManager::getNewAggregateInterfaces

(

)

{
  return newAggregateInterfaces;
}

getNewPresentationInterfaces()

const std::map< NewPresentationInterface::Ptr, std::string > & PluginManager::getNewPresentationInterfaces

(

)

{
  return newPresentationInterfaces;
}

getOpenInterfaces()

const std::map< OpenInterface::Ptr, std::string > & PluginManager::getOpenInterfaces

(

)

{ return openInterfaces; }

getOpenPresentationInterfaces()

const std::map< OpenPresentationInterface::Ptr, std::string > & PluginManager::getOpenPresentationInterfaces

(

)

{
  return openPresentationInterfaces;
}

getOpenTiledBitmapInterfaces()

const std::map< Scroom::TiledBitmap::OpenTiledBitmapInterface::Ptr, std::string > & PluginManager::getOpenTiledBitmapInterfaces

(

)

{
  return openTiledBitmapInterfaces;
}

getPresentationObservers()

const std::map< PresentationObserver::Ptr, std::string > & PluginManager::getPresentationObservers

(

)

{
  return presentationObservers;
}

getViewObservers()

const std::map< ViewObserver::Ptr, std::string > & PluginManager::getViewObservers

(

)

{ return viewObservers; }

registerNewAggregateInterface()

void PluginManager::registerNewAggregateInterface ( const std::string &  identifier, NewAggregateInterface::Ptr  newAggregateInterface  )

overridevirtual

Implements ScroomPluginInterface.

{
  newAggregateInterfaces[identifier] = newAggregateInterface;
}

registerNewPresentationInterface()

void PluginManager::registerNewPresentationInterface ( const std::string &  identifier, NewPresentationInterface::Ptr  newPresentationInterface  )

overridevirtual

Implements ScroomPluginInterface.

{
  newPresentationInterfaces[newPresentationInterface] = identifier;
 
  on_newPresentationInterfaces_update(newPresentationInterfaces);
}

Here is the call graph for this function:

registerOpenInterface()

void PluginManager::registerOpenInterface ( const std::string &  extension, OpenInterface::Ptr  openInterface  )

overridevirtual

Implements ScroomPluginInterface.

{
  openInterfaces[openInterface] = extension;
}

registerOpenPresentationInterface()

void PluginManager::registerOpenPresentationInterface ( const std::string &  extension, OpenPresentationInterface::Ptr  openPresentationInterface  )

overridevirtual

Implements ScroomPluginInterface.

{
  openPresentationInterfaces[openPresentationInterface] = extension;
}

registerOpenTiledBitmapInterface()

void PluginManager::registerOpenTiledBitmapInterface ( const std::string &  identifier, boost::shared_ptr< Scroom::TiledBitmap::OpenTiledBitmapInterface >  openTiledBitmapInterface  )

overridevirtual

Implements ScroomPluginInterface.

{
  openTiledBitmapInterfaces[openTiledBitmapInterface]                               = extension;
  openPresentationInterfaces[ToOpenPresentationInterface(openTiledBitmapInterface)] = extension;
}

Here is the call graph for this function:

registerPresentationObserver()

void PluginManager::registerPresentationObserver ( const std::string &  identifier, PresentationObserver::Ptr  observer  )

overridevirtual

Implements ScroomPluginInterface.

{
  presentationObservers[observer] = identifier;
}

registerViewObserver()

void PluginManager::registerViewObserver ( const std::string &  identifier, ViewObserver::Ptr  observer  )

overridevirtual

Implements ScroomPluginInterface.

{
  viewObservers[observer] = identifier;
 
  on_new_viewobserver(observer);
}

Here is the call graph for this function:

setStatusBarMessage()

void PluginManager::setStatusBarMessage ( const char *  message )

private

{
  // gtk_statusbar_pop(statusbar, status_context_id);
  // gtk_statusbar_push(statusbar, status_context_id, message);
}

Referenced by doWork().

Here is the caller graph for this function:

Member Data Documentation

currentDir

std::list<std::string>::iterator PluginManager::currentDir

private

Referenced by doWork().

currentFile

std::list<std::string>::iterator PluginManager::currentFile

private

Referenced by doWork().

devMode

bool PluginManager::devMode {false}

private

Referenced by addHook(), and doWork().

dirs

std::list<std::string> PluginManager::dirs

private

Referenced by doWork().

files

std::list<std::string> PluginManager::files

private

Referenced by doWork().

newAggregateInterfaces

std::map<std::string, NewAggregateInterface::Ptr> PluginManager::newAggregateInterfaces

private

Referenced by getNewAggregateInterfaces(), and registerNewAggregateInterface().

newPresentationInterfaces

std::map<NewPresentationInterface::Ptr, std::string> PluginManager::newPresentationInterfaces

private

Referenced by getNewPresentationInterfaces(), and registerNewPresentationInterface().

openInterfaces

std::map<OpenInterface::Ptr, std::string> PluginManager::openInterfaces

private

Referenced by getOpenInterfaces(), and registerOpenInterface().

openPresentationInterfaces

std::map<OpenPresentationInterface::Ptr, std::string> PluginManager::openPresentationInterfaces

private

Referenced by getOpenPresentationInterfaces(), registerOpenPresentationInterface(), and registerOpenTiledBitmapInterface().

openTiledBitmapInterfaces

std::map<Scroom::TiledBitmap::OpenTiledBitmapInterface::Ptr, std::string> PluginManager::openTiledBitmapInterfaces

private

Referenced by getOpenTiledBitmapInterfaces(), and registerOpenTiledBitmapInterface().

pluginInformationList

std::list<PluginInformation> PluginManager::pluginInformationList

private

Referenced by doWork().

presentationObservers

std::map<PresentationObserver::Ptr, std::string> PluginManager::presentationObservers

private

Referenced by getPresentationObservers(), and registerPresentationObserver().

state

PluginManagerState PluginManager::state {FINDING_DIRECTORIES}

private

Referenced by addHook(), and doWork().

viewObservers

std::map<ViewObserver::Ptr, std::string> PluginManager::viewObservers

private

Referenced by getViewObservers(), and registerViewObserver().

---

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

• gui/src/pluginmanager.hh
• gui/src/pluginmanager.cc