WKernel.cpp 7.07 KB
Newer Older
ebaum's avatar
[ADD]  
ebaum committed
1 2
//---------------------------------------------------------------------------
//
3
// Project: OpenWalnut ( http://www.openwalnut.org )
ebaum's avatar
[ADD]  
ebaum committed
4
//
5 6
// Copyright 2009 OpenWalnut Community, BSV@Uni-Leipzig and CNCF@MPI-CBS
// For more information see http://www.openwalnut.org/copying
ebaum's avatar
[ADD]  
ebaum committed
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
//
// This file is part of OpenWalnut.
//
// OpenWalnut is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// OpenWalnut 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with OpenWalnut. If not, see <http://www.gnu.org/licenses/>.
//
//---------------------------------------------------------------------------

25 26 27 28
#ifdef __linux__
#include <unistd.h> // used for getcwd (to get current directory)
#endif

29 30 31 32
#if defined(__APPLE__)
#include <mach-o/dyld.h>
#endif

ebaum's avatar
[ADD]  
ebaum committed
33
#include <iostream>
ebaum's avatar
ebaum committed
34
#include <list>
35 36
#include <string>
#include <vector>
ebaum's avatar
ebaum committed
37

ledig's avatar
ledig committed
38
#include <boost/filesystem.hpp>
ebaum's avatar
ebaum committed
39
#include <boost/thread/xtime.hpp>
ebaum's avatar
[ADD]  
ebaum committed
40

41
#include "../common/WPreferences.h"
42
#include "../common/WStringUtils.h"
43
#include "../common/WThreadedRunner.h"
Mathias Goldau's avatar
Mathias Goldau committed
44
#include "../dataHandler/WDataHandler.h"
ebaum's avatar
ebaum committed
45
#include "../graphicsEngine/WGraphicsEngine.h"
46
#include "WKernel.h"
47 48
#include "WModule.h"
#include "WModuleFactory.h"
49
#include "WModuleProjectFileCombiner.h"
ebaum's avatar
[ADD]  
ebaum committed
50

51
/**
ebaum's avatar
ebaum committed
52 53 54 55
 * Used for program wide access to the kernel.
 */
WKernel* kernel = NULL;

56 57 58
/**
 * Define shader path.
 */
59
boost::filesystem::path WKernel::m_shaderPath = boost::filesystem::path();
60 61 62 63

/**
 * Define app path.
 */
64
boost::filesystem::path WKernel::m_appPath = boost::filesystem::path();
65

66 67 68
/**
 * Define font path.
 */
69
boost::filesystem::path WKernel::m_fontPath = boost::filesystem::path();
70

71
WKernel::WKernel( boost::shared_ptr< WGraphicsEngine > ge, boost::shared_ptr< WGUI > gui ):
72
    WThreadedRunner()
ebaum's avatar
[ADD]  
ebaum committed
73
{
74
    WLogger::getLogger()->addLogMessage( "Initializing Kernel", "Kernel", LL_INFO );
ebaum's avatar
ebaum committed
75

76
    // init the singleton
ebaum's avatar
ebaum committed
77 78
    kernel = this;

ebaum's avatar
[ADD]  
ebaum committed
79
    // initialize members
80 81
    m_gui = gui;
    m_graphicsEngine = ge;
82

83
    // init
ebaum's avatar
ebaum committed
84
    init();
ebaum's avatar
[ADD]  
ebaum committed
85 86 87 88 89
}

WKernel::~WKernel()
{
    // cleanup
90
    WLogger::getLogger()->addLogMessage( "Shutting down Kernel", "Kernel", LL_INFO );
ebaum's avatar
[ADD]  
ebaum committed
91 92
}

93
void WKernel::init()
ebaum's avatar
[ADD]  
ebaum committed
94
{
95
    // initialize
96
    findAppPath();
97 98
    m_roiManager = boost::shared_ptr< WROIManagerFibers >( new WROIManagerFibers() );

99 100 101
    // get module factory
    m_moduleFactory = WModuleFactory::getModuleFactory();

102 103 104
    // init data handler
    WDataHandler::getDataHandler();

105 106 107 108 109
    // initialize module container
    m_moduleContainer = boost::shared_ptr< WModuleContainer >( new WModuleContainer( "KernelRootContainer",
                "Root module container in Kernel." ) );

    // initialize graphics engine, or, at least set some stuff
110 111
    m_graphicsEngine->setShaderPath( m_shaderPath.file_string() );
    m_graphicsEngine->setFontPath( m_fontPath.file_string() );
112 113 114

    // load all modules
    m_moduleFactory->load();
ebaum's avatar
[ADD]  
ebaum committed
115 116
}

ebaum's avatar
ebaum committed
117 118 119 120 121
WKernel* WKernel::getRunningKernel()
{
    return kernel;
}

122
boost::shared_ptr< WGraphicsEngine > WKernel::getGraphicsEngine() const
ebaum's avatar
ebaum committed
123
{
124
    return m_graphicsEngine;
ebaum's avatar
ebaum committed
125 126
}

Sebastian Eichelbaum's avatar
[MERGE]  
Sebastian Eichelbaum committed
127
boost::shared_ptr< WModuleContainer > WKernel::getRootContainer() const
128
{
Sebastian Eichelbaum's avatar
[MERGE]  
Sebastian Eichelbaum committed
129
    return m_moduleContainer;
130 131
}

