root/juggler/branches/2.2/modules/gadgeteer/gadget/InputManager.cpp

/*************** <auto-copyright.pl BEGIN do not edit this line> **************
 *
 * VR Juggler is (C) Copyright 1998-2007 by Iowa State University
 *
 * Original Authors:
 *   Allen Bierbaum, Christopher Just,
 *   Patrick Hartling, Kevin Meinert,
 *   Carolina Cruz-Neira, Albert Baker
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 *************** <auto-copyright.pl END do not edit this line> ***************/

#include <gadget/gadgetConfig.h>

#include <iomanip>
#include <sstream>
#include <boost/filesystem/path.hpp>
#include <boost/filesystem/exception.hpp>
#include <boost/filesystem/operations.hpp>

#include <vpr/vpr.h>
#include <vpr/System.h>
#include <vpr/DynLoad/LibraryFinder.h>
#include <vpr/DynLoad/LibraryLoader.h>
#include <vpr/Util/FileUtils.h>

#include <jccl/Config/ConfigElement.h>
#include <jccl/RTRC/ConfigManager.h>

#include <cluster/ClusterManager.h>
#include <gadget/InputLogger.h>
#include <gadget/ProxyFactory.h>
#include <gadget/Type/BaseTypeFactory.h>
#include <gadget/Type/DeviceFactory.h>
#include <gadget/Type/Proxy.h>
#include <gadget/Type/DeviceInterface.h>
#include <gadget/Util/Debug.h>
#include <gadget/Util/PluginVersionException.h>
#include <gadget/Util/PathHelpers.h>
#include <gadget/gadgetParam.h>

#include <gadget/InputManager.h>


namespace fs = boost::filesystem;

namespace gadget
{

   vprSingletonImp( InputManager );    // Implementation of singleton

// Local helpers
static bool recognizeProxyAlias(jccl::ConfigElementPtr element);

/**
 * InputManager Constructor
 */
InputManager::InputManager()
{
}

/**
 * InputManager Destructor
 */
InputManager::~InputManager()
{
   shutdown();
}

void InputManager::shutdown()
{
   typedef tDevTableType::iterator dev_iter_t;

   // Stop and delete all devices.
   for ( dev_iter_t a = mDevTable.begin(); a != mDevTable.end(); ++a )
   {
      if ((*a).second != NULL)
      {
         (*a).second->stopSampling();
         delete (*a).second;
      }
   }

   mDevTable.clear();

   // Delete all the proxies
   typedef std::map<std::string, Proxy*>::iterator proxy_iter_t;
   for ( proxy_iter_t j = mProxyTable.begin(); j != mProxyTable.end(); ++j )
   {
      delete (*j).second;
   }

   mProxyTable.clear();
}

/**
 * This struct implements a callable object (a functor, basically).  An
 * instance can be passed in where a boost::function1<bool, void*> is expected.
 * In gadget::InputManager::configAdd(), instances are used to handle version
 * checking of device driver plug-ins via vpr::LibraryLoader.
 */
struct VersionCheckCallable
{
   VersionCheckCallable()
   {
   }

   /**
    * This will be invoked as a callback by methods of vpr::LibraryLoader.
    *
    * @param func A function pointer for the entry point in a dynamically
    *             loaded device driver.  This must be cast to the correct
    *             signature before being invoked.
    */
   bool operator()(void* func)
   {
      vpr::Uint32 (*version_func)();
      version_func = (vpr::Uint32 (*)()) func;

      // Call the entry point function, which, in this case, returns the
      // version of Gadgeteer against which the driver was compiled.
      const vpr::Uint32 driver_gadget_ver = (*version_func)();

      if ( driver_gadget_ver != mGadgetVersion )
      {
         std::ostringstream msg_stream;
         msg_stream << "Gadgeteer version mismatch!\n"
                    << "Driver was compiled against Gadgeteer version "
                    << driver_gadget_ver << ",\n"
                    << "but this is Gadgeteer version " << mGadgetVersion
                    << std::endl;
         throw gadget::PluginVersionException(msg_stream.str(), VPR_LOCATION);
      }

      return true;
   }

   static const vpr::Uint32 mGadgetVersion;
};

const vpr::Uint32 VersionCheckCallable::mGadgetVersion(__GADGET_version);

/**
 * This struct implements a callable object (a functor, basically).  An
 * instance can be passed in where a boost::function1<bool, void*> is expected.
 * In gadget::InputManager::configAdd(), instances are used to handle dynamic
 * loading of device drivers via vpr::LibraryLoader.
 */
struct DriverInitCallable
{
   DriverInitCallable(gadget::InputManager* inputMgr) : mgr(inputMgr)
   {
   }

