G3D::_internal Namespace Reference

Classes
class	_BinaryFormat
class	_GetComputeType
class	BasicThread
class	Indirector
class	VN
class	VNTi
class	Welder
class	WeldHelper

Functions
bool	_handleDebugAssert_ (const char *expression, const std::string &message, const char *filename, int lineNumber, bool useGuiPrompt)
bool	_handleErrorCheck_ (const char *expression, const std::string &message, const char *filename, int lineNumber, bool useGuiPrompt)
void	_releaseInputGrab_ ()
void	_restoreInputGrab_ ()
const char **	smartEnumParseNames (const char *enumValList)
G3DSpecification &	g3dInitializationSpecification ()
static void	createErrorMessage (const char *expression, const std::string &message, const char *filename, int lineNumber, std::string &outTitle, std::string &outMessage)

Variables
AssertionHook	_debugHook = _handleDebugAssert_
AssertionHook	_failureHook = _handleErrorCheck_
ConsolePrintHook	_consolePrintHook
Set< std::string >	currentFilesUsed

Function Documentation

bool G3D::_internal::_handleDebugAssert_	(	const char *	expression,
		const std::string &	message,
		const char *	filename,
		int	lineNumber,
		bool	useGuiPrompt
	)

Pops up an assertion dialog or prints an assertion

ignoreAlways - return result of pressing the ignore button. useGuiPrompt - if true, shows a dialog

 {

 std::string dialogTitle = "Assertion Failure";
 std::string dialogText = "";
 createErrorMessage(expression, message, filename, lineNumber, dialogTitle, dialogText);

 #ifdef G3D_WINDOWS
 DWORD lastErr = GetLastError();
 postToClipboard(dialogText.c_str());
 debugPrintf("\n%s\n", dialogText.c_str());
 #endif

 const int cBreak = 0;
 const int cIgnore = 1;
 const int cAbort = 2;

 static const char* choices[] = {"Debug", "Ignore", "Exit"};

 // Log the error
 Log::common()->print(std::string("\n**************************\n\n") + dialogTitle + "\n" + dialogText);

 int result = G3D::prompt(dialogTitle.c_str(), dialogText.c_str(), (const char**)choices, 3, useGuiPrompt);

# ifdef G3D_WINDOWS
 // Put the incoming last error back.
 SetLastError(lastErr);
# endif

 switch (result) {
 // -1 shouldn't actually occur because it means 
 // that we're in release mode.
 case -1:
 case cBreak:
 return true;
 break;

 case cIgnore:
 return false;
 break;
 
 case cAbort:
 exit(-1);
 break;
 }

 // Should never get here
 return false;
}

Here is the call graph for this function:

bool G3D::_internal::_handleErrorCheck_	(	const char *	expression,
		const std::string &	message,
		const char *	filename,
		int	lineNumber,
		bool	useGuiPrompt
	)

 {

 std::string dialogTitle = "Critical Error";
 std::string dialogText = "";

 createErrorMessage(expression, message, filename, lineNumber, dialogTitle, dialogText);

 // Log the error
 Log::common()->print(std::string("\n**************************\n\n") + dialogTitle + "\n" + dialogText);
 #ifdef G3D_WINDOWS
 DWORD lastErr = GetLastError();
 (void)lastErr;
 postToClipboard(dialogText.c_str());
 debugPrintf("\n%s\n", dialogText.c_str());
 #endif

 static const char* choices[] = {"Ok"};

 const std::string& m = 
 std::string("An internal error has occured in this program and it will now close. "
 "The specific error is below. More information has been saved in \"") +
 Log::getCommonLogFilename() + "\".\n\n" + dialogText;

 int result = G3D::prompt("Error", m.c_str(), (const char**)choices, 1, useGuiPrompt);
 (void)result;

 return true;
}

Here is the call graph for this function:

void G3D::_internal::_releaseInputGrab_

(

)

