WQt4Gui.cpp 6.77 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"
42
#include "WCreateCustomDockWidgetEvent.h"
ebaum's avatar
ebaum committed
43

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

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

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

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

60 61 62
    po::options_description desc( "Allowed options", 2048 );
#ifndef _WIN32
// TODO(wiebel): this does not link on windows at the moment. But it should!
63 64 65
    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" );
66
#endif
67 68 69 70

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

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

    po::notify( m_optionsMap );

    //=====================
    // CONFIGURATION FILE
    po::options_description guiConfigurationDescription( "GUI configuration" );
91 92
#ifndef _WIN32
// TODO(wiebel): this does not link on windows at the moment. But it should!
93 94 95 96
    guiConfigurationDescription.add_options()
        ( "ge.bgColor.r", po::value< float >() )
        ( "ge.bgColor.g", po::value< float >() )
        ( "ge.bgColor.b", po::value< float >() );
97
#endif
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 130

    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 )
    {
131 132
        return 1;
    }
133

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

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

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

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

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

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

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

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

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

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

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

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

    return qtRetCode;
181 182
}

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

188 189 190 191 192 193 194 195 196
    // 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 );
    }
197 198
}

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

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

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

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

219 220 221 222 223 224 225 226 227
void WQt4Gui::createCustomWidget( std::string title )
{
    QCoreApplication::postEvent( m_gui, new WCreateCustomDockWidgetEvent( title ) );
}

void WQt4Gui::closeCustomWidget( std::string title )
{
    m_gui->closeCustomDockWidget( title );
}