   /**
    * This will be invoked as a callback by methods of vpr::LibraryLoader.
    *
    * @param func A function pointer for the entry point in a dynamically
    *             loaded device driver.  This must be cast to the correct
    *             signature before being invoked.
    */
   bool operator()(void* func)
   {
      void (*init_func)(InputManager*);

      // Cast the entry point function to the correct signature so that we can
      // call it.  All dynamically loaded drivers must have an entry point
      // function that takes a pointer to a gadget::InputManager instance and
      // returns nothing.
      init_func = (void (*)(InputManager*)) func;

      // Call the entry point function.
      (*init_func)(mgr);

      return true;
   }

   gadget::InputManager* mgr;
};

/** Adds the given config element to the input system. */
bool InputManager::configAdd(jccl::ConfigElementPtr element)
{
vpr::DebugOutputGuard dbg_output(gadgetDBG_INPUT_MGR, vprDBG_STATE_LVL,
                              std::string("Input Manager: Adding pending config element.\n"),
                              std::string("...done adding element.\n"));

   vprASSERT(configCanHandle(element));

   bool ret_val = false;      // Flag to return success

   if (cluster::ClusterManager::instance()->recognizeRemoteDeviceConfig(element))
   {
      vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CONFIG_LVL)
         << "InputManager can not handle remote devices, we must use Remote Input Manager."
         << vprDEBUG_FLUSH;
      ret_val = false;
   }
   else if (element->getID() == std::string( "input_window" ))
   {
      // Get the KeyboardMouseDevice that this window should send events to.
      std::string keyboard_mouse_device_name =
         element->getProperty<std::string>( "keyboard_mouse_device_name" );

      // Get the KeyboardMouseDevice ConfigElement.
      // NOTE: We can assume that this config element is in the active
      //       list since the DependancyManager requires that all
      //       ConfigElementPointers be resolved first.
      jccl::ConfigManager* cfg_mgr = jccl::ConfigManager::instance();
      cfg_mgr->lockActive();
      jccl::ConfigElementPtr keyboard_mouse_element
         = cfg_mgr->getActiveConfig()->get( keyboard_mouse_device_name );
      cfg_mgr->unlockActive();

      // If a KeyboardMouseDevice with this name exists and is remote, we do not want
      // to start this device and open a window since this KeyboardMouseDevice will
      // be invalid.
      if (NULL != keyboard_mouse_element.get() &&
         cluster::ClusterManager::instance()->recognizeRemoteDeviceConfig( keyboard_mouse_element ))
      {
         vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CONFIG_LVL)
            << "InputManager::configAdd() InputWindow not being opened "
            << "since it points to a remote KeyboardMouseDevice."
            << vprDEBUG_FLUSH;
         ret_val = true;
      }
      else
      {
         ret_val = configureDevice( element );
      }
   }
   else if(DeviceFactory::instance()->recognizeDevice(element))
   {
      ret_val = configureDevice(element);
   }
   else if(ProxyFactory::instance()->recognizeProxy(element))
   {
      ret_val = configureProxy(element);
   }
   else if(recognizeProxyAlias(element))
   {
      ret_val = configureProxyAlias(element);
   }
   else if(element->getID() == std::string("display_system"))
   {
      // XXX: Put signal here to tell draw manager to lookup new stuff
      mDisplaySystemElement = element;     // Keep track of the display system element
      ret_val = true;
   }
   else if(element->getID() == std::string("gadget_logger"))
   {
      ret_val = configureInputLogger(element);
   }
   else if(element->getID() == std::string("input_manager"))
   {
      ret_val = configureInputManager(element);
   }

   //DumpStatus();                      // Dump the status
   {
      vpr::DebugOutputGuard dbg_output(gadgetDBG_INPUT_MGR, vprDBG_STATE_LVL,
                              std::string("New Input Manager state:\n"),
                              std::string("-- end state -- \n"));
      vprDEBUG(gadgetDBG_INPUT_MGR,vprDBG_VERB_LVL) << (*this) << vprDEBUG_FLUSH;
   }

   if(ret_val)
   {
      resetAllDevicesAndProxies();
      updateAllDevices();                             // Update all the input data
      updateAllProxies();                             // Update all the input data
      BaseDeviceInterface::refreshAllInterfaces();    // Refresh all the device interface handles
      vprDEBUG(gadgetDBG_INPUT_MGR,vprDBG_STATE_LVL)
         << "Updated all devices" << std::endl << vprDEBUG_FLUSH;
   }

   return ret_val;         // Return the success flag if we added at all
}


