/cygdrive/d/src/svn/vrut/trunk/core/src/kernel.cpp

Go to the documentation of this file.

/*
 * $Id: kernel.cpp 579 2008-12-10 18:56:58Z kybav1 $
 *
 * Description  : One line description of file.
 * Author       : Vaclav Kyba <mail/Jabber: vaseo1@gmail.com>  <ICQ: 98576293>
 *
 * Purpose      :
 *     Long description of what the file is for.
 */


#include "kernel.h"
#include "flexilog.h"
#include "iomanager.h"
#include "rendermanager.h"
#include "manipmanager.h"
#include "generalmanager.h"
#include "guienvironment.h"

using namespace VRUT;

Kernel * Kernel::instance = (Kernel *)NULL;

Kernel * Kernel::Instantiate(MainWindow * window)
{
       if (!Kernel::instance)
              Kernel::instance = new Kernel(window);

       return Kernel::instance;
}


void Kernel::Release()
{
       SAFE_DELETE(instance);
}


Kernel::Kernel(MainWindow * window) : mainWindow(window), environment(), interpreter()
{
       initialized = exiting = false;
       mainThreadID = wxThread::GetCurrentId();
       ioManager = (IOManager *)NULL;
       renderManager = (RenderManager *)NULL;
       sceneManager = (SceneManager *)NULL;
       manipManager = (ManipulatorManager *)NULL;
       generalManager = (GeneralManager *)NULL;
       eventHandler = (EventHandler *)NULL;
       FlexiLog * log = dynamic_cast<FlexiLog *>(wxLog::GetActiveTarget());
       if (log)
              log->kernel = this;
}


Kernel::~Kernel()
{
       exiting = true;
       SAFE_DELETE(generalManager);
       SAFE_DELETE(renderManager);
       SAFE_DELETE(sceneManager);
       SAFE_DELETE(ioManager);
       SAFE_DELETE(manipManager);
       SAFE_DELETE(eventHandler);
       LOGVERBOSE(wxT("<Kernel>Deinitialized"));
}


Module * Kernel::GetModule(const MODULE_ID & id) const
{
       switch (id.GetServerID())
       {
       case MANIP_MANAGER:
              return manipManager->getModule(id);
       case IO_MANAGER:
              return ioManager->getModule(id);
       case RENDER_MANAGER:
              return renderManager->getModule(id);
       case GENERAL_MANAGER:
              return generalManager->getModule(id);
       default:
              LOGERROR(wxString::Format(wxT("<Kernel>Unknown module server type, module ID '%s'"), id.ToString().c_str()));
              return (Module *)NULL;
       }
}


void Kernel::ReleaseModule(const MODULE_ID & id)
{
       switch (id.GetServerID())
       {
       case MANIP_MANAGER:
              manipManager->releaseModule(id);
              break;
       case IO_MANAGER:
              ioManager->releaseModule(id);
              break;
       case RENDER_MANAGER:
              renderManager->releaseModule(id);
              break;
       case GENERAL_MANAGER:
              generalManager->releaseModule(id);
              break;
       default:
              LOGERROR(wxString::Format(wxT("<Kernel>Unknown module server type, module ID '%s'"), id.ToString().c_str()));
              break;
       }
}


std::vector<wxFileName> Kernel::GetAvailableModules() const
{
       std::vector<wxFileName> mods;
       if (IsInitialized())
       {
              std::vector<wxFileName> mods1 = ioManager->GetAvailableModules();
              mods.insert(mods.end(), mods1.begin(), mods1.end());
              mods1 = renderManager->GetAvailableModules();
              mods.insert(mods.end(), mods1.begin(), mods1.end());
              mods1 = manipManager->GetAvailableModules();
              mods.insert(mods.end(), mods1.begin(), mods1.end());
              mods1 = generalManager->GetAvailableModules();
              mods.insert(mods.end(), mods1.begin(), mods1.end());
       }
       else
              LOGERROR(wxT("<Kernel>Kernel not initialized"));

       return mods;
}


bool Kernel::Initialize()
{
       eventHandler = new EventHandler();
       ioManager = new IOManager();
       renderManager = new RenderManager();
       sceneManager = new SceneManager();
       manipManager = new ManipulatorManager();
       generalManager = new GeneralManager();
       GUIEnvironment * guiEnv = new GUIEnvironment(mainWindow);
       if (eventHandler && ioManager && renderManager && sceneManager && manipManager && generalManager)
       {
              wxString paramsNbName = wxT("Parameters");
              guiEnv->SetName(paramsNbName);
              mainWindow->GetAUIManager()->AddPane(guiEnv, wxAuiPaneInfo().
                      DefaultPane().Name(paramsNbName).
                      Caption(paramsNbName).Top().
                      PinButton().BestSize(480, 320));
              mainWindow->GetAUIManager()->Update();

              initialized = true;
              LOGVERBOSE(wxT("<Kernel>Initialized"));
              return true;
       }
       return false;
}


bool Kernel::GetModules(std::vector<std::pair<Module *, MODULE_INSTANCE_ID> > * moduleList, const wxString & moduleName, MODULE_INSTANCE_ID instanceID)
{
       bool ret = false;
       if (IsInitialized())
       {
              ret |= ioManager->GetModules(moduleList, moduleName, instanceID);
              ret |= renderManager->GetModules(moduleList, moduleName, instanceID);
              ret |= manipManager->GetModules(moduleList, moduleName, instanceID);
              ret |= generalManager->GetModules(moduleList, moduleName, instanceID);
       }
       else
              LOGERROR(wxT("<Kernel>Kernel not initialized"));

       return ret;
}


void Kernel::PreferModule(const wxString & libName)
{
       preferedModules.push_front(CloneWxString(libName));
       for (ModuleNamesList::iterator nameIt = forbiddenModules.begin();
              nameIt != forbiddenModules.end(); )
       {
              if (nameIt->IsSameAs(libName, false))
                     nameIt = forbiddenModules.erase(nameIt);
              else
                     nameIt++;
       }
}


void Kernel::ForbidModule(const wxString & libName)
{
       forbiddenModules.push_front(CloneWxString(libName));
       for (ModuleNamesList::iterator nameIt = preferedModules.begin();
              nameIt != preferedModules.end(); )
       {
              if (nameIt->IsSameAs(libName, false))
                     nameIt = preferedModules.erase(nameIt);
              else
                     nameIt++;
       }
}


bool Kernel::IsForbidden(const wxString & libName) const
{
       for (ModuleNamesList::const_iterator nameIt = forbiddenModules.begin();
              nameIt != forbiddenModules.end(); nameIt++)
              if (nameIt->IsSameAs(libName, false) || nameIt->IsSameAs(wxT("lib") + libName, false))
                     return true;
       return false;
}

---