VRUT::Kernel Class Reference

Application kernel - singleton. More...

#include <kernel.h>

List of all members.

Public Types

typedef std::deque< wxString > ModuleNamesList

Public Member Functions

void Release ()
 Release singleton instance.
 ~Kernel ()
 Class destructor.
bool IsInitialized () const
 Is kernel initialized?
bool IsExiting () const
 Is kernel and app exiting.
wxThreadIdType GetMainThreadID () const
 Get main thread ID.
MainWindow * GetMainWindow () const
 Get main window.
EventHandler * GetMessageSink () const
 Get event handler and main message sink.
Module * GetModule (const MODULE_ID &id) const
 Get module instance with unique module ID.
void ReleaseModule (const MODULE_ID &id)
 Release module instance with unique module ID.
std::vector< wxFileName > GetAvailableModules () const
 Get filenames of all available (instantiated or not) modules.
bool Initialize ()
 Initialize servers and search for available modules.
bool GetModules (std::vector< std::pair< Module *, MODULE_INSTANCE_ID > > *moduleList, const wxString &moduleName, MODULE_INSTANCE_ID instanceID=MODULE_INSTANCE_ID_NONE)
void PreferModule (const wxString &libName)
const ModuleNamesList * GetPreferedModules () const
 Get prefered modules list.
void ForbidModule (const wxString &libName)
 Add module's dynamic library name to forbidden modules list.
bool IsForbidden (const wxString &libName) const
 Is module forbidden?

Static Public Member Functions

static Kernel * Instantiate (MainWindow *window)
 Create and get singleton instance.
static Kernel * Instance ()
 Get singleton instance.

Public Attributes

Environment environment
 Environment with parameter management.
Interpreter interpreter
 Command interpreter.
IOManager * ioManager
 Input/output server.
RenderManager * renderManager
 Render server.
ManipulatorManager * manipManager
 Manipulator manager.
SceneManager * sceneManager
 Scene manager.
GeneralManager * generalManager
 General manager.

Protected Member Functions

 Kernel (MainWindow *window)
 Class constructor - disabled.
 Kernel (const Kernel &)
 Copy constructor - disabled.

Protected Attributes

MainWindow * mainWindow
 Application's main window.
EventHandler * eventHandler
 Event handler.
wxThreadIdType mainThreadID
 Main thread ID.
bool initialized
 Is kernel initialized?
bool exiting
 Is kernel releasing data and exiting?
ModuleNamesList preferedModules
 List of prefered modules to pick when loading.
ModuleNamesList forbiddenModules
 List of forbidden modules.

Static Protected Attributes

static Kernel * instance = (Kernel *)NULL
 Singleton instance.

Detailed Description

Application kernel - singleton.

Definition at line 32 of file kernel.h.

Member Typedef Documentation

typedef std::deque<wxString> VRUT::Kernel::ModuleNamesList

Definition at line 35 of file kernel.h.

Constructor & Destructor Documentation

Kernel::Kernel ( MainWindow *  window  )  [protected]

Class constructor - disabled.

Definition at line 39 of file kernel.cpp.

00039                                   : mainWindow(window), environment(), interpreter()
00040 {
00041        initialized = exiting = false;
00042        mainThreadID = wxThread::GetCurrentId();
00043        ioManager = (IOManager *)NULL;
00044        renderManager = (RenderManager *)NULL;
00045        sceneManager = (SceneManager *)NULL;
00046        manipManager = (ManipulatorManager *)NULL;
00047        generalManager = (GeneralManager *)NULL;
00048        eventHandler = (EventHandler *)NULL;
00049        FlexiLog * log = dynamic_cast<FlexiLog *>(wxLog::GetActiveTarget());
00050        if (log)
00051               log->kernel = this;
00052 }

VRUT::Kernel::Kernel ( const Kernel &   )  [protected]

Copy constructor - disabled.

Kernel::~Kernel (  ) 

Class destructor.

Definition at line 55 of file kernel.cpp.

00056 {
00057        exiting = true;
00058        SAFE_DELETE(generalManager);
00059        SAFE_DELETE(renderManager);
00060        SAFE_DELETE(sceneManager);
00061        SAFE_DELETE(ioManager);
00062        SAFE_DELETE(manipManager);
00063        SAFE_DELETE(eventHandler);
00064        LOGVERBOSE(wxT("<Kernel>Deinitialized"));
00065 }

Member Function Documentation

Kernel * Kernel::Instantiate ( MainWindow *  window  )  [static]

Create and get singleton instance.

Definition at line 24 of file kernel.cpp.

00025 {
00026        if (!Kernel::instance)
00027               Kernel::instance = new Kernel(window);
00028 
00029        return Kernel::instance;
00030 }

static Kernel* VRUT::Kernel::Instance (  )  [inline, static]

Get singleton instance.

Definition at line 79 of file kernel.h.

00079 { return instance; }

void Kernel::Release (  ) 

Release singleton instance.