Sebastian Eichelbaum's avatar
[MERGE]  
Sebastian Eichelbaum committed
132
boost::shared_ptr< WGUI > WKernel::getGui() const
133
{
134
    return m_gui;
135 136
}

137
void WKernel::finalize()
Sebastian Eichelbaum's avatar
[MERGE]  
Sebastian Eichelbaum committed
138
{
139
    WLogger::getLogger()->addLogMessage( "Stopping Kernel", "Kernel", LL_INFO );
140 141

    // NOTE: stopping a container erases all modules inside.
Sebastian Eichelbaum's avatar
[STYLE]  
Sebastian Eichelbaum committed
142
    getRootContainer()->stop();
143 144 145

    WLogger::getLogger()->addLogMessage( "Stopping Data Handler", "Kernel", LL_INFO );
    WDataHandler::getDataHandler()->clear();
Sebastian Eichelbaum's avatar
[MERGE]  
Sebastian Eichelbaum committed
146 147
}

148
void WKernel::threadMain()
ebaum's avatar
ebaum committed
149
{
150
    WLogger::getLogger()->addLogMessage( "Starting Kernel", "Kernel", LL_INFO );
ebaum's avatar
ebaum committed
151

152
    // wait for GUI to be initialized properly
153
    m_gui->isInitialized().wait();
Sebastian Eichelbaum's avatar
[MERGE]  
Sebastian Eichelbaum committed
154

155 156 157
    // start GE
    m_graphicsEngine->run();

158
    // default modules
159
    {
Mathias Goldau's avatar
[MERGE]  
Mathias Goldau committed
160
        std::string stdModules = "Coordinate System Module,HUD";
161 162 163
        WPreferences::getPreference( "modules.default", &stdModules );
        std::vector< std::string > defMods = string_utils::tokenize( stdModules, "," );
        for ( std::vector< std::string >::iterator iter = defMods.begin(); iter != defMods.end(); ++iter )
164
        {
165 166 167 168 169 170 171 172 173 174 175
            std::string moduleName = string_utils::trim( ( *iter ) );
            boost::shared_ptr< WModule> proto = m_moduleFactory->isPrototypeAvailable( moduleName );

            // try to find a prototype
            if ( proto.get() )
            {
                // the module exists
                m_moduleContainer->add( m_moduleFactory->create( proto ) , true );
            }
            else
            {
Alexander Wiebel's avatar
Alexander Wiebel committed
176 177 178
                WLogger::getLogger()->addLogMessage( "Specified default module \"" + moduleName + "\" does not exist. Ignoring.",
                                                     "Kernel",
                                                     LL_WARNING );
179
            }
180 181
        }
    }
182

183 184
    // actually there is nothing more to do here
    waitForStop();
185

186
    WLogger::getLogger()->addLogMessage( "Shutting down Kernel", "Kernel", LL_INFO );
187 188
}

189
void WKernel::findAppPath()
190
{
191
    // only get the path if not already done
192
    if ( !m_appPath.empty() )
193 194 195 196 197 198
    {
        return;
    }

    // unified version with boost::filesystem
    namespace fs = boost::filesystem;
ledig's avatar
ledig committed
199 200
    fs::path currentDir( fs::initial_path<fs::path>() );

201 202
    m_appPath = currentDir;
    WLogger::getLogger()->addLogMessage( "Application path: " + m_appPath.file_string(), "Kernel", LL_DEBUG );
203

204 205
    m_shaderPath = fs::path( currentDir / "shaders" );
    WLogger::getLogger()->addLogMessage( "Shader path: " + m_shaderPath.file_string(), "Kernel", LL_DEBUG );
206

207 208
    m_fontPath = fs::path( currentDir / "fonts" );
    WLogger::getLogger()->addLogMessage( "Font path: " + m_fontPath.file_string(), "Kernel", LL_DEBUG );
ebaum's avatar
ebaum committed
209 210
}

211
const WBoolFlag& WKernel::isFinishRequested() const
ebaum's avatar
ebaum committed
212
{
213
    return m_shutdownFlag;
ebaum's avatar
[ADD]  
ebaum committed
214 215
}

216
void WKernel::loadDataSets( std::vector< std::string > fileNames )
217
{
218 219 220 221 222 223
    getRootContainer()->loadDataSets( fileNames );
}

void WKernel::loadDataSetsSynchronously( std::vector< std::string > fileNames )
{
    getRootContainer()->loadDataSetsSynchronously( fileNames );
224 225
}

226
boost::shared_ptr< WModule > WKernel::applyModule( boost::shared_ptr< WModule > applyOn, boost::shared_ptr< WModule > prototype )
227
{
228
    return getRootContainer()->applyModule( applyOn, prototype );
229 230
}

231
boost::filesystem::path WKernel::getAppPathObject()
232
{
233
    findAppPath();
234
    return WKernel::m_appPath;
235 236
}

237 238 239 240 241 242
std::string WKernel::getAppPath()
{
    findAppPath();
    return WKernel::m_appPath.file_string();
}

243
std::string WKernel::getShaderPath()
244
{
245
    findAppPath();
246
    return WKernel::m_shaderPath.file_string();
247
}
248 249 250 251 252

boost::shared_ptr< WROIManagerFibers> WKernel::getRoiManager()
{
    return m_roiManager;
}
253 254 255 256

std::string WKernel::getFontPath()
{
    findAppPath();
257
    return WKernel::m_fontPath.file_string();
258
}