/*
* Domhan_Samhlaigh - Constructor for Domhan_Samhlaigh class
*
* parameter argc - int &
* parameter argv - char **&
* parameter appDefaults - char **&
*/
Domhan_Samhlaigh::Domhan_Samhlaigh(int & argc, char **& argv, char **& appDefaults) :
Vrui::Application(argc, argv, appDefaults), heightMapPrefix(0), mainMenu(NULL), minimumLevel(0), numberOfHorizontalPatches(0),
numberOfVerticalPatches(0), scaleToEnvironment(true), scene(NULL), texturePrefix(0) {
try {
processCommandLineArguments(argc, argv);
} catch (std::runtime_error e) {
std::cerr << "Error: Exception " << e.what() << "!" << std::endl;
}
initialize();
}
FiberApplication::FiberApplication(int& argc,char**& argv,char**& appDefaults)
:Vrui::Application(argc,argv,appDefaults),
mainMenu(0),
propertiesDialog(0),
m_showSelectionBox(true),
m_fiberFileName(""),
m_anatomyFileName(""),
m_showVolume(false),
mIsoSurface(NULL)
{
//TODO create tool at launch if possible
processCommandLineArguments(argc,argv);
if(m_anatomyFileName != "")
{
mAnatomy.load(m_anatomyFileName);
mIsoSurface = new IsoSurface(&mAnatomy,false);
mIsoSurface->GenerateSurface(0.2f);
}
if(m_fiberFileName != "")
{
mFibers.load(m_fiberFileName);
}
//Create the user interface:
mainMenu=createMainMenu();
//create Popup Window
//propertiesDialog = createPropertiesDialog();
//Install the main menu:
Vrui::setMainMenu(mainMenu);
if(mFibers.getBBMax()[X_AXIS] + mFibers.getBBMax()[Y_AXIS] + mFibers.getBBMax()[Z_AXIS] >
mAnatomy.getBBMax()[X_AXIS] + mAnatomy.getBBMax()[Y_AXIS] + mAnatomy.getBBMax()[Z_AXIS])
{
m_BBMax = mFibers.getBBMax();
}
else
{
m_BBMax = mAnatomy.getBBMax();
}
//Set the navigation transformation:
resetNavigationCallback(0);
//Tell Vrui to run in a continuous frame sequence:
Vrui::updateContinuously();
}
void Config::process(int argc, char* argv[])
{
processCommandLineArguments(argc-1, argv+1);
if (isSet("config")) {
string path;
get("config", path);
ifstream f(path.c_str());
if (!f) {
cerr << "Failed to open config file " << path << endl;
return;
}
while (f) {
string str;
getline(f, str);
boost::trim(str);
if (str[0] == '#') continue;
if (str.empty()) continue;
processArgument(str.c_str());
}
}
processEnvArguments();
}
/**
* Parse command line arguments to find those arguments that
* 1) affect the starting of the VM,
* 2) can be handled without starting the VM, or
* 3) contain quotes
* then call createVM().
*/
int main(int argc, const char **argv)
{
int vbufret, j, ret;
JavaVMInitArgs initArgs;
JavaVM *mainJavaVM;
JNIEnv *mainJNIEnv;
/* Make standard streams unbuffered so that we can use them
for low level-debugging */
vbufret = setvbuf(stdout, NULL, _IONBF, 0);
if (vbufret != 0) {
printf("Error making stdout unbuffered: %d\n", vbufret);
}
vbufret = setvbuf(stderr, NULL, _IONBF, 0);
if (vbufret != 0) {
printf("Error making stderr unbuffered: %d\n", vbufret);
}
SysErrorFile = stderr;
SysTraceFile = stdout;
Me = strrchr(*argv, '/');
if (Me == NULL) {
Me = "RVM";
} else {
Me++;
}
++argv, --argc;
initialHeapSize = heap_default_initial_size;
maximumHeapSize = heap_default_maximum_size;
// Determine page size information early because
// it's needed to parse command line options
pageSize = (Extent) determinePageSize();
if (pageSize <= 0) {
ERROR_PRINTF("RunBootImage.main(): invalid page size %u", pageSize);
exit(EXIT_STATUS_IMPOSSIBLE_LIBRARY_FUNCTION_ERROR);
}
/*
* Debugging: print out command line arguments.
*/
if (TRACE) {
TRACE_PRINTF("RunBootImage.main(): process %d command line arguments\n",argc);
for (j = 0; j < argc; j++) {
TRACE_PRINTF("\targv[%d] is \"%s\"\n",j, argv[j]);
}
}
/* Initialize JavaArgc, JavaArgs and initArg */
initArgs.version = JNI_VERSION_1_4;
initArgs.ignoreUnrecognized = JNI_TRUE;
JavaArgs = (char **)processCommandLineArguments(&initArgs, argv, argc);
if (TRACE) {
TRACE_PRINTF("RunBootImage.main(): after processCommandLineArguments: %d command line arguments\n", JavaArgc);
for (j = 0; j < JavaArgc; j++) {
TRACE_PRINTF("\tJavaArgs[%d] is \"%s\"\n", j, JavaArgs[j]);
}
}
/* Verify heap sizes for sanity. */
if (initialHeapSize == heap_default_initial_size &&
maximumHeapSize != heap_default_maximum_size &&
initialHeapSize > maximumHeapSize) {
initialHeapSize = maximumHeapSize;
}
if (maximumHeapSize == heap_default_maximum_size &&
initialHeapSize != heap_default_initial_size &&
initialHeapSize > maximumHeapSize) {
maximumHeapSize = initialHeapSize;
}
if (maximumHeapSize < initialHeapSize) {
CONSOLE_PRINTF( "%s: maximum heap size %lu MiB is less than initial heap size %lu MiB\n",
Me, (unsigned long) maximumHeapSize/(1024*1024),
(unsigned long) initialHeapSize/(1024*1024));
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
TRACE_PRINTF("\nRunBootImage.main(): VM variable settings\n");
TRACE_PRINTF("initialHeapSize %lu\nmaxHeapSize %lu\n"
"bootCodeFileName \"%s\"\nbootDataFileName \"%s\"\n"
"bootRmapFileName \"%s\"\n"
"verbose %d\n",
(unsigned long) initialHeapSize,
(unsigned long) maximumHeapSize,
bootCodeFilename, bootDataFilename, bootRMapFilename,
verbose);
if (!bootCodeFilename) {
CONSOLE_PRINTF( "%s: please specify name of boot image code file using \"-X:ic=<filename>\"\n", Me);
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
if (!bootDataFilename) {
CONSOLE_PRINTF( "%s: please specify name of boot image data file using \"-X:id=<filename>\"\n", Me);
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
if (!bootRMapFilename) {
CONSOLE_PRINTF( "%s: please specify name of boot image ref map file using \"-X:ir=<filename>\"\n", Me);
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
ret = JNI_CreateJavaVM(&mainJavaVM, &mainJNIEnv, &initArgs);
if (ret < 0) {
ERROR_PRINTF("%s: Could not create the virtual machine; goodbye\n", Me);
exit(EXIT_STATUS_MISC_TROUBLE);
}
return 0;
}
int main (int argc, char *argv[])
{
SquareMaze *maze;
bool showVisualization=false;
bool showSolutionMode=false;
double visualizationPauseInSec=0.1;
// 221 STUDENTS: you may safely ignore (or even delete) the function
// call to processCommandLineArguments. We will test your program
// with no command-line arguments. (You are free to leave the call
// here and, e.g., use the visualization for your debugging,
// however!)
processCommandLineArguments(argc, argv,
showVisualization,
showSolutionMode,
visualizationPauseInSec);
// 221 STUDENTS: This reads a square maze from standard input. You
// can use this as is.
maze = new SquareMaze(cin);
// 221 STUDENTS: You may safely ignore (or even delete) the
// visualization code below. Even if you would like to use it, it
// should work with no changes on your part.
// Set up the visualizer, if it has been requested. If solution
// visualization has been requested, then the input should include
// solutions to the maze, and showing the solutions is all this
// program will do. (It will not also try to solve the maze.)
//
// WARNING: this code does not work on Windows
VisualizeSquareMazeRunner *visualizer=NULL;
#ifndef WIN32
if (showVisualization) {
visualizer=new VisualizeSquareMazeRunner(maze);
visualizer->setPauseTime(visualizationPauseInSec);
if (showSolutionMode) {
while (!cin.eof()) {
char solutionAlg[256];
cin.getline(solutionAlg,256);
if (cin.eof()) {
break;
}
cout << " Printing solution done by " << solutionAlg << " algorithm\n";
int x,y;
visualizer->startSolutionPath();
while (SquareMaze::SquareMazeNode::readXY(cin,&x,&y)) {
visualizer->addNextInSolutionPath(x,y);
//cout << "(" << x << "," << y << ")\n";
}
visualizer->doneSolutionPath();
cout << "Click mouse in solution display window to continue...\n";
cout << flush;
visualizer->waitForMouseClick();
}
return 0;
}
}
#endif
MazeRunner *mazeRunner;
// 221 STUDENTS: You'll want to use your own maze runner rather than
// a RandomMazeRunner. (Just change the constructor called on the
// right side of the assignment statement.) You'll also want to run
// two mazerunners (which you can do by copying similar code below).
// cout<< "random"<< endl;
// mazeRunner = new RandomMazeRunner();
// mazeRunner->solveMaze(maze,cout);
// delete mazeRunner;
//
// Clean up the maze, in case we need to run another maze runner
maze->reinitializeMaze();
mazeRunner = new DFSMazeRunner();
mazeRunner->solveMaze(maze,cout);
delete mazeRunner;
// Clean up the maze, in case we need to run another maze runner
maze->reinitializeMaze();
mazeRunner = new BFSMazeRunner();
mazeRunner->solveMaze(maze,cout);
delete mazeRunner;
// Clean up the maze, in case we need to run another maze runner
maze->reinitializeMaze();
// Clean up and return.
if (visualizer != NULL)
delete visualizer;
delete maze;
return 0;
}
/*
* Parse command line arguments to find those arguments that
* 1) affect the starting of the VM,
* 2) can be handled without starting the VM, or
* 3) contain quotes
* then call createVM().
*/
int
main(int argc, const char **argv)
{
Me = strrchr(*argv, '/') + 1;
++argv, --argc;
initialHeapSize = heap_default_initial_size;
maximumHeapSize = heap_default_maximum_size;
/*
* Debugging: print out command line arguments.
*/
if (DEBUG) {
printf("RunBootImage.main(): process %d command line arguments\n",argc);
for (int j=0; j<argc; j++) {
printf("\targv[%d] is \"%s\"\n",j, argv[j]);
}
}
// call processCommandLineArguments().
bool fastBreak = false;
// Sets JavaArgc
JavaArgs = processCommandLineArguments(argv, argc, &fastBreak);
if (fastBreak) {
exit(EXIT_STATUS_BOGUS_COMMAND_LINE_ARG);
}
if (DEBUG) {
printf("RunBootImage.main(): after processCommandLineArguments: %d command line arguments\n", JavaArgc);
for (int j = 0; j < JavaArgc; j++) {
printf("\tJavaArgs[%d] is \"%s\"\n", j, JavaArgs[j]);
}
}
/* Verify heap sizes for sanity. */
if (initialHeapSize == heap_default_initial_size &&
maximumHeapSize != heap_default_maximum_size &&
initialHeapSize > maximumHeapSize) {
initialHeapSize = maximumHeapSize;
}
if (maximumHeapSize == heap_default_maximum_size &&
initialHeapSize != heap_default_initial_size &&
initialHeapSize > maximumHeapSize) {
maximumHeapSize = initialHeapSize;
}
if (maximumHeapSize < initialHeapSize) {
fprintf(SysTraceFile, "%s: maximum heap size %lu MiB is less than initial heap size %lu MiB\n",
Me, (unsigned long) maximumHeapSize/(1024*1024),
(unsigned long) initialHeapSize/(1024*1024));
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
if (DEBUG){
printf("\nRunBootImage.main(): VM variable settings\n");
printf("initialHeapSize %lu\nmaxHeapSize %lu\n"
"bootCodeFileName |%s|\nbootDataFileName |%s|\n"
"bootRmapFileName |%s|\n"
"lib_verbose %d\n",
(unsigned long) initialHeapSize,
(unsigned long) maximumHeapSize,
bootCodeFilename, bootDataFilename, bootRMapFilename,
lib_verbose);
}
if (!bootCodeFilename) {
fprintf(SysTraceFile, "%s: please specify name of boot image code file using \"-X:ic=<filename>\"\n", Me);
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
if (!bootDataFilename) {
fprintf(SysTraceFile, "%s: please specify name of boot image data file using \"-X:id=<filename>\"\n", Me);
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
if (!bootRMapFilename) {
fprintf(SysTraceFile, "%s: please specify name of boot image ref map file using \"-X:ir=<filename>\"\n", Me);
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
#ifdef __MACH__
// Initialize timer information on OS/X
(void) mach_timebase_info(&timebaseInfo);
#endif
int ret = createVM(0);
assert(ret == 1); // must be 1 (error status for this func.)
fprintf(SysErrorFile, "%s: Could not create the virtual machine; goodbye\n", Me);
exit(EXIT_STATUS_MISC_TROUBLE);
}
/*
* Parse command line arguments to find those arguments that
* 1) affect the starting of the VM,
* 2) can be handled without starting the VM, or
* 3) contain quotes
* then call createVM().
*/
int
main(int argc, const char **argv)
{
Me = strrchr(*argv, '/') + 1;
++argv, --argc;
initialHeapSize = heap_default_initial_size;
maximumHeapSize = heap_default_maximum_size;
#ifdef RVM_WITH_FLEXIBLE_STACK_SIZES
const unsigned stack_minimum_size =
VM_Constants_STACK_SIZE_MIN;
const unsigned stack_default_initial_size =
VM_Constants_STACK_SIZE_NORMAL_DEFAULT;
const unsigned stack_grow_minimum_increment =
VM_Constants_STACK_SIZE_GROW_MIN;
const unsigned stack_default_grow_increment =
VM_Constants_STACK_SIZE_GROW_DEFAULT;
const unsigned stack_default_maximum_size =
VM_Constants_STACK_SIZE_MAX_DEFAULT;
initialStackSize = stack_default_initial_size;
stackGrowIncrement = stack_default_grow_increment;
maximumStackSize = stack_default_maximum_size;
#endif // RVM_WITH_FLEXIBLE_STACK_SIZES
/*
* Debugging: print out command line arguments.
*/
if (DEBUG) {
printf("RunBootImage.main(): process %d command line arguments\n",argc);
for (int j=0; j<argc; j++) {
printf("\targv[%d] is \"%s\"\n",j, argv[j]);
}
}
// call processCommandLineArguments().
bool fastBreak = false;
// Sets JavaArgc
JavaArgs = processCommandLineArguments(argv, argc, &fastBreak);
if (fastBreak) {
exit(EXIT_STATUS_BOGUS_COMMAND_LINE_ARG);
}
if (DEBUG) {
printf("RunBootImage.main(): after processCommandLineArguments: %d command line arguments\n", JavaArgc);
for (int j = 0; j < JavaArgc; j++) {
printf("\tJavaArgs[%d] is \"%s\"\n", j, JavaArgs[j]);
}
}
#ifdef RVM_FOR_LINUX
if (rvm_singleVirtualProcessor <= -2) {
if (running_Debian())
rvm_singleVirtualProcessor = -1;
else
rvm_singleVirtualProcessor = 0;
}
if (rvm_singleVirtualProcessor < 0) // Debian.
rvm_singleVirtualProcessor = singleVirtualProcessor_for_Debian();
#else
/* Turn it off for all non-Linux systems. We could print a diagnostic
* message here, but that seems like too much work to implement. */
if (rvm_singleVirtualProcessor < 0)
rvm_singleVirtualProcessor = 0;
#endif
/* Verify heap sizes for sanity. */
if (initialHeapSize == heap_default_initial_size &&
maximumHeapSize != heap_default_maximum_size &&
initialHeapSize > maximumHeapSize) {
initialHeapSize = maximumHeapSize;
}
if (maximumHeapSize == heap_default_maximum_size &&
initialHeapSize != heap_default_initial_size &&
initialHeapSize > maximumHeapSize) {
maximumHeapSize = initialHeapSize;
}
if (maximumHeapSize < initialHeapSize) {
fprintf(SysTraceFile, "%s: maximum heap size %lu MiB is less than initial heap size %lu MiB\n",
Me, (unsigned long) maximumHeapSize/(1024*1024),
(unsigned long) initialHeapSize/(1024*1024));
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
#ifdef RVM_WITH_FLEXIBLE_STACK_SIZES
/* Verify stack sizes for sanity. */
if (initialStackSize == stack_default_initial_size &&
maximumStackSize != stack_default_maximum_size &&
initialStackSize > maximumStackSize) {
initialStackSize = maximumStackSize;
}
if (maximumStackSize == stack_default_maximum_size &&
initialStackSize != stack_default_initial_size &&
initialStackSize > maximumStackSize) {
maximumStackSize = initialStackSize;
}
if (maximumStackSize < initialStackSize) {
fprintf(SysTraceFile, "%s: maximum stack size %lu KiB is less than initial stack size %lu KiB\n",
Me, (unsigned long) maximumStackSize/1024,
(unsigned long) initialStackSize/1024);
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
if (initialStackSize < stack_minimum_size) {
fprintf(SysTraceFile, "%s: initial stack size %lu KiB is less than minimum stack size %lu KiB\n",
Me, (unsigned long) initialStackSize/1024,
(unsigned long) stack_minimum_size/1024);
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
if (stackGrowIncrement < stack_grow_minimum_increment) {
fprintf(SysTraceFile, "%s: stack growth increment %lu KiB is less than minimum growth increment %lu KiB\n",
Me, (unsigned long) stackGrowIncrement/1024,
(unsigned long) stack_grow_minimum_increment/1024);
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
#endif // RVM_WITH_FLEXIBLE_STACK_SIZES
if (DEBUG){
printf("\nRunBootImage.main(): VM variable settings\n");
printf("initialHeapSize %lu\nmaxHeapSize %lu\n"
#ifdef RVM_WITH_FLEXIBLE_STACK_SIZES
"initialStackSize %lu\n"
"stackGrowIncrement %lu\n"
"maxStackSize %lu\n"
#endif // RVM_WITH_FLEXIBLE_STACK_SIZES
"rvm_singleVirtualProcessor %d\n"
"bootFileName |%s|\nlib_verbose %d\n",
(unsigned long) initialHeapSize,
(unsigned long) maximumHeapSize,
#ifdef RVM_WITH_FLEXIBLE_STACK_SIZES
(unsigned long) initialStackSize,
(unsigned long) stackGrowIncrement,
(unsigned long) maximumStackSize,
#endif // RVM_WITH_FLEXIBLE_STACK_SIZES
rvm_singleVirtualProcessor,
bootFilename, lib_verbose);
}
if (!bootFilename) {
#define STRINGIZE(x) #x
#ifdef RVM_BOOTIMAGE
bootFilename = STRINGIZE(RVM_BOOTIMAGE);
#endif
}
if (!bootFilename) {
fprintf(SysTraceFile, "%s: please specify name of boot image file using \"-i<filename>\"\n", Me);
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
int ret = createVM(0);
assert(ret == 1); // must be 1 (error status for this func.)
fprintf(SysErrorFile, "%s: Could not create the virtual machine; goodbye\n", Me);
exit(EXIT_STATUS_MISC_TROUBLE);
}
/**
* Parse command line arguments to find those arguments that
* 1) affect the starting of the VM,
* 2) can be handled without starting the VM, or
* 3) contain quotes
* then call createVM().
*/
int main(int argc, const char **argv)
{
int j, ret;
JavaVMInitArgs initArgs;
JavaVM *mainJavaVM;
JNIEnv *mainJNIEnv;
SYS_START();
#ifndef RVM_FOR_HARMONY
SysErrorFile = stderr;
SysTraceFile = stdout;
setbuf (SysErrorFile, NULL);
setbuf (SysTraceFile, NULL);
setvbuf(stdout,NULL,_IONBF,0);
setvbuf(stderr,NULL,_IONBF,0);
#endif
#ifndef RVM_FOR_WINDOWS
Me = strrchr(*argv, '/');
#else
Me = strrchr(*argv, '\\');
#endif
if (Me == NULL) {
Me = "RVM";
} else {
Me++;
}
++argv, --argc;
initialHeapSize = heap_default_initial_size;
maximumHeapSize = heap_default_maximum_size;
/* Initialize system call routines and side data structures */
sysInitialize();
/*
* Debugging: print out command line arguments.
*/
if (TRACE) {
TRACE_PRINTF("RunBootImage.main(): process %d command line arguments\n",argc);
for (j=0; j<argc; j++) {
TRACE_PRINTF("\targv[%d] is \"%s\"\n",j, argv[j]);
}
}
/* Initialize JavaArgc, JavaArgs and initArg */
initArgs.version = JNI_VERSION_1_4;
initArgs.ignoreUnrecognized = JNI_TRUE;
JavaArgs = (char **)processCommandLineArguments(&initArgs, argv, argc);
if (TRACE) {
TRACE_PRINTF("RunBootImage.main(): after processCommandLineArguments: %d command line arguments\n", JavaArgc);
for (j = 0; j < JavaArgc; j++) {
TRACE_PRINTF("\tJavaArgs[%d] is \"%s\"\n", j, JavaArgs[j]);
}
}
/* Verify heap sizes for sanity. */
if (initialHeapSize == heap_default_initial_size &&
maximumHeapSize != heap_default_maximum_size &&
initialHeapSize > maximumHeapSize) {
initialHeapSize = maximumHeapSize;
}
if (maximumHeapSize == heap_default_maximum_size &&
initialHeapSize != heap_default_initial_size &&
initialHeapSize > maximumHeapSize) {
maximumHeapSize = initialHeapSize;
}
if (maximumHeapSize < initialHeapSize) {
CONSOLE_PRINTF( "%s: maximum heap size %lu MiB is less than initial heap size %lu MiB\n",
Me, (unsigned long) maximumHeapSize/(1024*1024),
(unsigned long) initialHeapSize/(1024*1024));
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
TRACE_PRINTF("\nRunBootImage.main(): VM variable settings\n");
TRACE_PRINTF("initialHeapSize %lu\nmaxHeapSize %lu\n"
"bootCodeFileName \"%s\"\nbootDataFileName \"%s\"\n"
"bootRmapFileName \"%s\"\n"
"verbose %d\n",
(unsigned long) initialHeapSize,
(unsigned long) maximumHeapSize,
bootCodeFilename, bootDataFilename, bootRMapFilename,
verbose);
if (!bootCodeFilename) {
CONSOLE_PRINTF( "%s: please specify name of boot image code file using \"-X:ic=<filename>\"\n", Me);
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
if (!bootDataFilename) {
CONSOLE_PRINTF( "%s: please specify name of boot image data file using \"-X:id=<filename>\"\n", Me);
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
if (!bootRMapFilename) {
CONSOLE_PRINTF( "%s: please specify name of boot image ref map file using \"-X:ir=<filename>\"\n", Me);
return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
}
ret = JNI_CreateJavaVM(&mainJavaVM, &mainJNIEnv, &initArgs);
if (ret < 0) {
ERROR_PRINTF("%s: Could not create the virtual machine; goodbye\n", Me);
sysExit(EXIT_STATUS_MISC_TROUBLE);
}
return 0;
}
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow) {
#else
int main(int argc, char* argv[]) {
#endif
// Do all the standard CEF setup stuff.
//-------------------------------------
void * sandbox_info = nullptr;
#ifdef _WIN32
// Enable High-DPI support on Windows 7 or newer.
CefEnableHighDPISupport();
// Read command line arguments.
CefMainArgs main_args(hInstance);
#else
// Read command line arguments.
CefMainArgs main_args(argc, argv);
#endif
// Create the process reference.
CefRefPtr<loot::LootApp> app(new loot::LootApp);
// Run the process.
int exit_code = CefExecuteProcess(main_args, app.get(), nullptr);
if (exit_code >= 0) {
// The sub-process has completed so return here.
return exit_code;
}
#ifdef _WIN32
// Check if LOOT is already running
//---------------------------------
HANDLE hMutex = ::OpenMutex(MUTEX_ALL_ACCESS, FALSE, L"LOOT.Shell.Instance");
if (hMutex != NULL) {
// An instance of LOOT is already running, so focus its window then quit.
HWND hWnd = ::FindWindow(NULL, L"LOOT");
::SetForegroundWindow(hWnd);
return 0;
} else {
//Create the mutex so that future instances will not run.
hMutex = ::CreateMutex(NULL, FALSE, L"LOOT.Shell.Instance");
}
#endif
// Handle command line args (not CEF args)
//----------------------------------------
processCommandLineArguments(app);
// Back to CEF
//------------
// Initialise CEF settings.
CefSettings cef_settings = GetCefSettings();
#ifndef _WIN32
// Install xlib error handlers so that the application won't be terminated
// on non-fatal errors.
XSetErrorHandler(XErrorHandlerImpl);
XSetIOErrorHandler(XIOErrorHandlerImpl);
#endif
// Initialize CEF.
CefInitialize(main_args, cef_settings, app.get(), sandbox_info);
// Run the CEF message loop. This will block until CefQuitMessageLoop() is called.
CefRunMessageLoop();
// Shut down CEF.
CefShutdown();
#ifdef _WIN32
// Release the program instance mutex.
if (hMutex != NULL)
ReleaseMutex(hMutex);
#endif
return 0;
}