Definition at line 33 of file kernel.cpp.

00034 {
00035        SAFE_DELETE(instance);
00036 }

bool VRUT::Kernel::IsInitialized (  )  const [inline]

Is kernel initialized?

Definition at line 86 of file kernel.h.

00087               {
00088                      return initialized;
00089               }

bool VRUT::Kernel::IsExiting (  )  const [inline]

Is kernel and app exiting.

Definition at line 91 of file kernel.h.

00092               {
00093                      return exiting;
00094               }

wxThreadIdType VRUT::Kernel::GetMainThreadID (  )  const [inline]

Get main thread ID.

Definition at line 96 of file kernel.h.

00097               {
00098                      return mainThreadID;
00099               }

MainWindow* VRUT::Kernel::GetMainWindow (  )  const [inline]

Get main window.

Definition at line 101 of file kernel.h.

00102               {
00103                      return mainWindow;
00104               }

EventHandler* VRUT::Kernel::GetMessageSink (  )  const [inline]

Get event handler and main message sink.

Definition at line 106 of file kernel.h.

00107               {
00108                      return eventHandler;
00109               }

Module * Kernel::GetModule ( const MODULE_ID &  id  )  const

Get module instance with unique module ID.

Definition at line 68 of file kernel.cpp.

00069 {
00070        switch (id.GetServerID())
00071        {
00072        case MANIP_MANAGER:
00073               return manipManager->getModule(id);
00074        case IO_MANAGER:
00075               return ioManager->getModule(id);
00076        case RENDER_MANAGER:
00077               return renderManager->getModule(id);
00078        case GENERAL_MANAGER:
00079               return generalManager->getModule(id);
00080        default:
00081               LOGERROR(wxString::Format(wxT("<Kernel>Unknown module server type, module ID '%s'"), id.ToString().c_str()));
00082               return (Module *)NULL;
00083        }
00084 }

void Kernel::ReleaseModule ( const MODULE_ID &  id  ) 

Release module instance with unique module ID.

Definition at line 87 of file kernel.cpp.

00088 {
00089        switch (id.GetServerID())
00090        {
00091        case MANIP_MANAGER:
00092               manipManager->releaseModule(id);
00093               break;
00094        case IO_MANAGER:
00095               ioManager->releaseModule(id);
00096               break;
00097        case RENDER_MANAGER:
00098               renderManager->releaseModule(id);
00099               break;
00100        case GENERAL_MANAGER:
00101               generalManager->releaseModule(id);
00102               break;
00103        default:
00104               LOGERROR(wxString::Format(wxT("<Kernel>Unknown module server type, module ID '%s'"), id.ToString().c_str()));
00105               break;
00106        }
00107 }

std::vector< wxFileName > Kernel::GetAvailableModules (  )  const

Get filenames of all available (instantiated or not) modules.

Definition at line 110 of file kernel.cpp.

00111 {
00112        std::vector<wxFileName> mods;
00113        if (IsInitialized())
00114        {
00115               std::vector<wxFileName> mods1 = ioManager->GetAvailableModules();
00116               mods.insert(mods.end(), mods1.begin(), mods1.end());
00117               mods1 = renderManager->GetAvailableModules();
00118               mods.insert(mods.end(), mods1.begin(), mods1.end());
00119               mods1 = manipManager->GetAvailableModules();
00120               mods.insert(mods.end(), mods1.begin(), mods1.end());
00121               mods1 = generalManager->GetAvailableModules();
00122               mods.insert(mods.end(), mods1.begin(), mods1.end());
00123        }
00124        else
00125               LOGERROR(wxT("<Kernel>Kernel not initialized"));
00126 
00127        return mods;
00128 }

bool Kernel::Initialize (  ) 

Initialize servers and search for available modules.

Notebook for parameters

Definition at line 131 of file kernel.cpp.

00132 {
00133        eventHandler = new EventHandler();
00134        ioManager = new IOManager();
00135        renderManager = new RenderManager();
00136        sceneManager = new SceneManager();
00137        manipManager = new ManipulatorManager();
00138        generalManager = new GeneralManager();
00139        GUIEnvironment * guiEnv = new GUIEnvironment(mainWindow);
00140        if (eventHandler && ioManager && renderManager && sceneManager && manipManager && generalManager)
00141        {
00143               wxString paramsNbName = wxT("Parameters");
00144               guiEnv->SetName(paramsNbName);
00145               mainWindow->GetAUIManager()->AddPane(guiEnv, wxAuiPaneInfo().
00146                       DefaultPane().Name(paramsNbName).
00147                       Caption(paramsNbName).Top().
00148                       PinButton().BestSize(480, 320));
00149               mainWindow->GetAUIManager()->Update();
00150 
00151               initialized = true;
00152               LOGVERBOSE(wxT("<Kernel>Initialized"));
00153               return true;
00154        }
00155        return false;
00156 }

