WQt4Gui.cpp 6.5 KB
Newer Older
1 2
//---------------------------------------------------------------------------
//
3
// Project: OpenWalnut ( http://www.openwalnut.org )
4
//
5 6
// Copyright 2009 OpenWalnut Community, BSV@Uni-Leipzig and CNCF@MPI-CBS
// For more information see http://www.openwalnut.org/copying
7
//
wiebel's avatar
wiebel committed
8
// This file is part of OpenWalnut.
9
//
wiebel's avatar
wiebel committed
10
// OpenWalnut is free software: you can redistribute it and/or modify
11 12 13 14
// 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.
//
wiebel's avatar
wiebel committed
15
// OpenWalnut is distributed in the hope that it will be useful,
16 17 18 19 20
// 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
wiebel's avatar
wiebel committed
21
// along with OpenWalnut. If not, see <http://www.gnu.org/licenses/>.
22 23 24
//
//---------------------------------------------------------------------------

ebaum's avatar
ebaum committed
25
#include <iostream>
26
#include <fstream>
27 28
#include <string>
#include <vector>
29

30
#include <boost/program_options.hpp>
31
#include <boost/shared_ptr.hpp>
32

33
#include <QtGui/QApplication>
34 35 36
#include <QtGui/QFileDialog>

#include "WMainWindow.h"
37 38
#include "../../kernel/WKernel.h"
#include "../../graphicsEngine/WGraphicsEngine.h"
39
#include "../../modules/data/WMData.h"
40

41
#include "WQt4Gui.h"
ebaum's avatar
ebaum committed
42

43 44
WQt4Gui::WQt4Gui( int argc, char** argv ):
    WGUI( argc, argv )
ebaum's avatar
ebaum committed
45 46 47
{
}

48
WQt4Gui::~WQt4Gui()
49
{
ebaum's avatar
ebaum committed
50
}
Sebastian Eichelbaum's avatar
[STYLE]  
Sebastian Eichelbaum committed
51 52

const unsigned int boost::program_options::options_description::m_default_line_length = ( unsigned int )2048;
ebaum's avatar
ebaum committed
53

54
bool WQt4Gui::parseOptions( int argc, char** argv )
55 56 57 58
{
    // since the namespace is far to big we use a shortcut here
    namespace po = boost::program_options;

59 60 61
    po::options_description desc( "Allowed options", 2048 );
#ifndef _WIN32
// TODO(wiebel): this does not link on windows at the moment. But it should!
62 63 64
    desc.add_options()
        ( "help,h", "Prints this help message" )
        ( "input,i", po::value< std::vector< std::string > >(), "Input data files that should be loaded automatically" );
65
#endif
66 67 68 69

    po::positional_options_description p;
    p.add( "input", -1 );

70 71
    try
    {
72
        po::store( po::command_line_parser( argc, argv ).options( desc ).positional( p ).run(), m_optionsMap );
73 74 75 76
    }
    catch( boost::program_options::unknown_option e )
    {
        std::cout << e.what() << std::endl;
77
        return false;
78
    }
79 80 81
    catch( boost::program_options::invalid_command_line_syntax e )
    {
        std::cout << e.what() << std::endl;
82 83 84 85 86 87 88 89
        return false;
    }

    po::notify( m_optionsMap );

    //=====================
    // CONFIGURATION FILE
    po::options_description guiConfigurationDescription( "GUI configuration" );
90 91
#ifndef _WIN32
// TODO(wiebel): this does not link on windows at the moment. But it should!
92 93 94 95
    guiConfigurationDescription.add_options()
        ( "ge.bgColor.r", po::value< float >() )
        ( "ge.bgColor.g", po::value< float >() )
        ( "ge.bgColor.b", po::value< float >() );
96
#endif
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129

    std::ifstream ifs;
    ifs.open( "walnut.cfg", std::ifstream::in );

    po::variables_map guiConfiguration;

    try
    {
        po::store( po::parse_config_file( ifs, guiConfigurationDescription ), m_guiConfiguration );
    }
    catch( boost::program_options::unknown_option e )
    {
        std::cout << "Syntax error in configuration file \"walnut.cfg\"." << std::endl;
        return false;
    }

    po::notify( m_guiConfiguration );

    // print usage information if command line asks for help.
    if( m_optionsMap.count( "help" ) )
    {
        std::cout << desc << std::endl;
    }
    return true;
}

