//----------------------------------------------------------------------------
void DolfinGui::updateGeometry(Geometry *geometry)
{
// Use python script to obtain values in QLineEdit boxes
PythonQt::init();
PythonQtObjectPtr mainModule = PythonQt::self()->getMainModule();
mainModule.addObject("infoBox", geometry->getInfoBox());
double *points = new double[geometry->getPointCount()];
double *radius = new double[geometry->getRadiusCount()];
std::cout << "Points: " << std::endl;
for (int i=0; i < geometry->getPointCount(); ++i){
points[i] = mainModule.evalScript(QString("eval(infoBox.pointEdit%1.text)").arg(i),
Py_eval_input).toDouble();
std::cout << i << ": " << points[i] << std::endl;
}
if (geometry->getRadiusCount() > 0){
for (int i=0; i < geometry->getRadiusCount(); ++i){
radius[i] = mainModule.evalScript(QString("eval(infoBox.radiusEdit%1.text)").arg(i),
Py_eval_input).toDouble();
}
}
geometry->setPoints(points);
geometry->setRadius(radius);
geometry->setGeometryPointer(generateGeometry(geometry));
std::cout << "Point count: " << geometry->getPointCount() << std::endl;
plotGeometry();
}
int main( int argc, char **argv )
{
QApplication qapp(argc, argv);
PythonQt::init(PythonQt::IgnoreSiteModule | PythonQt::RedirectStdOut);
PythonQt_QtAll::init();
PythonQtObjectPtr mainContext = PythonQt::self()->getMainModule();
PythonQtScriptingConsole console(NULL, mainContext);
// add a QObject to the namespace of the main python context
PyExampleObject example;
mainContext.addObject("example", &example);
mainContext.evalFile(":example.py");
console.show();
return qapp.exec();
}
int main(int argc, char* argv[])
{
QApplication app(argc, argv);
QSplashScreen* splash = new QSplashScreen(QPixmap(":splash/cgogn/splash.png"));
splash->show();
splash->showMessage("Welcome to SCHNApps", Qt::AlignBottom | Qt::AlignCenter);
// init PythonQt and Python itself
PythonQt::init();
QStringList classNames;
classNames.append("View");
classNames.append("Camera");
classNames.append("Plugin");
classNames.append("MapHandlerGen");
PythonQt::self()->registerQObjectClassNames(classNames);
// get a smart pointer to the __main__ module of the Python interpreter
PythonQtObjectPtr pythonContext = PythonQt::self()->getMainModule();
PythonQtScriptingConsole* pythonConsole = new PythonQtScriptingConsole(NULL, pythonContext);
CGoGN::SCHNApps::SCHNApps schnapps(app.applicationDirPath(), pythonContext, *pythonConsole);
schnapps.show();
pythonContext.addObject("schnapps", &schnapps);
if(argc > 1)
{
QString filename(argv[1]);
QFileInfo fi(filename);
if (fi.exists())
//pythonContext.evalFile(fi.filePath());
schnapps.loadPythonScriptFromFile(fi.filePath());
}
splash->finish(&schnapps);
delete splash;
return app.exec();;
}
//----------------------------------------------------------------------------
void DolfinGui::updateSphere(SphereGeometry *sphere){
std::cout << "In method updateSphere(): \n";
std::cout << "-------- HELLO!!! --------" << std::endl;
// Use python script to obtain values for corner points
PythonQtObjectPtr mainModule = PythonQt::self()->getMainModule();
mainModule.addObject("sphereInfoBox", sphere->getInfoBox());
for (int i=0; i<sphere->getPointCount(); ++i)
sphere->getPoints()[i] = mainModule.evalScript(QString("eval(sphereInfoBox.sphereEdit%1.text)").arg(i),
Py_eval_input).toDouble();
// Use python script to obtain values for radius
for (int i=0; i<sphere->getRadiusCount(); ++i)
sphere->getRadius()[i] = mainModule.evalScript(QString("eval(sphereInfoBox.radiusEdit%1.text)").arg(i),
Py_eval_input).toDouble();
plotSphere(sphere);
sphereSelected = false;
}
//----------------------------------------------------------------------------
void DolfinGui::updateCone(ConeGeometry *cone){
std::cout << "In method updateCone(): \n";
std::cout << "-------- HELLO!!! --------" << std::endl;
for (int i=0; i<6; ++i)
std::cout << cone->getPoints()[i] << " " << std::endl;
// Use python script to obtain values for corner points
PythonQtObjectPtr mainModule = PythonQt::self()->getMainModule();
mainModule.addObject("coneInfoBox", cone->getInfoBox());
for (int i=0; i<cone->getPointCount(); ++i)
cone->getPoints()[i] = mainModule.evalScript(QString("eval(coneInfoBox.coneEdit%1.text)").arg(i),
Py_eval_input).toDouble();
// Use python script to obtain values for radius
for (int i=0; i<cone->getRadiusCount(); ++i)
cone->getRadius()[i] = mainModule.evalScript(QString("eval(coneInfoBox.radiusEdit%1.text)").arg(i),
Py_eval_input).toDouble();
plotCone(cone);
std::cout << "Ferdig" << std::endl;
//coneSelected = false;
}
//----------------------------------------------------------------------------
void DolfinGui::updateCube(CubeGeometry *cube)
{
// Set up arrays to hold information about corner points
//GeometryInfo *cubeInfo = new GeometryInfo(6);
//double dataList[cube->getPointCount()];
//cube->setPoints(dataList);
updateRequested = true;
std::cout << "In method updateCube(): \n";
std::cout << "-------- HELLO!!! --------" << std::endl;
//for (int i=0; i<6; ++i)
// std::cout << cube->getPoints()[i] << " " << std::endl;
// Use python script to obtain new values for corner points
PythonQtObjectPtr mainModule = PythonQt::self()->getMainModule();
mainModule.addObject("cubeInfoBox", cube->getInfoBox());
for (int i=0; i<cube->getPointCount(); ++i){
cube->getPoints()[i] = mainModule.evalScript(QString("eval(cubeInfoBox.cubeEdit%1.text)").arg(i),
Py_eval_input).toDouble();
}
plotCube(cube);
cubeSelected = false;
}
void PythonScriptModule::PostInitialize()
{
// An error has occurred on startup.
if (!pythonQtStarted_)
return;
// Get python main module.
PythonQtObjectPtr mainModule = PythonQt::self()->getMainModule();
if (mainModule.isNull())
{
LogError("PythonScriptModule::StartPythonQt(): Failed to get main module from PythonQt after init!");
return;
}
// Add PythonScriptModule as '_pythonscriptmodule'
// and Framework as '_tundra' to python.
mainModule.addObject("_pythonscriptmodule", this);
mainModule.addObject("_tundra", GetFramework());
QDir pythonPlugins(Application::InstallationDirectory() + "pyplugins");
QDir pythonLibrary(pythonPlugins.absoluteFilePath("python/"));
// Add Tundra python plugins source location.
AddSystemPath(pythonPlugins.absolutePath());
AddSystemPath(pythonPlugins.absoluteFilePath("lib"));
// Add Python Library DLL and on windows pass whole python as a archive file.
/// \todo Is the 'DLLs' really needed also outside windows?
AddSystemPath(pythonLibrary.absoluteFilePath("DLLs"));
#ifdef _WIN32
AddSystemPath(pythonLibrary.absoluteFilePath("Python26.zip"));
#endif
// Connect to SceneAPI
QObject::connect(GetFramework()->Scene(), SIGNAL(SceneAdded(const QString&)), this, SLOT(OnSceneAdded(const QString&)));
// Console commands to ConsoleAPI
GetFramework()->Console()->RegisterCommand("PyExec", "Execute given code in the embedded Python interpreter. Usage: PyExec(mycodestring)",
this, SLOT(ConsoleRunString(const QStringList&)));
GetFramework()->Console()->RegisterCommand("PyLoad", "Execute a python file. Usage: PyLoad(mypymodule)",
this, SLOT(ConsoleRunFile(const QStringList&)));
GetFramework()->Console()->RegisterCommand("PyRestart", "Restarts the Tundra Python ModuleManager",
this, SLOT(ConsoleRestartPython(const QStringList&)));
GetFramework()->Console()->RegisterCommand("PyConsole", "Creates a new Python console window.",
this, SLOT(ShowConsole()));
// Done in PostInitialize() so all modules/APIs are loaded and initialized.
//StartPythonModuleManager();
// --p --python --pythonapitests are special command line options that on purpose not put
// to the Framework program options parsing. So lets do a special parse here for there hidden variables.
/// \todo See if we should return --p --python as official cmd line options back to Framework. Probably best to have modules give own params somehow,
/// we should not mess python specific things to core SDK params in Framework.cpp :I
namespace po = boost::program_options;
po::variables_map commandLineVariables;
po::options_description commandLineDescriptions;
commandLineDescriptions.add_options()
("p", po::value<std::string>(), "Run a python script on startup")
("python", po::value<std::string>(), "Run a python script on startup")
("pythonapitests", "Run a python api test script on startup");
try
{
/// \note QApplication::argc() and QApplication::argv() are deprecated.
po::store(po::command_line_parser(QApplication::argc(), QApplication::argv()).options(commandLineDescriptions).allow_unregistered().run(), commandLineVariables);
}
catch(std::exception &e)
{
LogWarning(Name() + ": " + + e.what());
}
po::notify(commandLineVariables);
if (commandLineVariables.count("python"))
RunScript(commandLineVariables["python"].as<std::string>().c_str());
if (commandLineVariables.count("p"))
RunScript(commandLineVariables["p"].as<std::string>().c_str());
LoadStartupScripts();
}