Attempts to give the user back their mouse and keyboard if they were locked to the current window.

 {
 #ifdef G3D_WINDOWS

 GetCursorPos(&oldCursorPos);

 // Stop hiding the cursor if the application hid it.
 oldShowCursorCount = ShowCursor(true) - 1;

 if (oldShowCursorCount < -1) {
 for (int c = oldShowCursorCount; c < -1; ++c) {
 ShowCursor(true);
 }
 }

 // Set the default cursor in case the application
 // set the cursor to NULL.
 oldCursor = GetCursor();
 SetCursor(LoadCursor(NULL, IDC_ARROW));

 // Allow the cursor full access to the screen
 GetClipCursor(&oldCursorRect);
 ClipCursor(NULL);
 
 #elif defined(G3D_LINUX)
#if 0 /* G3DFIX: Disabled to avoid requirement for X11 libraries */
 if (x11Display != NULL) {
 XUngrabPointer(x11Display, CurrentTime);
 XUngrabKeyboard(x11Display, CurrentTime);
 if (x11Window != 0) {
 //XUndefineCursor(x11Display, x11Window);
 // TODO: Note that we leak this cursor; it should be
 // freed in the restore code.
 Cursor c = XCreateFontCursor(x11Display, 68);
 XDefineCursor(x11Display, x11Window, c);
 }
 XSync(x11Display, false); 
 XAllowEvents(x11Display, AsyncPointer, CurrentTime);
 XFlush(x11Display);
 }
#endif
 #elif defined(G3D_OSX)
 // TODO: OS X
 #endif
}

void G3D::_internal::_restoreInputGrab_

(

)

Attempts to restore the state before releaseInputGrab.

 {
 #ifdef G3D_WINDOWS

 // Restore the old clipping region
 ClipCursor(&oldCursorRect);

 SetCursorPos(oldCursorPos.x, oldCursorPos.y);

 // Restore the old cursor
 SetCursor(oldCursor);

 // Restore old visibility count
 if (oldShowCursorCount < 0) {
 for (int c = 0; c > oldShowCursorCount; --c) {
 ShowCursor(false);
 }
 }
 
 #elif defined(G3D_LINUX)
 // TODO: Linux
 #elif defined(G3D_OSX)
 // TODO: OS X
 #endif
}

static void G3D::_internal::createErrorMessage ( const char *  expression, const std::string &  message, const char *  filename, int  lineNumber, std::string &  outTitle, std::string &  outMessage  )

static

outTitle should be set before the call

 {

 std::string le = "";
 const char* newline = "\n";

 #ifdef G3D_WINDOWS
 newline = "\r\n";

 // The last error value. (Which is preserved across the call).
 DWORD lastErr = GetLastError();
 
 // The decoded message from FormatMessage
 LPTSTR formatMsg = NULL;

 if (NULL == formatMsg) {
 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
 FORMAT_MESSAGE_IGNORE_INSERTS |
 FORMAT_MESSAGE_FROM_SYSTEM,
 NULL,
 lastErr,
 0,
 (LPTSTR)&formatMsg,
 0,
 NULL);
 }

 // Make sure the message got translated into something.
 LPTSTR realLastErr;
 if (NULL != formatMsg) {
 realLastErr = formatMsg;
 } else {
 realLastErr = _T("Last error code does not exist.");
 }

 if (lastErr != 0) {
 le = G3D::format("Last Error (0x%08X): %s\r\n\r\n", lastErr, (LPCSTR)realLastErr);
 }

 // Get rid of the allocated memory from FormatMessage.
 if (NULL != formatMsg) {
 LocalFree((LPVOID)formatMsg);
 }

 char modulePath[MAX_PATH];
 GetModuleFileNameA(NULL, modulePath, MAX_PATH);

 const char* moduleName = strrchr(modulePath, '\\');
 outTitle = outTitle + string(" - ") + string(moduleName ? (moduleName + 1) : modulePath);

 #else
 (void)outTitle;
 #endif

 // Build the message.
 outMessage =
 G3D::format("%s%s%sExpression: %s%s%s:%d%s%s%s", 
 message.c_str(), newline, newline, expression, newline, 
 filename, lineNumber, newline, newline, le.c_str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

G3DSpecification& G3D::_internal::g3dInitializationSpecification

(

)

Set by initG3D, defined in initG3D.cpp

const char** G3D::_internal::smartEnumParseNames

(

const char *

enumValList

)

Variable Documentation

ConsolePrintHook G3D::_internal::_consolePrintHook

AssertionHook G3D::_internal::_debugHook = _handleDebugAssert_

AssertionHook G3D::_internal::_failureHook = _handleErrorCheck_

Set<std::string> G3D::_internal::currentFilesUsed