/**
 * Removes the element from the current configuration.
 */
bool InputManager::configRemove(jccl::ConfigElementPtr element)
{
vpr::DebugOutputGuard dbg_output(gadgetDBG_INPUT_MGR, vprDBG_STATE_LVL,
                              std::string("InputManager: Removing config...\n"),
                              std::string("done removing config.\n"));
   vprASSERT(configCanHandle(element));

   bool ret_val = false;      // Flag to return success

   // NEED TO FIX!!!!
   if (cluster::ClusterManager::instance()->recognizeRemoteDeviceConfig(element))
   {
      vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CONFIG_LVL)
         << "InputManager can not handle remote devices, we must use Remote Input Manager."
         << vprDEBUG_FLUSH;
      ret_val = false;
   }
   else if(DeviceFactory::instance()->recognizeDevice(element))
   {
      ret_val = removeDevice(element);
   }
   else if(recognizeProxyAlias(element))
   {
      ret_val = removeProxyAlias(element);
   }
   else if(ProxyFactory::instance()->recognizeProxy(element))
   {
      ret_val = removeProxy(element);
   }
   else if(element->getID() == std::string("display_system"))
   {
      mDisplaySystemElement.reset();  // Keep track of the display system element
      ret_val = true;                 // We successfully configured.
                                       // This tell processPending to remove it to the active config
   }
   else
   {
      ret_val = false;
   }

   if(ret_val)
   {
      resetAllDevicesAndProxies();
      updateAllDevices();                             // Update all the input data
      updateAllProxies();                             // Update all the input data
      BaseDeviceInterface::refreshAllInterfaces();      // Refresh all the device interface handles
      vprDEBUG(gadgetDBG_INPUT_MGR,vprDBG_VERB_LVL)
         << "InputManager::configRemove(): Updated all data" << std::endl
         << vprDEBUG_FLUSH;
   }

   return ret_val;         // Return the success flag if we added at all
}


// Return true if:
//  It is recognized device, proxy, or alias.
bool InputManager::configCanHandle(jccl::ConfigElementPtr element)
{           // NEED TO FIX!!!!
   return ( (DeviceFactory::instance()->recognizeDevice(element) &&
             !cluster::ClusterManager::instance()->recognizeRemoteDeviceConfig(element)) ||
            ProxyFactory::instance()->recognizeProxy(element) ||
            recognizeProxyAlias(element) ||
            (element->getID() == std::string("display_system")) ||
            (element->getID() == std::string("input_manager")) ||
            (element->getID() == std::string("gadget_logger"))
          );
}

jccl::ConfigElementPtr InputManager::getDisplaySystemElement()
{
   if ( mDisplaySystemElement.get() == NULL )
   {
      jccl::ConfigManager* cfg_mgr = jccl::ConfigManager::instance();

      cfg_mgr->lockActive();
      {
         std::vector<jccl::ConfigElementPtr>::iterator i;
         for( i = cfg_mgr->getActiveBegin(); i != cfg_mgr->getActiveEnd(); ++i)
         {
            if((*i)->getID() == std::string("display_system"))
            {
               mDisplaySystemElement = *i;
               break;         // This guarantees that we get the first displaySystem element.
            }
         }
      }
      cfg_mgr->unlockActive();
      //vprASSERT(mDisplaySystemElement.get() != NULL && "No Display Manager element found!");
   }
   return mDisplaySystemElement;
}

/**
 * Check if the device factory or proxy factory can handle the element.
 */
bool InputManager::configureDevice(jccl::ConfigElementPtr element)
{
   bool ret_val;
   std::string dev_name = element->getFullName();

   vpr::DebugOutputGuard dbg_output(gadgetDBG_INPUT_MGR, vprDBG_STATE_LVL,
                                 std::string("InputManager::configureDevice: device[") + dev_name + std::string("]\n"),
                                 std::string("done configuring device\n"));

   Input* new_device;
   new_device = DeviceFactory::instance()->loadDevice(element);

   if ((new_device != NULL) && (new_device->startSampling()))
   {
      addDevice(new_device);
      ret_val = true;
      vprDEBUG(gadgetDBG_INPUT_MGR,vprDBG_STATE_LVL)
         << "   Successfully added device: " << dev_name << std::endl
         << vprDEBUG_FLUSH;
   }
   else
   {
      vprDEBUG(vprDBG_ERROR,vprDBG_CRITICAL_LVL) << clrOutNORM(clrRED,"ERROR:")
         << "New device " << clrSetBOLD(clrCYAN) << dev_name << clrRESET
         << " failed to start.  Deleting instance" << std::endl
         << vprDEBUG_FLUSH;
      if ( NULL != new_device )
      {
         delete new_device;
      }

      ret_val = false;
   }

   return ret_val;
}