bool Kernel::GetModules ( std::vector< std::pair< Module *, MODULE_INSTANCE_ID > > *  moduleList,
const wxString &  moduleName,
MODULE_INSTANCE_ID  instanceID = MODULE_INSTANCE_ID_NONE 
)

Search all servers and get modules with given module name (and instance ID optionally)

Parameters:
[out] moduleList Will be filled with corresponding modules
[in] moduleName Module name (filename without extension)
[in] instanceID If defined one or no module is returned, otherwise instance ID is ignored
Returns:
false if no module with moduleName name exists

Definition at line 159 of file kernel.cpp.

00160 {
00161        bool ret = false;
00162        if (IsInitialized())
00163        {
00164               ret |= ioManager->GetModules(moduleList, moduleName, instanceID);
00165               ret |= renderManager->GetModules(moduleList, moduleName, instanceID);
00166               ret |= manipManager->GetModules(moduleList, moduleName, instanceID);
00167               ret |= generalManager->GetModules(moduleList, moduleName, instanceID);
00168        }
00169        else
00170               LOGERROR(wxT("<Kernel>Kernel not initialized"));
00171 
00172        return ret;
00173 }

void Kernel::PreferModule ( const wxString &  libName  ) 

Add module's dynamic library name to prefered modules list Last added has the highest priority

Definition at line 176 of file kernel.cpp.

00177 {
00178        preferedModules.push_front(CloneWxString(libName));
00179        for (ModuleNamesList::iterator nameIt = forbiddenModules.begin();
00180               nameIt != forbiddenModules.end(); )
00181        {
00182               if (nameIt->IsSameAs(libName, false))
00183                      nameIt = forbiddenModules.erase(nameIt);
00184               else
00185                      nameIt++;
00186        }
00187 }

const ModuleNamesList* VRUT::Kernel::GetPreferedModules (  )  const [inline]

Get prefered modules list.

Definition at line 128 of file kernel.h.

00129               {
00130                      return &preferedModules;
00131               }

void Kernel::ForbidModule ( const wxString &  libName  ) 

Add module's dynamic library name to forbidden modules list.

Definition at line 190 of file kernel.cpp.

00191 {
00192        forbiddenModules.push_front(CloneWxString(libName));
00193        for (ModuleNamesList::iterator nameIt = preferedModules.begin();
00194               nameIt != preferedModules.end(); )
00195        {
00196               if (nameIt->IsSameAs(libName, false))
00197                      nameIt = preferedModules.erase(nameIt);
00198               else
00199                      nameIt++;
00200        }
00201 }

bool Kernel::IsForbidden ( const wxString &  libName  )  const

Is module forbidden?

Definition at line 204 of file kernel.cpp.

00205 {
00206        for (ModuleNamesList::const_iterator nameIt = forbiddenModules.begin();
00207               nameIt != forbiddenModules.end(); nameIt++)
00208               if (nameIt->IsSameAs(libName, false) || nameIt->IsSameAs(wxT("lib") + libName, false))
00209                      return true;
00210        return false;
00211 }

Member Data Documentation

Kernel * Kernel::instance = (Kernel *)NULL [static, protected]

Singleton instance.

Definition at line 39 of file kernel.h.

MainWindow* VRUT::Kernel::mainWindow [protected]

Application's main window.

Definition at line 41 of file kernel.h.

EventHandler* VRUT::Kernel::eventHandler [protected]

Event handler.

Definition at line 43 of file kernel.h.

wxThreadIdType VRUT::Kernel::mainThreadID [protected]

Main thread ID.

Definition at line 45 of file kernel.h.

bool VRUT::Kernel::initialized [protected]

Is kernel initialized?

Definition at line 47 of file kernel.h.

bool VRUT::Kernel::exiting [protected]

Is kernel releasing data and exiting?

Definition at line 49 of file kernel.h.

ModuleNamesList VRUT::Kernel::preferedModules [protected]

List of prefered modules to pick when loading.

Definition at line 51 of file kernel.h.

ModuleNamesList VRUT::Kernel::forbiddenModules [protected]

List of forbidden modules.

Definition at line 53 of file kernel.h.

Environment VRUT::Kernel::environment

Environment with parameter management.

Definition at line 62 of file kernel.h.

Interpreter VRUT::Kernel::interpreter

Command interpreter.

Definition at line 64 of file kernel.h.

IOManager* VRUT::Kernel::ioManager

Input/output server.

Definition at line 66 of file kernel.h.

RenderManager* VRUT::Kernel::renderManager

Render server.

Definition at line 68 of file kernel.h.

ManipulatorManager* VRUT::Kernel::manipManager

Manipulator manager.

Definition at line 70 of file kernel.h.

SceneManager* VRUT::Kernel::sceneManager

Scene manager.

Definition at line 72 of file kernel.h.

GeneralManager* VRUT::Kernel::generalManager

General manager.

Definition at line 74 of file kernel.h.

The documentation for this class was generated from the following files:
Generated on Tue Mar 10 14:41:43 2009 for VRUT by  doxygen 1.5.5