int main(int argc, char *argv[])
{
createConsole();
QApplication a(argc, argv);
PrimeSenseTest w;
w.show();
return a.exec();
}
void Fixture::viewConsole()
{
if (m_console == NULL)
{
if (createConsole() == true)
m_console->show();
Q_ASSERT(m_console != NULL);
}
else
{
m_console->hide();
m_console->show();
}
}
void VisualStudio::createTutorial(const QString &item,const QString &directory,const QString &filename) const
{
createConsole(item,directory,filename,false);
QFile file(filename);
if ( file.open( QIODevice::Append ) )
{
QTextStream stream( &file );
stream << "cls" << "\r\n";
stream << "@ECHO ON" << "\r\n";
stream << "cscl --cs-count tutorial.cpp /nologo /EHsc /Fehello.exe" << "\r\n";
stream << "@ECHO OFF" << "\r\n";
stream << "pause" << "\r\n";
stream << "exit" << "\r\n";
file.close();
}
}
// constructor initializes the reference time and sets the current camera
// and HUD
//
Coordinator::Coordinator(void* hinst, int show) {
coordinator = this;
window = CreateAPIWindow(hinst, show);
userInput = CreateAPIUserInput(AUDIO_DIRECTORY);
display = CreateAPIDisplay();
audio = CreateAPIAudio(1.0f, MIN_VOLUME, MAX_VOLUME, MIN_FREQUENCY,
MAX_FREQUENCY, DEFAULT_VOLUME, DEFAULT_FREQUENCY);
// timers
now = 0;
lastReset = 0;
lastUpdate = 0;
lastCameraToggle = 0;
lastHUDToggle = 0;
framecount = 0;
fps = 0;
// current camera and HUD
currentCam = 0;
currentHUD = 0;
// creating message centre (CONSOLE)
lastConsoleToggle = 0;
console = createConsole();
// volume and frequency settings
frequency = DEFAULT_FREQUENCY;
volume = DEFAULT_VOLUME;
// pointers
timerText = nullptr;
background = nullptr;
// projection parameters are updated
fov = 0.9f;
nearcp = 1.0f;
farcp = 1000.0f;
}
int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/,
LPSTR lpCmdLine, int nCmdShow)
{
ModelLoader* modelLoader;
bool screenSaver = isScreenSaver();
int retValue;
STARTUPINFO startupInfo;
bool fromConsole = false;
//HMODULE hThumbs = LoadLibrary("LDViewThumbs.dll");
//if (hThumbs != NULL)
//{
// PFNDLLREGISTERSERVER pDllRegisterServer =
// (PFNDLLREGISTERSERVER)GetProcAddress(hThumbs, "DllRegisterServer");
// CoInitialize(NULL);
// if (pDllRegisterServer != NULL)
// {
// pDllRegisterServer();
// }
//}
memset(&startupInfo, 0, sizeof(startupInfo));
startupInfo.cb = sizeof(startupInfo);
GetStartupInfo(&startupInfo);
if (startupInfo.lpTitle != NULL &&
stringHasCaseInsensitivePrefix(startupInfo.lpTitle, "command line ")
&& strcasestr(startupInfo.lpTitle, "ldview") != NULL)
{
runningWithConsole();
fromConsole = true;
}
#ifdef _DEBUG
int _debugFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
_debugFlag |= _CRTDBG_LEAK_CHECK_DF;
_CrtSetDbgFlag(_debugFlag);
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_DEBUG);
if (!fromConsole)
{
createConsole();
}
// MessageBox(NULL, "Attach a debugger now...", "Debug", MB_OK);
#endif // _DEBUG
bool udok = setupUserDefaults(lpCmdLine, screenSaver,
isRemovableDrive(hInstance));
setupLocalStrings();
if (TCUserDefaults::boolForKey(DEBUG_COMMAND_LINE_KEY, false, false))
{
std::string message = "Command Line:\n";
message += lpCmdLine;
MessageBox(NULL, message.c_str(), "LDView", MB_OK);
}
if (!udok && !TCUserDefaults::longForKey("IniFailureShown", 0, 0))
{
UCCHAR message[2048];
UCSTR iniPath = mbstoucstring(TCUserDefaults::getIniPath());
sucprintf(message, COUNT_OF(message),
TCLocalStrings::get(_UC("IniFailure")), iniPath);
CUIWindow::messageBoxUC(NULL, message, _UC("LDView"), MB_OK);
delete iniPath;
TCUserDefaults::setLongForKey(1, "IniFailureShown", false);
}
if (screenSaver)
{
if (strncasecmp(lpCmdLine, "/p", 2) == 0 ||
strncasecmp(lpCmdLine, "-p", 2) == 0 ||
strncasecmp(lpCmdLine, "p", 1) == 0)
{
// preview mode
return doPreview(hInstance, lpCmdLine);
}
if (strncasecmp(lpCmdLine, "/c", 2) == 0 ||
strncasecmp(lpCmdLine, "-c", 2) == 0 ||
strncasecmp(lpCmdLine, "c", 1) == 0 ||
strlen(lpCmdLine) == 0)
{
SSConfigure *configure;
configure = new SSConfigure(hInstance);
#ifdef _DEBUG
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_DEBUG);
createConsole();
#endif // _DEBUG
configure->run();
// configure mode
return 1;
}
// This shouldn't be necessary, but I've received a report of a whole
// bunch of copies of the LDView screensaver running at once. This
// might not fix things entirely, but it will at least prevent it
// from launching multiple times concurrently.
CreateMutex(NULL, FALSE, "LDView Screensaver");
if (GetLastError() == ERROR_ALREADY_EXISTS)
{
return 0;
}
}
#ifdef _LOG_PERFORMANCE
LARGE_INTEGER frequency;
if (QueryPerformanceFrequency(&frequency))
{
debugPrintf("Frequency: %I64d\n", frequency.QuadPart);
}
#endif // _LOG_PERFORMANCE
OleInitialize(NULL);
//Win7JumpListStuff();
modelLoader = new ModelLoader(CUIWindow::getLanguageModule(), nCmdShow,
screenSaver);
retValue = mainLoop();
modelLoader->release();
return retValue;
} // WinMain
void LLPluginProcessChild::receiveMessageRaw(const std::string &message)
{
// Incoming message from the TCP Socket
LL_DEBUGS("PluginChild") << "Received from parent: " << message << LL_ENDL;
// Decode this message
LLPluginMessage parsed;
parsed.parse(message);
if(mBlockingRequest)
{
// We're blocking the plugin waiting for a response.
if(parsed.hasValue("blocking_response"))
{
// This is the message we've been waiting for -- fall through and send it immediately.
mBlockingResponseReceived = true;
}
else
{
// Still waiting. Queue this message and don't process it yet.
mMessageQueue.push(message);
return;
}
}
bool passMessage = true;
// FIXME: how should we handle queueing here?
{
std::string message_class = parsed.getClass();
if(message_class == LLPLUGIN_MESSAGE_CLASS_INTERNAL)
{
passMessage = false;
std::string message_name = parsed.getName();
if(message_name == "load_plugin")
{
mPluginFile = parsed.getValue("file");
mPluginDir = parsed.getValue("dir");
}
else if(message_name == "shm_add")
{
std::string name = parsed.getValue("name");
size_t size = (size_t)parsed.getValueS32("size");
sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);
if(iter != mSharedMemoryRegions.end())
{
// Need to remove the old region first
LL_WARNS("PluginChild") << "Adding a duplicate shared memory segment!" << LL_ENDL;
}
else
{
// This is a new region
LLPluginSharedMemory *region = new LLPluginSharedMemory;
if(region->attach(name, size))
{
mSharedMemoryRegions.insert(sharedMemoryRegionsType::value_type(name, region));
std::stringstream addr;
addr << region->getMappedAddress();
// Send the add notification to the plugin
LLPluginMessage message("base", "shm_added");
message.setValue("name", name);
message.setValueS32("size", (S32)size);
message.setValuePointer("address", region->getMappedAddress());
sendMessageToPlugin(message);
// and send the response to the parent
message.setMessage(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "shm_add_response");
message.setValue("name", name);
sendMessageToParent(message);
}
else
{
LL_WARNS("PluginChild") << "Couldn't create a shared memory segment!" << LL_ENDL;
delete region;
}
}
}
else if(message_name == "shm_remove")
{
std::string name = parsed.getValue("name");
sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);
if(iter != mSharedMemoryRegions.end())
{
// forward the remove request to the plugin -- its response will trigger us to detach the segment.
LLPluginMessage message("base", "shm_remove");
message.setValue("name", name);
sendMessageToPlugin(message);
}
else
{
LL_WARNS("PluginChild") << "shm_remove for unknown memory segment!" << LL_ENDL;
}
}
else if(message_name == "sleep_time")
{
mSleepTime = llmax(parsed.getValueReal("time"), 1.0 / 100.0); // clamp to maximum of 100Hz
}
#if LL_WINDOWS
else if(message_name == "show_console")
{
createConsole();
}
#endif
else if(message_name == "crash")
{
// Crash the plugin
LL_ERRS("PluginChild") << "Plugin crash requested." << LL_ENDL;
}
else if(message_name == "hang")
{
// Hang the plugin
LL_WARNS("PluginChild") << "Plugin hang requested." << LL_ENDL;
while(1)
{
// wheeeeeeeee......
}
}
else
{
LL_WARNS("PluginChild") << "Unknown internal message from parent: " << message_name << LL_ENDL;
}
}
}
if(passMessage && mInstance != NULL)
{
LLTimer elapsed;
mInstance->sendMessage(message);
mCPUElapsed += elapsed.getElapsedTimeF64();
}
}
int main(int argc, char **argv)
{
#if (QT_VERSION < 0x050200)
#error("You need Qt 5.2.0 or later to compile Actiona Executer");
#endif
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
QtSingleApplication app("actiona-exec", argc, argv);
#else
ActionTools::NativeEventFilteringApplication app("actiona-exec", argc, argv);
#endif
app.setQuitOnLastWindowClosed(false);
qAddPostRoutine(cleanup);
qsrand(std::time(NULL));
#ifdef Q_OS_LINUX
notify_init("Actiona executer");
#endif
#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8"));
#endif
QxtCommandOptions preOptions;
preOptions.add("portable", QObject::tr("starts in portable mode, storing the settings in the executable folder"));
preOptions.alias("portable", "p");
preOptions.parse(QCoreApplication::arguments());
if(preOptions.count("portable") > 0)
{
QSettings::setPath(QSettings::IniFormat, QSettings::UserScope, QApplication::applicationDirPath() + "/userSettings");
QSettings::setPath(QSettings::IniFormat, QSettings::SystemScope, QApplication::applicationDirPath() + "/systemSettings");
QSettings::setDefaultFormat(QSettings::IniFormat);
}
QString locale = Tools::locale();
Tools::installQtTranslator(locale);
Tools::installTranslator("tools", locale);
Tools::installTranslator("actiontools", locale);
Tools::installTranslator("executer", locale);
Tools::installTranslator("actexecuter", locale);
const QStringList &arguments = QCoreApplication::arguments();
QxtCommandOptions options;
options.setFlagStyle(QxtCommandOptions::DoubleDash);
options.setScreenWidth(0);
options.add("code", QObject::tr("switch to code mode, may not be used with -s"));
options.alias("code", "c");
options.add("script", QObject::tr("switch to script mode, may not be used with -c"));
options.alias("script", "s");
options.add("nocodeqt", QObject::tr("do not include the Qt library into the code"));
options.alias("nocodeqt", "Q");
options.add("portable", QObject::tr("starts in portable mode, storing the settings in the executable folder"));
options.alias("portable", "p");
options.add("proxy-mode", QObject::tr("sets the proxy mode, values are \"none\", \"system\" (default) or \"custom\""));
options.add("proxy-type", QObject::tr("sets the custom proxy type, values are \"http\" or \"socks\" (default)"));
options.add("proxy-host", QObject::tr("sets the custom proxy host"));
options.add("proxy-port", QObject::tr("sets the custom proxy port"));
options.add("proxy-user", QObject::tr("sets the custom proxy user"));
options.add("proxy-password", QObject::tr("sets the custom proxy password"));
#ifdef Q_OS_WIN
options.add("console", QObject::tr("create a console to see debug output"));
options.add("pause-at-end", QObject::tr("wait for user input at the end of the execution, used only with --console"));
#endif
options.add("version", QObject::tr("show the program version"));
options.alias("version", "v");
options.add("help", QObject::tr("show this help text"));
options.alias("help", "h");
options.parse(arguments);
#ifdef Q_OS_WIN
if(options.count("console"))
{
createConsole();
if(options.count("pause-at-end"))
qAddPostRoutine(pause);
}
#endif
qRegisterMetaType<ActionTools::ActionInstance>("ActionInstance");
qRegisterMetaType<ActionTools::ActionException::Exception>("Exception");
qRegisterMetaType<ActionTools::Parameter>("Parameter");
qRegisterMetaType<ActionTools::SubParameter>("SubParameter");
qRegisterMetaType<Tools::Version>("Version");
qRegisterMetaTypeStreamOperators<ActionTools::ActionInstance>("ActionInstance");
qRegisterMetaTypeStreamOperators<ActionTools::Parameter>("Parameter");
qRegisterMetaTypeStreamOperators<ActionTools::SubParameter>("SubParameter");
qRegisterMetaTypeStreamOperators<Tools::Version>("Version");
if(options.count("version"))
{
QTextStream stream(stdout);
stream << "Actiona Executer version " << Global::ACTIONA_VERSION.toString() << ", script version " << Global::SCRIPT_VERSION.toString() << "\n";
stream.flush();
return 0;
}
if(options.count("help") || options.showUnrecognizedWarning() || options.positional().count() < 1 || (options.count("code") && options.count("script")))
{
QTextStream stream(stdout);
stream << QObject::tr("usage: ") << QCoreApplication::arguments().at(0) << " " << QObject::tr("[parameters]") << " " << QObject::tr("filename") << "\n";
stream << QObject::tr("Parameters are:") << "\n";
stream << options.getUsage();
stream.flush();
return -1;
}
app.addLibraryPath(QApplication::applicationDirPath() + "/actions");
app.addLibraryPath(QApplication::applicationDirPath() + "/plugins");
if(!options.count("nocodeqt"))
app.addLibraryPath(QApplication::applicationDirPath() + "/code");
#ifdef Q_OS_LINUX
{
#ifdef ACT_PROFILE
Tools::HighResolutionTimer timer("Load key codes");
#endif
ActionTools::KeySymHelper::loadKeyCodes();
}
#endif
// Proxy settings
int proxyMode = ActionTools::Settings::PROXY_SYSTEM;
if(options.value("proxy-mode").toString() == "none")
proxyMode = ActionTools::Settings::PROXY_NONE;
else if(options.value("proxy-mode").toString() == "custom")
proxyMode = ActionTools::Settings::PROXY_CUSTOM;
else if(options.value("proxy-mode").toString() == "system")
proxyMode = ActionTools::Settings::PROXY_SYSTEM;
else if(!options.value("proxy-mode").toString().isEmpty())
{
QTextStream stream(stdout);
stream << QObject::tr("Unknown proxy mode, values are \"none\", \"system\" (default) or \"custom\"") << "\n";
stream.flush();
return -1;
}
QNetworkProxy proxy;
switch(proxyMode)
{
case ActionTools::Settings::PROXY_NONE:
proxy.setType(QNetworkProxy::NoProxy);
break;
case ActionTools::Settings::PROXY_SYSTEM:
{
QUrl url(Global::CONNECTIVITY_URL);
QNetworkProxyQuery networkProxyQuery(url);
QList<QNetworkProxy> listOfProxies = QNetworkProxyFactory::systemProxyForQuery(networkProxyQuery);
if(!listOfProxies.isEmpty())
proxy = listOfProxies.first();
else
proxy.setType(QNetworkProxy::NoProxy);
}
break;
case ActionTools::Settings::PROXY_CUSTOM:
{
int type = ActionTools::Settings::PROXY_TYPE_SOCKS5;
if(options.value("proxy-type").toString() == "http")
type = ActionTools::Settings::PROXY_TYPE_HTTP;
else if(options.value("proxy-type").toString() == "socks")
type = ActionTools::Settings::PROXY_TYPE_SOCKS5;
else if(!options.value("proxy-type").toString().isEmpty())
{
QTextStream stream(stdout);
stream << QObject::tr("Unknown proxy type, values are \"http\" or \"socks\" (default)") << "\n";
stream.flush();
return -1;
}
QNetworkProxy proxy;
if(type == ActionTools::Settings::PROXY_TYPE_HTTP)
proxy.setType(QNetworkProxy::HttpProxy);
else
proxy.setType(QNetworkProxy::Socks5Proxy);
proxy.setHostName(options.value("proxy-host").toString());
proxy.setPort(options.value("proxy-port").toInt());
proxy.setUser(options.value("proxy-user").toString());
proxy.setPassword(options.value("proxy-password").toString());
}
break;
}
QNetworkProxy::setApplicationProxy(proxy);
QUrl protocolUrl = QUrl::fromEncoded(arguments.at(1).toUtf8());
if(protocolUrl.isValid() && protocolUrl.scheme() != "actiona")
protocolUrl = QUrl();
MainClass::ExecutionMode executionMode = MainClass::Unknown;
MainClass mainClass;
if(protocolUrl.isValid())
{
QString mode;
using QStringPair = QPair<QString, QString>;
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
for(const QStringPair &queryItem: QUrlQuery(protocolUrl.query()).queryItems())
#else
for(const QStringPair &queryItem: protocolUrl.queryItems())
#endif
{
if(queryItem.first == "mode")
{
mode = queryItem.second;
break;
}
}
if(mode == "code")
executionMode = MainClass::Code;
else if(mode == "script")
executionMode = MainClass::Script;
else
{
if(protocolUrl.path().endsWith(".ascr"))
executionMode = MainClass::Script;
else if(protocolUrl.path().endsWith(".acod"))
executionMode = MainClass::Code;
else
{
QTextStream stream(stdout);
stream << QObject::tr("Unknown execution mode, please specify mode=script or mode=code") << "\n";
stream.flush();
return -1;
}
}
if(!mainClass.start(executionMode, protocolUrl))
return -1;
}
else
{
QString filename = options.positional().at(0);
if(options.count("code"))
executionMode = MainClass::Code;
else if(options.count("script"))
executionMode = MainClass::Script;
else
{
if(filename.endsWith(".ascr"))
executionMode = MainClass::Script;
else if(filename.endsWith(".acod"))
executionMode = MainClass::Code;
else
{
QTextStream stream(stdout);
stream << QObject::tr("Unknown execution mode, please specify -s (script) or -c (code)") << "\n";
stream.flush();
return -1;
}
}
QFile file(filename);
if(!file.open(QIODevice::ReadOnly))
{
QTextStream stream(stdout);
stream << QObject::tr("Unable to read input file") << "\n";
stream.flush();
return -1;
}
if(!mainClass.start(executionMode, &file, file.fileName()))
{
file.close();
return -1;
}
}
return app.exec();
}