/**
 * Check if the device factory or proxy factory can handle the element.
 */
bool InputManager::configureProxy(jccl::ConfigElementPtr element)
{
   std::string proxy_name = element->getFullName();

vpr::DebugOutputGuard dbg_output(gadgetDBG_INPUT_MGR, vprDBG_STATE_LVL,
                                 std::string("gadget::InputManager::configureProxy: Named: ") + proxy_name + std::string("\n"),
                                 std::string("done configuring proxy\n"));

   Proxy* new_proxy;

   // Tell the factory to load the proxy
   // NOTE: The config for the proxy registers it with the input manager
   new_proxy = ProxyFactory::instance()->loadProxy(element);

   // Check for success
   if(NULL == new_proxy)
   {
      vprDEBUG(vprDBG_ERROR,vprDBG_CRITICAL_LVL)
         << clrOutNORM(clrRED,"ERROR:")
         << " gadget::InputManager::configureProxy: Proxy construction failed:"
         << proxy_name << std::endl << vprDEBUG_FLUSH;
      return false;
   }
   vprASSERT(proxy_name == new_proxy->getName());

   // -- Add to proxy table
   if(false == addProxy(new_proxy))
   {
      return false;
   }

   return true;
}


/**
 * Removes the device associated with the given element.
 */
bool InputManager::removeDevice(jccl::ConfigElementPtr element)
{
   return removeDevice(element->getFullName());
}


/**
 * Dump the current Status of the InputManager, listing all
 * the devices, proxies and internal settings
 */
GADGET_IMPLEMENT(std::ostream&) operator<<(std::ostream& out, InputManager& iMgr)
{
   out << "\n========== Input Manager Status ==========" << std::endl;
   out << "Device List:\n";

   // Dump DEVICES
   for ( InputManager::tDevTableType::iterator i = iMgr.mDevTable.begin();
         i != iMgr.mDevTable.end();
         ++i)
   {
      if ((*i).second != NULL)
      {
         out << "    '" << i->first << "' (type: "
             << typeid(*(i->second)).name() << ")" << std::endl;
      }
   }

   out << "\nProxy List:\n";
   for (std::map<std::string, Proxy*>::iterator i_p = iMgr.mProxyTable.begin();
        i_p != iMgr.mProxyTable.end();
        ++i_p)
   {
      out << "    '" << (*i_p).second->getName() << "' refers to ";
      if(NULL != ((*i_p).second->getProxiedInputDevice()))
      {
         out << ((*i_p).second->getProxiedInputDevice())->getInstanceName();
      }
      else
      {
         out << "None (internal dummy)";
      }
      out << std::endl;
   }

   out << std::endl;

   // Dump Alias list
   out << "Alias List:" << std::endl;
   for ( std::map<std::string, std::string>::iterator cur_alias = iMgr.mProxyAliases.begin();
         cur_alias != iMgr.mProxyAliases.end();
         ++cur_alias )
   {
      out << "    '" << (*cur_alias).first.c_str() << "' (alias for "
          << (*cur_alias).second << ")" << std::endl;
   }

   out << "========== InputManager Status ==========" << std::endl;
   return out;
}

/**
 * Add a device to the InputManager, returns the index
 * where the device was placed
 */
bool InputManager::addDevice(Input* devPtr)
{
   mDevTable[devPtr->getInstanceName()] = devPtr;

   refreshAllProxies();

   return true;
}

/**
 *   Add a remote device to the InputManager that is being updated by a RemoteInputManager.
 */
bool InputManager::addRemoteDevice(Input* devPtr, const std::string& device_name)
{
   mDevTable[device_name] = devPtr;

   refreshAllProxies();

   return true;
}