int WQt4Gui::run()
{
    bool parsingSuccessful = false;
    parsingSuccessful = parseOptions( argc, argv );

    if( !parsingSuccessful )
    {
130 131
        return 1;
    }
132

133
    // exit as fast as possible if command line asked for help. The ,essage has been printed by parseOptions().
134 135
    if( m_optionsMap.count( "help" ) )
    {
136
        return 1;
137 138
    }

139
    WLogger::getLogger()->run();
140
    WLogger::getLogger()->addLogMessage( "Bringing up GUI", "GUI", LL_INFO );
141

142
    QApplication appl( argc, argv, true );
143

144 145
    // startup graphics engine
    m_ge = boost::shared_ptr< WGraphicsEngine >( new WGraphicsEngine() );
146

147 148 149 150
    // and startup kernel
    m_kernel = boost::shared_ptr< WKernel >( new WKernel( m_ge, shared_from_this() ) );
    m_kernel->run();
    // create the window
151
    m_gui = new WMainWindow( m_guiConfiguration );
152
    m_gui->show();
153

154
    // connect out loader signal with krnel
155
    getLoadButtonSignal()->connect( boost::bind( &WKernel::loadDataSets, m_kernel, _1 ) );
156

157
    m_gui->getModuleButtonSignal()->connect( boost::bind( &WKernel::applyModule, m_kernel, _1, _2 ) );
158

159
    // bind the GUI's slot with the ready signal
160
    t_ModuleGenericSignalHandlerType f = boost::bind( &WQt4Gui::slotAddDatasetOrModuleToBrowser, this, _1 );
161
    m_kernel->getRootContainer()->addDefaultNotifier( WM_READY, f );
162 163

    // now we are initialized
164
    m_isInitialized( true );
165

166 167 168
    // check if we want to load data due to command line and call the respective function
    if( m_optionsMap.count("input") )
    {
169
        m_kernel->loadDataSets( m_optionsMap["input"].as< std::vector< std::string > >() );
170 171
    }

172
    // run
173 174 175 176 177 178 179
    int qtRetCode = appl.exec();

    // signal everybody to shut down properly.
    WKernel::getRunningKernel()->wait( true );
    WKernel::getRunningKernel()->getGraphicsEngine()->wait( true );

    return qtRetCode;
180 181
}

182
void WQt4Gui::slotAddDatasetOrModuleToBrowser( boost::shared_ptr< WModule > module )
183
{
184 185
    // get properties from the module and register them
    m_gui->getPropertyManager()->connectProperties( module->getProperties() );
186

187 188 189 190 191 192 193 194 195
    // TODO(schurade): is this differentiation between data and "normal" modules really needed?
    if ( boost::shared_dynamic_cast< WMData >( module ).get() )
    {
        m_gui->getDatasetBrowser()->addDataset( module, 0 );
    }
    else
    {
        m_gui->getDatasetBrowser()->addModule( module );
    }
196 197
}

198
std::vector< boost::shared_ptr< WDataSet > > WQt4Gui::getDataSetList( int subjectId, bool onlyTextures )
199
{
200
    return m_gui->getDatasetBrowser()->getDataSetList( subjectId, onlyTextures );
201
}
202

203 204 205 206 207
boost::shared_ptr< WModule > WQt4Gui::getSelectedModule()
{
    return m_gui->getDatasetBrowser()->getSelectedModule();
}

schurade's avatar
schurade committed
208
boost::signals2::signal1< void, std::vector< std::string > >* WQt4Gui::getLoadButtonSignal()
209 210 211 212
{
    return m_gui->getLoaderSignal();
}

schurade's avatar
schurade committed
213 214 215 216 217
boost::signals2::signal1< void, std::string >* WQt4Gui::getPickSignal()
{
    return m_gui->getPickSignal();
}