void InputManager::resetAllDevicesAndProxies()
{
   typedef std::map<std::string, Proxy*>::iterator iter_type;
   for ( iter_type i_p = mProxyTable.begin(); i_p != mProxyTable.end(); ++i_p )
   {
      (*i_p).second->resetData();
   }

   // all DEVICES
   for ( tDevTableType::iterator i = mDevTable.begin();
         i != mDevTable.end();
         ++i )
   {
      if ( (*i).second != NULL )
      {
         (*i).second->resetData();
      }
   }
}

void InputManager::updateAllProxies()
{
   // Update proxies MIGHT NOT NEED
   for (std::map<std::string, Proxy*>::iterator i_p = mProxyTable.begin();
        i_p != mProxyTable.end();
        ++i_p)
   {
      (*i_p).second->updateDataIfNeeded();
   }
}


/**
 * Call UpdateData() on all the devices and transform proxies.
 */
void InputManager::updateAllDevices()
{
   for (tDevTableType::iterator i = mDevTable.begin(); i != mDevTable.end(); ++i)      // all DEVICES
   {
      if ((*i).second != NULL)
      {
         i->second->updateDataIfNeeded();
      }
   }

   // Update Logger - Done here so that device can be "rewritten" by logger
   //                 before rim or proxies get their hands on the data
   if(mInputLogger.get() != NULL)
   {
      mInputLogger->process();
   }
}

/**
 * Return a Input ptr to a deviced named
 *
 * @returns - NULL if not found.
 */
Input* InputManager::getDevice(const std::string& deviceName)
{
   // Look up in Input Manager
   tDevTableType::iterator ret_dev;
   ret_dev = mDevTable.find(deviceName);
   if(ret_dev != mDevTable.end())
   {
      return ret_dev->second;
   }
   return NULL;
}

DeviceFactory* InputManager::getDeviceFactory()
{
   return gadget::DeviceFactory::instance();
}

/**
 * Remove the device that is pointed to by devPtr.
 */
bool InputManager::removeDevice(const Input* devPtr)
{
   for (tDevTableType::iterator i = mDevTable.begin(); i != mDevTable.end(); ++i)      // all DEVICES
   {
      if ((*i).second == devPtr)
      {
         return removeDevice((*i).first);
      }
   }

   return false;
}


/**
 * InputManager remove instName from the InputManager,
 * currently stupefies all the proxies connected to it.
 */
bool InputManager::removeDevice(const std::string& instName)
{
   tDevTableType::iterator dev_found;
   dev_found = mDevTable.find(instName);
   if(dev_found == mDevTable.end())
   {
      return false;
   }

   Input* dev_ptr = dev_found->second;

   if(NULL == dev_ptr)
   {
      return false;
   }

   // Find any proxies connected to the device
   // Stupefy any proxies connected to device
   // NOTE: Could just remove it and then refresh all, but this is a little safer
   //       since we explicitly stupefy the one that we don't want anymore
   for ( std::map<std::string, Proxy*>::iterator i_p = mProxyTable.begin();
        i_p != mProxyTable.end();
        ++i_p )
   {
      if((*i_p).second->getProxiedInputDevice() == dev_ptr)
      {
         (*i_p).second->stupefy(true);
      }
   }

   // stop the device, delete it, set pointer to NULL
   dev_ptr->stopSampling();
   delete dev_ptr;
   mDevTable.erase(dev_found);

   // Refresh the proxies
   refreshAllProxies();

   return true;
}

bool InputManager::configureInputManager(jccl::ConfigElementPtr element)
{
   bool have_bad_elt = (element->getID() != std::string("input_manager"));
   vprASSERT(!have_bad_elt);
   if(have_bad_elt)
   {
      return false;
   }

   bool ret_val = false;

   vpr::DebugOutputGuard dbg_output(gadgetDBG_INPUT_MGR, vprDBG_STATE_LVL,
                                    std::string("Handling input_manager element:\n"),
                                    std::string("-- end state -- \n"));

   // Keep this up to date with the version of the element definition we're
   // expecting to handle.
   const unsigned int cur_version(2);

   // If the element version is less than cur_version, we will not try to
   // proceed.  Instead, we'll print an error message and return false so
   // that the Config Manager knows this element wasn't consumed.
   if ( element->getVersion() < cur_version )
   {
      vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL)
         << clrOutBOLD(clrRED, "ERROR")
         << ": [gadget::InputManager::configureInputManager()] Element named '"
         << element->getName() << "'" << std::endl << vprDEBUG_FLUSH;
      vprDEBUG_NEXT(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL)
         << "is version " << element->getVersion()
         << ", but we require at least version " << cur_version
         << std::endl << vprDEBUG_FLUSH;
      vprDEBUG_NEXT(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL)
         << "Ignoring this element and moving on." << std::endl
         << vprDEBUG_FLUSH;
      ret_val = false;
   }
   // We got the right version of the config element and can proceed.
   else
   {
      const std::string driver_path_prop_name("driver_path");
      const int path_count(element->getNum(driver_path_prop_name));
      std::vector<fs::path> search_path(path_count);

      for ( unsigned int i = 0; i < search_path.size(); ++i )
      {
         std::string temp_str =
            vpr::replaceEnvVars(element->getProperty<std::string>(driver_path_prop_name, i));

         try
         {
            search_path[i] = fs::path(temp_str, fs::native);
         }
         catch(fs::filesystem_error& fsEx)
         {
            vprDEBUG(vprDBG_ERROR, vprDBG_CRITICAL_LVL)
               << clrOutNORM(clrRED, "ERROR")
               << ": [gadget::InputManager::configureInputManager()] File "
               << "system exception caught while converting\n"
               << vprDEBUG_FLUSH;
            vprDEBUG_NEXT(vprDBG_ERROR, vprDBG_CRITICAL_LVL)
               << "'" << temp_str << "'\n" << vprDEBUG_FLUSH;
            vprDEBUG_NEXT(vprDBG_ERROR, vprDBG_CRITICAL_LVL)
               << "to a Boost.Filesystem path.\n" << vprDEBUG_FLUSH;
            vprDEBUG_NEXT(vprDBG_ERROR, vprDBG_CRITICAL_LVL)
               << fsEx.what() << std::endl << vprDEBUG_FLUSH;
         }
      }

      // Append a default driver search path to search_path.
      const fs::path default_search_dir =
         gadget::getDefaultPluginRoot() / std::string("drivers");

      vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_VERB_LVL)
         << "[gadget::InputManager::configureInputManager()] Appending "
         << "default search path '"
         << default_search_dir.native_directory_string() << "'\n"
         << vprDEBUG_FLUSH;

#if defined(GADGET_DEBUG)
      // For a debug build, search in the debug subdirectory of
      // default_search_dir before looking in default_search_dir.
      search_path.push_back(default_search_dir / std::string("debug"));
#endif

      search_path.push_back(default_search_dir);

      // --- Load device driver dsos -- //
      // - Load individual drivers
      const std::string driver_prop_name("driver");
      const std::string get_version_func("getGadgeteerVersion");
      const std::string driver_init_func("initDevice");

      int driver_count = element->getNum(driver_prop_name);
      std::string driver_dso_name;

      for ( int i = 0; i < driver_count; ++i )
      {
         driver_dso_name =
            element->getProperty<std::string>(driver_prop_name, i);

         if ( ! driver_dso_name.empty() )
         {
            vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_STATE_LVL)
               << "[gadget::InputManager::configureInputManager()] Loading "
               << "driver DSO '" << driver_dso_name << "'\n" << vprDEBUG_FLUSH;

            vpr::LibraryPtr dso = vpr::LibraryLoader::findDSO(driver_dso_name,
                                                              search_path);

            if ( dso.get() != NULL )
            {
               try
               {
                  VersionCheckCallable version_functor;
                  vpr::LibraryLoader::callEntryPoint(dso, get_version_func,
                                                     version_functor);

                  DriverInitCallable init_functor(this);
                  vpr::LibraryLoader::callEntryPoint(dso, driver_init_func,
                                                     init_functor);

                  mLoadedDrivers.push_back(dso);
               }
               catch (gadget::PluginVersionException& ex)
               {
                  vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL)
                     << clrOutBOLD(clrRED, "ERROR")
                     << ": Version mismatch while loading driver DSO '"
                     << driver_dso_name << "'\n" << vprDEBUG_FLUSH;
                  vprDEBUG_NEXT(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL)
                     << "This driver will not be usable.\n"
                     << vprDEBUG_FLUSH;
                  vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL)
                     << ex.getExtendedDescription() << std::endl
                     << vprDEBUG_FLUSH;
               }
               catch (vpr::Exception& ex)
               {
                  vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL)
                     << clrOutBOLD(clrRED, "ERROR")
                     << ": Failed to load driver DSO '"
                     << driver_dso_name << "'\n" << vprDEBUG_FLUSH;
                  vprDEBUG_NEXT(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL)
                     << "This driver will not be usable.\n" << vprDEBUG_FLUSH;
                  vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL)
                     << ex.what() << std::endl << vprDEBUG_FLUSH;