source-engine/utils/xbox/vxconsole/bug.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
//	BUG.CPP
//
//	Tracker bridge
//=====================================================================================//
#include "vxconsole.h"

// two bug systems, certain games are tied to a specific system
#define BUG_REPORTER_DLLNAME_1		"bugreporter.dll" 
#define BUG_REPORTER_DLLNAME_2		"bugreporter_filequeue.dll" 

#define BUG_REPOSITORY_URL			"\\\\fileserver\\bugs"
#define REPOSITORY_VALIDATION_FILE	"info.txt"
#define BUG_ERRORTITLE				"Bug Error"
#define BUG_COLOR					( RGB( 0,255,255 ) )

HWND			g_bug_hWnd;
HMODULE			g_bug_hBugReporter1;
HMODULE			g_bug_hBugReporter2;
IBugReporter	*g_bug_pReporter1;
IBugReporter	*g_bug_pReporter2;
IBugReporter	*g_bug_pReporter;
char			g_bug_szTitle[512];
char			g_bug_szDescription[1024];
char			g_bug_szOwner[128];
char			g_bug_szSeverity[128];
char			g_bug_szReportType[128];
char			g_bug_szPriority[128];
char			g_bug_szArea[128];
char			g_bug_szMapNumber[128];
int				g_bug_GameType;	
bool			g_bug_bActive;
char			g_bug_szScreenshot[MAX_PATH];
char			g_bug_szSavegame[MAX_PATH];
char			g_bug_szBSPName[MAX_PATH];
xrMapInfo_t		g_bug_mapInfo;
bool			g_bug_bCompressScreenshot;
bool			g_bug_bFirstCommand;

struct GameSystem_t
{
	const char *pFriendlyName;
	const char *pGameName;
	bool		bUsesSystem1;
};

GameSystem_t g_Games[] = 
{
	{ "Half Life 2",		"hl2",		true },
	{ "Episode 1",			"episodic",	true },
	{ "Episode 2",			"ep2",		true },
	{ "Portal",				"portal",	false },
	{ "Team Fortress 2",	"tf",		false },
};

static const char *GetRepositoryURL( void )
{
	const char *pURL = g_bug_pReporter->GetRepositoryURL();
	if ( pURL )
	{
		return pURL;
	}

	return BUG_REPOSITORY_URL;
}

const char *GetSubmissionURL( int bugid )
{
	const char *pURL = g_bug_pReporter->GetSubmissionURL();
	if ( pURL )
	{
		return pURL;
	}

	static char url[MAX_PATH];
	Q_snprintf( url, sizeof(url), "%s/%i", GetRepositoryURL(), bugid );

	return url;
}

//-----------------------------------------------------------------------------
//	BugReporter_SelectReporter
// 
//-----------------------------------------------------------------------------
bool BugReporter_SelectReporter( const char *pGameName )
{	
	int system = -1;
	for ( int i = 0; i < ARRAYSIZE( g_Games ); i++ )
	{
		if ( pGameName && !V_stricmp( g_Games[i].pGameName, pGameName ) )
		{
			system = i;
			break;
		}
	}

	if ( system == -1 )
	{
		// not found, slam to first
		system = 0;
	}

	// games uses different systems
	int oldGameType = g_bug_GameType;
	g_bug_GameType = system;
	if ( g_Games[system].bUsesSystem1 )
	{
		g_bug_pReporter = g_bug_pReporter1;
	}
	else
	{
		g_bug_pReporter = g_bug_pReporter2;
	}

	// force the game area
	if ( g_Games[g_bug_GameType].bUsesSystem1 )
	{
		strcpy( g_bug_szArea, "XBOX 360" );
	}
	else
	{
		strcpy( g_bug_szArea, g_Games[g_bug_GameType].pFriendlyName );
	}

	bool bChanged = ( oldGameType != g_bug_GameType );
	return bChanged;
}

//-----------------------------------------------------------------------------
//	BugReporter_LoadDLL
// 
//-----------------------------------------------------------------------------
IBugReporter *BugReporter_LoadDLL( const char *pDLLName, HMODULE *phModule )
{
	HMODULE hModule;
	IBugReporter *pBugReporter;

	*phModule = NULL;

	hModule = LoadLibrary( pDLLName );
	if ( !hModule )
	{
		Sys_MessageBox( BUG_ERRORTITLE, "Could not open '%s'\n", pDLLName );
		return NULL;
	}

	FARPROC pCreateInterface = GetProcAddress( hModule, CREATEINTERFACE_PROCNAME );
	if ( !pCreateInterface )
	{
		Sys_MessageBox( BUG_ERRORTITLE, "Missing '%s' interface for '%s'\n", CREATEINTERFACE_PROCNAME, pDLLName );
		return NULL;
	}

	pBugReporter = (IBugReporter *)((CreateInterfaceFn)pCreateInterface)( INTERFACEVERSION_BUGREPORTER, NULL );
	if ( !pBugReporter )
	{
		Sys_MessageBox( BUG_ERRORTITLE, "Missing interface '%s' for '%s'\n", INTERFACEVERSION_BUGREPORTER, pDLLName );
		return NULL;
	}

	bool bSuccess = pBugReporter->Init( NULL );
	if ( !bSuccess )
	{
		return NULL;
	}

	*phModule = hModule;
	return pBugReporter;
}

//-----------------------------------------------------------------------------
//	BugReporter_GetInterfaces
// 
//-----------------------------------------------------------------------------
bool BugReporter_GetInterfaces()
{
	if ( !g_bug_pReporter1 )
	{
		g_bug_pReporter1 = BugReporter_LoadDLL( BUG_REPORTER_DLLNAME_1, &g_bug_hBugReporter1 );
		if ( !g_bug_pReporter1 )
		{
			Sys_MessageBox( BUG_ERRORTITLE, "PVCS intialization failed!\n" );
		}
	}

	if ( !g_bug_pReporter2 )
	{
		g_bug_pReporter2 = BugReporter_LoadDLL( BUG_REPORTER_DLLNAME_2, &g_bug_hBugReporter2 );
		if ( !g_bug_pReporter2 )
		{
			Sys_MessageBox( BUG_ERRORTITLE, "BugBait intialization failed!\n" );
		}
	}

	if ( g_bug_pReporter1 )
	{
		// determine submitter name
		ConsoleWindowPrintf( BUG_COLOR, "Bug Reporter: PVCS Username: '%s' Display As: '%s'\n", g_bug_pReporter1->GetUserName(), g_bug_pReporter1->GetUserName_Display() );
	}
	if ( g_bug_pReporter2 )
	{
		// determine submitter name
		ConsoleWindowPrintf( BUG_COLOR, "Bug Reporter: BugBait Username: '%s' Display As: '%s'\n", g_bug_pReporter2->GetUserName(), g_bug_pReporter2->GetUserName_Display() );
	}
	
	BugReporter_SelectReporter( NULL );

	// See if we can see the bug repository right now
	char fn[MAX_PATH];
	V_snprintf( fn, sizeof( fn ), "%s/%s", GetRepositoryURL(), REPOSITORY_VALIDATION_FILE );
	Sys_NormalizePath( fn, false );

	FILE *fp = fopen( fn, "rb" );
	if ( fp )
	{
		ConsoleWindowPrintf( BUG_COLOR, "PVCS Repository '%s'\n", GetRepositoryURL() );
		fclose( fp );
	}
	else
	{
		Sys_MessageBox( BUG_ERRORTITLE, "Unable to see '%s', check permissions and network connectivity.\n", fn );
		return false;
	}

	// success
	return true;
}

//-----------------------------------------------------------------------------
//	BugReporter_FreeInterfaces
// 
//-----------------------------------------------------------------------------
void BugReporter_FreeInterfaces()
{
	if ( g_bug_pReporter1 )
	{
		g_bug_pReporter1->Shutdown();
		g_bug_pReporter1 = NULL;
		FreeLibrary( g_bug_hBugReporter1 );
		g_bug_hBugReporter1 = NULL;
	}

	if ( g_bug_pReporter2 )
	{
		g_bug_pReporter2->Shutdown();
		g_bug_pReporter2 = NULL;
		FreeLibrary( g_bug_hBugReporter2 );
		g_bug_hBugReporter2 = NULL;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Expanded data destination object for CUtlBuffer output
//-----------------------------------------------------------------------------
struct JPEGDestinationManager_t
{
	struct jpeg_destination_mgr pub; // public fields
	
	CUtlBuffer	*pBuffer;		// target/final buffer
	byte		*buffer;		// start of temp buffer
};

// choose an efficiently bufferaable size
#define OUTPUT_BUF_SIZE  4096	

//-----------------------------------------------------------------------------
// Purpose:  Initialize destination --- called by jpeg_start_compress
//  before any data is actually written.
//-----------------------------------------------------------------------------
void init_destination( j_compress_ptr cinfo )
{
	JPEGDestinationManager_t *dest = ( JPEGDestinationManager_t *) cinfo->dest;
	
	// Allocate the output buffer --- it will be released when done with image
	dest->buffer = (byte *)
		(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
		OUTPUT_BUF_SIZE * sizeof(byte));
	
	dest->pub.next_output_byte = dest->buffer;
	dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
}

//-----------------------------------------------------------------------------
// Purpose: Empty the output buffer --- called whenever buffer fills up.
// Input  : boolean - 
//-----------------------------------------------------------------------------
boolean empty_output_buffer( j_compress_ptr cinfo )
{
	JPEGDestinationManager_t *dest = ( JPEGDestinationManager_t * ) cinfo->dest;
	
	CUtlBuffer *buf = dest->pBuffer;

	// Add some data
	buf->Put( dest->buffer, OUTPUT_BUF_SIZE );
	
	dest->pub.next_output_byte = dest->buffer;
	dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
	
	return TRUE;
}

//-----------------------------------------------------------------------------
// Purpose: Terminate destination --- called by jpeg_finish_compress
// after all data has been written.  Usually needs to flush buffer.
//
// NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
// application must deal with any cleanup that should happen even
// for error exit.
//-----------------------------------------------------------------------------
void term_destination( j_compress_ptr cinfo )
{
	JPEGDestinationManager_t *dest = (JPEGDestinationManager_t *) cinfo->dest;
	size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
	
	CUtlBuffer *buf = dest->pBuffer;

	/* Write any data remaining in the buffer */
	if (datacount > 0) 
	{
		buf->Put( dest->buffer, datacount );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Set up functions for writing data to a CUtlBuffer instead of FILE *
//-----------------------------------------------------------------------------
void jpeg_UtlBuffer_dest( j_compress_ptr cinfo, CUtlBuffer *pBuffer )
{
	JPEGDestinationManager_t *dest;
	
	/* The destination object is made permanent so that multiple JPEG images
	* can be written to the same file without re-executing jpeg_stdio_dest.
	* This makes it dangerous to use this manager and a different destination
	* manager serially with the same JPEG object, because their private object
	* sizes may be different.  Caveat programmer.
	*/
	if (cinfo->dest == NULL) {	/* first time for this JPEG object? */
		cinfo->dest = (struct jpeg_destination_mgr *)
			(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
			sizeof(JPEGDestinationManager_t));
	}
	
	dest = ( JPEGDestinationManager_t * ) cinfo->dest;

	dest->pub.init_destination		= init_destination;
	dest->pub.empty_output_buffer	= empty_output_buffer;
	dest->pub.term_destination		= term_destination;
	dest->pBuffer					= pBuffer;
}

//-----------------------------------------------------------------------------
//	BugDlg_CompressScreenshot
//
//	Compress .BMP to .JPG, Delete .BMP
//-----------------------------------------------------------------------------
bool BugDlg_CompressScreenshot()
{
	if ( !g_bug_szScreenshot[0] )
	{
		return false;
	}

	bool bSuccess = false;
	HBITMAP hBitmap = NULL;
	HDC hDC = NULL;
	char *pBMPBits = NULL;

	CUtlBuffer buf( 0, 0 );

	hBitmap = (HBITMAP)LoadImage( NULL, g_bug_szScreenshot, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_DEFAULTSIZE | LR_LOADFROMFILE );
	if ( !hBitmap )
		goto cleanUp;

	hDC = CreateCompatibleDC( NULL );
	if ( !hDC )
		goto cleanUp;

	BITMAPINFO bitmapInfo;
	ZeroMemory( &bitmapInfo, sizeof( BITMAPINFO ) );
	bitmapInfo.bmiHeader.biSize = sizeof( BITMAPINFOHEADER );

	// populate the bmp info
	if ( !GetDIBits( hDC, hBitmap, 0, 0, NULL, &bitmapInfo, DIB_RGB_COLORS ) )
		goto cleanUp;

	pBMPBits = (char *)Sys_Alloc( bitmapInfo.bmiHeader.biSizeImage );
	if ( !pBMPBits )
		goto cleanUp;
	
	// could be bottom-up or top-down
	int nHeight = abs( bitmapInfo.bmiHeader.biHeight );

	if ( bitmapInfo.bmiHeader.biBitCount != 32 )
	{
		// unexpected format
		goto cleanUp;
	}

	if ( bitmapInfo.bmiHeader.biCompression != BI_RGB && bitmapInfo.bmiHeader.biCompression != BI_BITFIELDS )
	{
		// unexpected format
		goto cleanUp;
	}

	// don't want color masks
	bitmapInfo.bmiHeader.biCompression = BI_RGB;

	// get the raw bits
	if ( !GetDIBits( hDC, hBitmap, 0, nHeight, pBMPBits, &bitmapInfo, DIB_RGB_COLORS ) )
		goto cleanUp;

	JSAMPROW row_pointer[1]; 

	// compression data structure
	struct jpeg_compress_struct cinfo;
	ZeroMemory( &cinfo, sizeof( jpeg_compress_struct ) );

	// point at stderr
	struct jpeg_error_mgr jerr;
	cinfo.err = jpeg_std_error( &jerr );

	// create compressor
	jpeg_create_compress( &cinfo );

	// Hook CUtlBuffer to compression
	jpeg_UtlBuffer_dest( &cinfo, &buf );

	// image width and height, in pixels
	cinfo.image_width = bitmapInfo.bmiHeader.biWidth;
	cinfo.image_height = nHeight;
	cinfo.input_components = 3;
	cinfo.in_color_space = JCS_RGB;

	// Apply settings
	jpeg_set_defaults( &cinfo );
	jpeg_set_quality( &cinfo, 50, TRUE );

	// Start compressor
	jpeg_start_compress( &cinfo, TRUE);
	
	char *pRowBuffer = (char*)_alloca( bitmapInfo.bmiHeader.biWidth * 3 );
	row_pointer[0] = (JSAMPROW)pRowBuffer;

	// Write scanlines
	while ( cinfo.next_scanline < cinfo.image_height ) 
	{
		char *pSrc;
		if ( bitmapInfo.bmiHeader.biHeight < 0 )
		{
			// top down
			pSrc = &pBMPBits[cinfo.next_scanline * bitmapInfo.bmiHeader.biWidth * 4];
		}
		else
		{
			// bottom up
			pSrc = &pBMPBits[(nHeight-1 - cinfo.next_scanline) * bitmapInfo.bmiHeader.biWidth * 4];
		}
		
		// convert to BGR to RGB
		char *pDst = pRowBuffer;
		for ( int i=0; i<bitmapInfo.bmiHeader.biWidth; i++ )
		{
			pDst[0] = pSrc[2];
			pDst[1] = pSrc[1];
			pDst[2] = pSrc[0];
			pSrc += 4;
			pDst += 3;
		}		
		jpeg_write_scanlines( &cinfo, row_pointer, 1 );
	}

	// Finalize image
	jpeg_finish_compress( &cinfo );

	char jpgFilename[MAX_PATH];
	Sys_StripExtension( g_bug_szScreenshot, jpgFilename, sizeof( jpgFilename ) );
	Sys_AddExtension( ".jpg", jpgFilename, sizeof( jpgFilename ) );
	if ( !Sys_SaveFile( jpgFilename, buf.Base(), buf.TellMaxPut() ) )
		goto cleanUp;

	// remove the uncompressed version
	unlink( g_bug_szScreenshot );
	strcpy( g_bug_szScreenshot, jpgFilename );

	bSuccess = true;

cleanUp:
	if ( hBitmap )
		DeleteObject( hBitmap );
	if ( hDC )
		DeleteDC( hDC );
	if ( pBMPBits )
		Sys_Free( pBMPBits );

	return bSuccess;
}


//-----------------------------------------------------------------------------
//	BugDlg_GetAppData
//
//-----------------------------------------------------------------------------
void BugDlg_GetAppData( HWND hWnd )
{
	// clear stale data from previous query
	memset( &g_bug_mapInfo, 0, sizeof( g_bug_mapInfo ) );

	SetDlgItemText( hWnd, IDC_BUG_POSITION_LABEL, "" );
	SetDlgItemText( hWnd, IDC_BUG_ORIENTATION_LABEL, "" );
	SetDlgItemText( hWnd, IDC_BUG_MAP_LABEL, "" );
	SetDlgItemText( hWnd, IDC_BUG_BUILD_LABEL, "" );

	EnableWindow( GetDlgItem( hWnd, IDC_BUG_SAVEGAME ), false );
	EnableWindow( GetDlgItem( hWnd, IDC_BUG_INCLUDEBSP ), false );
	
	if ( g_connectedToApp )
	{
		// send to app, responds with position info
		if ( !g_bug_bFirstCommand )
		{
			// first command must send pause and status to be processed correctly
			g_bug_bFirstCommand = true;
			ProcessCommand( "pause ; status" );
		}
		else
		{
			ProcessCommand( "status" );
		}
	}
}

//-----------------------------------------------------------------------------
//	BugDlg_GetDataFileBase
//
//-----------------------------------------------------------------------------
void BugDlg_GetDataFileBase( char const *suffix, bool bLocalPath, char *buf, int bufsize )
{
	char	filepath[MAX_PATH];
	char	filename[MAX_PATH];

	struct tm t;

	time_t ltime;
	time( &ltime );
	tm *pTime = localtime( &ltime );
	memcpy( &t, pTime, sizeof( t ) );

	char who[128];
	strncpy( who, suffix, sizeof( who ) );
	_strlwr( who );

	if ( bLocalPath )
	{
		// add a qualified local path 
		// used as a gathering store before uploading to server
		strcpy( filepath, g_localPath );
		Sys_AddFileSeperator( filepath, sizeof( filepath ) );
		strcat( filepath, "bug/" );
		Sys_NormalizePath( filepath, false );
		Sys_CreatePath( filepath );
	}
	else
	{
		filepath[0] = '\0';
	}

	sprintf( filename, "%i_%02i_%02i_%s", t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, who );
	V_snprintf( buf, bufsize, "%s%s", filepath, filename );
}

//-----------------------------------------------------------------------------
//	BugDlg_CheckSubmit
//
//-----------------------------------------------------------------------------
bool BugDlg_CheckSubmit( HWND hWnd )
{
	bool bEnableSubmit = false;

	if ( g_Games[g_bug_GameType].bUsesSystem1 )
	{
		if ( g_bug_szTitle[0] &&
			g_bug_szDescription[0] &&
			g_bug_szSeverity[0] &&
			g_bug_szOwner[0] &&
			g_bug_szReportType[0] &&
			g_bug_szPriority[0] &&
			g_bug_szArea[0] )
		{
			bEnableSubmit = true;
		}
	}
	else
	{
		if ( g_bug_szTitle[0] &&
			g_bug_szDescription[0] &&
			g_bug_szSeverity[0] &&
			g_bug_szOwner[0] &&
			g_bug_szArea[0] &&
			g_bug_szMapNumber[0] )
		{
			bEnableSubmit = true;
		}
	}

	EnableWindow( GetDlgItem( hWnd, IDC_BUG_SUBMIT ), bEnableSubmit );

	return bEnableSubmit;
}

//-----------------------------------------------------------------------------
//	BugDlg_GetChanges
//
//-----------------------------------------------------------------------------
bool BugDlg_GetChanges( HWND hWnd )
{
	int curSel;

	// title
	GetDlgItemText( hWnd, IDC_BUG_TITLE, g_bug_szTitle, sizeof( g_bug_szTitle ) );

	// description
	GetDlgItemText( hWnd, IDC_BUG_DESCRIPTION, g_bug_szDescription, sizeof( g_bug_szDescription ) );

	// owner
	curSel = SendDlgItemMessage( hWnd, IDC_BUG_OWNER, CB_GETCURSEL, 0, 0 );
	if ( curSel == CB_ERR )
	{
		g_bug_szOwner[0] = '\0';
	}
	else
	{
		strncpy( g_bug_szOwner, g_bug_pReporter->GetDisplayName( curSel ), sizeof( g_bug_szOwner ) );
		g_bug_szOwner[sizeof( g_bug_szOwner )-1] = '\0';

		if ( V_stristr( g_bug_szOwner, "unassigned" ) )
		{
			g_bug_szOwner[0] = '\0';
		}
	}

	// severity
	curSel = SendDlgItemMessage( hWnd, IDC_BUG_SEVERITY, CB_GETCURSEL, 0, 0 );
	if ( curSel == CB_ERR )
	{
		g_bug_szSeverity[0] = '\0';
	}
	else
	{
		V_strncpy( g_bug_szSeverity, g_bug_pReporter->GetSeverity( curSel ), sizeof( g_bug_szSeverity ) );
	}

	// report type
	curSel = SendDlgItemMessage( hWnd, IDC_BUG_REPORTTYPE, CB_GETCURSEL, 0, 0 );
	if ( curSel == CB_ERR )
	{
		g_bug_szReportType[0] = '\0';
	}
	else
	{
		V_strncpy( g_bug_szReportType, g_bug_pReporter->GetReportType( curSel ), sizeof( g_bug_szReportType ) );
	}

	// priority
	curSel = SendDlgItemMessage( hWnd, IDC_BUG_PRIORITY, CB_GETCURSEL, 0, 0 );
	if ( curSel == CB_ERR )
	{
		g_bug_szPriority[0] = '\0';
	}
	else
	{
		V_strncpy( g_bug_szPriority, g_bug_pReporter->GetPriority( curSel ), sizeof( g_bug_szPriority ) );
	}

	// area
	curSel = SendDlgItemMessage( hWnd, IDC_BUG_AREA, CB_GETCURSEL, 0, 0 );
	int areaIndex = 0;
	if ( curSel == CB_ERR )
	{
		g_bug_szArea[0] = '\0';
	}
	else
	{
		V_strncpy( g_bug_szArea, g_bug_pReporter->GetArea( curSel ), sizeof( g_bug_szArea ) );
		areaIndex = curSel;
	}

	if ( !g_Games[g_bug_GameType].bUsesSystem1 )
	{
		// map number
		curSel = SendDlgItemMessage( hWnd, IDC_BUG_MAPNUMBER, CB_GETCURSEL, 0, 0 );
		if ( curSel == CB_ERR )
		{
			g_bug_szMapNumber[0] = '\0';
		}
		else
		{
			V_strncpy( g_bug_szMapNumber, g_bug_pReporter->GetLevel( areaIndex, curSel ), sizeof( g_bug_szMapNumber ) );
		}
	}

	g_bug_bCompressScreenshot = ( IsDlgButtonChecked( hWnd, IDC_BUG_COMPRESS_SCREENSHOT ) != 0 );

	BugDlg_CheckSubmit( hWnd );

	// success
	return true;
}

//-----------------------------------------------------------------------------
//	BugDlg_UpdateReporter
//
//-----------------------------------------------------------------------------
bool BugDlg_UpdateReporter( HWND hWnd )
{
	// game
	int newGameType;
	int curSel = SendDlgItemMessage( hWnd, IDC_BUG_GAME, CB_GETCURSEL, 0, 0 );
	if ( curSel == CB_ERR )
	{
		newGameType = 0;
	}
	else
	{
		newGameType = curSel;
	}

	return BugReporter_SelectReporter( g_Games[newGameType].pGameName );
}

//-----------------------------------------------------------------------------
//	BugDlg_Populate
//
//-----------------------------------------------------------------------------
void BugDlg_Populate( HWND hWnd )
{
	int i;
	int	count;
	int	curSel;

	g_bug_bActive = false;

	// title
	SendDlgItemMessage( hWnd, IDC_BUG_TITLE, EM_LIMITTEXT, sizeof( g_bug_szTitle )-1, 0 ); 
	SetDlgItemText( hWnd, IDC_BUG_TITLE, g_bug_szTitle );

	// description
	SendDlgItemMessage( hWnd, IDC_BUG_DESCRIPTION, EM_LIMITTEXT, sizeof( g_bug_szDescription )-1, 0 ); 
	SetDlgItemText( hWnd, IDC_BUG_DESCRIPTION, g_bug_szDescription );

	// submitter
	SetDlgItemText( hWnd, IDC_BUG_SUBMITTER_LABEL, g_bug_pReporter->GetUserName_Display() );

	// owner
	SendDlgItemMessage( hWnd, IDC_BUG_OWNER, CB_RESETCONTENT, 0, 0 );
	count = g_bug_pReporter->GetDisplayNameCount();
	for ( i = 0; i < count; i++ )
	{
		SendDlgItemMessage( hWnd, IDC_BUG_OWNER, CB_ADDSTRING, 0, (LPARAM)(LPCSTR)g_bug_pReporter->GetDisplayName( i ) );
	}
	if ( count )
	{
		curSel = SendDlgItemMessage( hWnd, IDC_BUG_OWNER, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPCSTR)g_bug_szOwner );
		if ( curSel != CB_ERR )
		{
			SendDlgItemMessage( hWnd, IDC_BUG_OWNER, CB_SETCURSEL, curSel, 0 );
		}
	}

	// severity
	SendDlgItemMessage( hWnd, IDC_BUG_SEVERITY, CB_RESETCONTENT, 0, 0 );
	count = g_bug_pReporter->GetSeverityCount();
	for ( i = 0; i < count; i++ )
	{
		SendDlgItemMessage( hWnd, IDC_BUG_SEVERITY, CB_ADDSTRING, 0, (LPARAM)(LPCSTR)g_bug_pReporter->GetSeverity( i ) );
	}
	if ( count )
	{
		curSel = SendDlgItemMessage( hWnd, IDC_BUG_SEVERITY, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPCSTR)g_bug_szSeverity );
		if ( curSel != CB_ERR )
		{
			SendDlgItemMessage( hWnd, IDC_BUG_SEVERITY, CB_SETCURSEL, curSel, 0 );
		}
	}

	// report type
	SendDlgItemMessage( hWnd, IDC_BUG_REPORTTYPE, CB_RESETCONTENT, 0, 0 );
	EnableWindow( GetDlgItem( hWnd, IDC_BUG_REPORTTYPE ), g_Games[g_bug_GameType].bUsesSystem1 );
	if ( g_Games[g_bug_GameType].bUsesSystem1 )
	{
		count = g_bug_pReporter->GetReportTypeCount();
		for ( i = 0; i < count; i++ )
		{
			SendDlgItemMessage( hWnd, IDC_BUG_REPORTTYPE, CB_ADDSTRING, 0, (LPARAM)(LPCSTR)g_bug_pReporter->GetReportType( i ) );
		}
		if ( count )
		{
			curSel = SendDlgItemMessage( hWnd, IDC_BUG_REPORTTYPE, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPCSTR)g_bug_szReportType );
			if ( curSel != CB_ERR )
			{
				SendDlgItemMessage( hWnd, IDC_BUG_REPORTTYPE, CB_SETCURSEL, curSel, 0 );
			}
		}
	}

	// priority
	SendDlgItemMessage( hWnd, IDC_BUG_PRIORITY, CB_RESETCONTENT, 0, 0 );
	EnableWindow( GetDlgItem( hWnd, IDC_BUG_PRIORITY ), g_Games[g_bug_GameType].bUsesSystem1 );
	if ( g_Games[g_bug_GameType].bUsesSystem1 )
	{
		count = g_bug_pReporter->GetPriorityCount();
		for ( i = 0; i < count; i++ )
		{
			SendDlgItemMessage( hWnd, IDC_BUG_PRIORITY, CB_ADDSTRING, 0, (LPARAM)(LPCSTR)g_bug_pReporter->GetPriority( i ) );
		}
		if ( count )
		{
			curSel = SendDlgItemMessage( hWnd, IDC_BUG_PRIORITY, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPCSTR)g_bug_szPriority );
			if ( curSel != CB_ERR )
			{
				SendDlgItemMessage( hWnd, IDC_BUG_PRIORITY, CB_SETCURSEL, curSel, 0 );
			}
		}
	}

	// area
	SendDlgItemMessage( hWnd, IDC_BUG_AREA, CB_RESETCONTENT, 0, 0 );
	count = g_bug_pReporter->GetAreaCount();
	int areaIndex = 0;
	for ( i = 0; i < count; i++ )
	{
		SendDlgItemMessage( hWnd, IDC_BUG_AREA, CB_ADDSTRING, 0, (LPARAM)(LPCSTR)g_bug_pReporter->GetArea( i ) );
	}
	if ( count )
	{
		curSel = SendDlgItemMessage( hWnd, IDC_BUG_AREA, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPCSTR)g_bug_szArea );
		if ( curSel != CB_ERR )
		{
			SendDlgItemMessage( hWnd, IDC_BUG_AREA, CB_SETCURSEL, curSel, 0 );
			areaIndex = curSel;
		}
	}

	// map name or number
	SendDlgItemMessage( hWnd, IDC_BUG_MAPNUMBER, CB_RESETCONTENT, 0, 0 );
	EnableWindow( GetDlgItem( hWnd, IDC_BUG_MAPNUMBER ), g_Games[g_bug_GameType].bUsesSystem1 == false );
	if ( !g_Games[g_bug_GameType].bUsesSystem1 )
	{
		// new system has map names
		count = g_bug_pReporter->GetLevelCount( areaIndex );
		for ( i = 0; i < count; i++ )
		{
			SendDlgItemMessage( hWnd, IDC_BUG_MAPNUMBER, CB_ADDSTRING, 0, (LPARAM)(LPCSTR)g_bug_pReporter->GetLevel( areaIndex, i ) );
		}
	}
	if ( count )
	{
		curSel = SendDlgItemMessage( hWnd, IDC_BUG_MAPNUMBER, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPCSTR)g_bug_szMapNumber );
		if ( curSel != CB_ERR )
		{
			SendDlgItemMessage( hWnd, IDC_BUG_MAPNUMBER, CB_SETCURSEL, curSel, 0 );
		}
	}

	// game
	SendDlgItemMessage( hWnd, IDC_BUG_GAME, CB_RESETCONTENT, 0, 0 );
	count = ARRAYSIZE( g_Games );
	for ( i = 0; i < count; i++ )
	{
		SendDlgItemMessage( hWnd, IDC_BUG_GAME, CB_ADDSTRING, 0, (LPARAM)(LPCSTR)g_Games[i].pFriendlyName );
	}
	if ( count )
	{
		curSel = SendDlgItemMessage( hWnd, IDC_BUG_GAME, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPCSTR)g_Games[g_bug_GameType].pFriendlyName );
		if ( curSel != CB_ERR )
		{
			SendDlgItemMessage( hWnd, IDC_BUG_GAME, CB_SETCURSEL, curSel, 0 );
		}
	}

	CheckDlgButton( hWnd, IDC_BUG_COMPRESS_SCREENSHOT, g_bug_bCompressScreenshot ? BST_CHECKED : BST_UNCHECKED );

	SetDlgItemText( hWnd, IDC_BUG_TAKESHOT_LABEL, g_bug_szScreenshot );
	SetDlgItemText( hWnd, IDC_BUG_SAVEGAME_LABEL, g_bug_szSavegame );
	SetDlgItemText( hWnd, IDC_BUG_INCLUDEBSP_LABEL, g_bug_szBSPName );
	SetDlgItemText( hWnd, IDC_BUG_INCLUDEVMF_LABEL, "" );

	EnableWindow( GetDlgItem( hWnd, IDC_BUG_TAKESHOT ), g_connectedToApp );
	EnableWindow( GetDlgItem( hWnd, IDC_BUG_INCLUDEVMF ), false );
	EnableWindow( GetDlgItem( hWnd, IDC_BUG_UPDATE ), g_connectedToApp );

	BugDlg_GetAppData( hWnd );

	BugDlg_CheckSubmit( hWnd );

	g_bug_bActive = true;
}

//-----------------------------------------------------------------------------
//	BugDlg_TakeScreenshot
//
//-----------------------------------------------------------------------------
void BugDlg_TakeScreenshot( HWND hWnd )
{
	char	buff[1024];

	SetDlgItemText( hWnd, IDC_BUG_TAKESHOT_LABEL, "Working..." );

	BugDlg_GetDataFileBase( g_bug_pReporter->GetUserName(), true, g_bug_szScreenshot, sizeof( g_bug_szScreenshot ) );
	strcat( g_bug_szScreenshot, ".bmp" );

	// remove local version
	unlink( g_bug_szScreenshot );

	sprintf( buff, "*screenshot \"%s\"", g_bug_szScreenshot );
	if ( !ProcessCommand( buff  ) )
	{
		g_bug_szScreenshot[0] = '\0';
	}

	SetDlgItemText( hWnd, IDC_BUG_TAKESHOT_LABEL, g_bug_szScreenshot );
}

//-----------------------------------------------------------------------------
//	BugDlg_SaveGame
//
//-----------------------------------------------------------------------------
void BugDlg_SaveGame( HWND hWnd )
{
	char	buff[1024];
	char	savename[MAX_PATH];
	char	remoteFile[MAX_PATH];

	if ( !g_bug_mapInfo.savePath[0] )
	{
		return;
	}

	SetDlgItemText( hWnd, IDC_BUG_SAVEGAME_LABEL, "Working..." );

	BugDlg_GetDataFileBase( g_bug_pReporter->GetUserName(), true, g_bug_szSavegame, sizeof( g_bug_szSavegame ) );
	Sys_StripPath( g_bug_szSavegame, savename, sizeof( savename ) );
	strcat( g_bug_szSavegame, ".360.sav" );

	sprintf( remoteFile, "%s\\%s.360.sav", g_bug_mapInfo.savePath, savename );

	// delete file locally
	unlink( g_bug_szSavegame );

	// delete file remotely
	DmDeleteFile( remoteFile, false );

	// save, and wait to ensure async completes
	sprintf( buff, "save \"%s\" notmostrecent wait", savename );
	if ( !ProcessCommand( buff ) )
	{
		// failed
		g_bug_szSavegame[0] = '\0';
	}
	else
	{
		DM_FILE_ATTRIBUTES fileAttributes;
		for (int i=0; i<5; i++)
		{
			// wait for the save file to appear
			HRESULT hr = DmGetFileAttributes( remoteFile, &fileAttributes );
			if ( hr == XBDM_NOERR )
				break;

			// wait for it
			Sleep( 1000 );
		}

		HRESULT hr = DmReceiveFile( g_bug_szSavegame, remoteFile );
		if ( hr != XBDM_NOERR )
		{
			// failed
			g_bug_szSavegame[0] = '\0';
		}
	}

	SetDlgItemText( hWnd, IDC_BUG_SAVEGAME_LABEL, g_bug_szSavegame );
}

//-----------------------------------------------------------------------------
//	BugDlg_IncludeBSP
//
//-----------------------------------------------------------------------------
void BugDlg_IncludeBSP( HWND hWnd )
{
	if ( !g_bug_mapInfo.mapPath[0] )
	{
		return;
	}

	SetDlgItemText( hWnd, IDC_BUG_INCLUDEBSP_LABEL, "Working..." );

	BugDlg_GetDataFileBase( g_bug_pReporter->GetUserName(), true, g_bug_szBSPName, sizeof( g_bug_szBSPName ) );
	strcat( g_bug_szBSPName, ".360.bsp" );

	// remove local version
	unlink( g_bug_szBSPName );

	// get the file locally
	HRESULT hr = DmReceiveFile( g_bug_szBSPName, g_bug_mapInfo.mapPath );
	if ( hr != XBDM_NOERR )
	{
		// failed
		g_bug_szBSPName[0] = '\0';
	}

	SetDlgItemText( hWnd, IDC_BUG_INCLUDEBSP_LABEL, g_bug_szBSPName );
}

//-----------------------------------------------------------------------------
//	BugDlg_ResetAndPopulate
//
//-----------------------------------------------------------------------------
void BugDlg_ResetAndPopulate( HWND hWnd, bool bFullReset = true )
{
	// reset all fields
	if ( bFullReset )
	{
		g_bug_szTitle[0] = '\0';
		g_bug_szDescription[0] = '\0';
	}
	g_bug_szOwner[0] = '\0';
	g_bug_szSeverity[0] = '\0';
	g_bug_szReportType[0] = '\0';
	g_bug_szPriority[0] = '\0';
	g_bug_szMapNumber[0] = '\0';

	if ( bFullReset )
	{
		g_bug_szScreenshot[0] = '\0';
		g_bug_szSavegame[0] = '\0';
		g_bug_szBSPName[0] = '\0';
	}

	g_bug_bCompressScreenshot = true;

	memset( &g_bug_mapInfo, 0, sizeof( g_bug_mapInfo ) );

	// populate with reset fields
	BugDlg_Populate( hWnd );
}

//-----------------------------------------------------------------------------
//	BugDlg_Setup
//
//-----------------------------------------------------------------------------
void BugDlg_Setup( HWND hWnd )
{
	g_bug_hWnd = hWnd;

	// clear stale data from app
	g_bug_bFirstCommand = false;
	memset( &g_bug_mapInfo, 0, sizeof( g_bug_mapInfo ) );

	// always reset these fields
	g_bug_szTitle[0] = '\0';
	g_bug_szDescription[0] = '\0';
	g_bug_szScreenshot[0] = '\0';
	g_bug_szSavegame[0] = '\0';
	g_bug_szBSPName[0] = '\0';

	g_bug_bCompressScreenshot = true;

	memset( &g_bug_mapInfo, 0, sizeof( g_bug_mapInfo ) );

	BugDlg_Populate( hWnd );
}

//-----------------------------------------------------------------------------
//	BugDlg_UploadFile
//
//-----------------------------------------------------------------------------
bool BugDlg_UploadFile( char const *pLocalName, char const *pRemoteName, bool bDeleteLocal )
{
	FILE	*fp;
	int		len;
	void	*pLocalData;

	ConsoleWindowPrintf( BUG_COLOR, "Uploading %s to %s\n", pLocalName, pRemoteName );

	len = Sys_LoadFile( pLocalName, &pLocalData );
	if ( !pLocalData || !len )
	{
		ConsoleWindowPrintf( XBX_CLR_RED, "UploadFile: Unable to open local path '%s'\n", pLocalName );
		return false;
	}

	Sys_CreatePath( pRemoteName );

	fp = fopen( pRemoteName, "wb" );
	if ( !fp )
	{
		ConsoleWindowPrintf( XBX_CLR_RED, "UploadFile: Unable to open remote path '%s'\n", pRemoteName );
		Sys_Free( pLocalData );
		return false;
	}

	fwrite( pLocalData, len, 1, fp );

	fclose( fp );
	Sys_Free( pLocalData );

	if ( bDeleteLocal )
	{
		unlink( pLocalName );
	}

	return true;
}

//-----------------------------------------------------------------------------
//	BugDlg_UploadBugSubmission
//
//	Expects fully qualified source paths
//-----------------------------------------------------------------------------
bool BugDlg_UploadBugSubmission( int bugID, char const *pSavefile, char const *pScreenshot, char const *pBspFile, char const *pVmfFile )
{
	char	szFilename[MAX_PATH];
	char	szLocalfile[MAX_PATH];
	char	szRemotefile[MAX_PATH];
	bool	bSuccess = true;

	if ( pSavefile && pSavefile[0] )
	{
		V_snprintf( szLocalfile, sizeof( szLocalfile ), "%s", pSavefile );
		Sys_StripPath( pSavefile, szFilename, sizeof( szFilename ) );
		V_snprintf( szRemotefile, sizeof( szRemotefile ), "%s/%s", GetSubmissionURL( bugID ), szFilename );
		Sys_NormalizePath( szLocalfile, false );
		Sys_NormalizePath( szRemotefile, false );

		if ( !BugDlg_UploadFile( szLocalfile, szRemotefile, false ) )
		{
			bSuccess = false;
		}
	}

	if ( pScreenshot && pScreenshot[0] )
	{
		V_snprintf( szLocalfile, sizeof( szLocalfile ), "%s", pScreenshot );
		Sys_StripPath( pScreenshot, szFilename, sizeof( szFilename ) );
		V_snprintf( szRemotefile, sizeof( szRemotefile ), "%s/%s", GetSubmissionURL( bugID ), szFilename );
		Sys_NormalizePath( szLocalfile, false );
		Sys_NormalizePath( szRemotefile, false );
		
		if ( !BugDlg_UploadFile( szLocalfile, szRemotefile, true ) )
		{
			bSuccess = false;
		}
	}

	if ( pBspFile && pBspFile[0] )
	{
		V_snprintf( szLocalfile, sizeof( szLocalfile ), "%s", pBspFile );
		Sys_StripPath( pBspFile, szFilename, sizeof( szFilename ) );
		V_snprintf( szRemotefile, sizeof( szRemotefile ), "%s/%s", GetSubmissionURL( bugID ), szFilename );
		Sys_NormalizePath( szLocalfile, false );
		Sys_NormalizePath( szRemotefile, false );
		
		if ( !BugDlg_UploadFile( szLocalfile, szRemotefile, true ) )
		{
			bSuccess = false;
		}
	}

	return bSuccess;
}

//-----------------------------------------------------------------------------
//	BugDlg_Submit
//
//-----------------------------------------------------------------------------
bool BugDlg_Submit( HWND hWnd )
{
	char	title[1024];
	char	miscInfo[1024];
	char	basename[MAX_PATH];
	char	filename[MAX_PATH];
	char	positionName[MAX_PATH];
	char	orientationName[MAX_PATH];
	char	buildName[MAX_PATH];
	char	mapName[MAX_PATH];
	bool	bSuccess = false;

	sprintf( positionName, "%f %f %f", g_bug_mapInfo.position[0], g_bug_mapInfo.position[1], g_bug_mapInfo.position[2] );
	SetDlgItemText( g_bug_hWnd, IDC_BUG_POSITION_LABEL, positionName );

	sprintf( orientationName, "%f %f %f", g_bug_mapInfo.angle[0], g_bug_mapInfo.angle[1], g_bug_mapInfo.angle[2] );
	SetDlgItemText( g_bug_hWnd, IDC_BUG_ORIENTATION_LABEL, orientationName );

	sprintf( buildName, "%d", g_bug_mapInfo.build );
	SetDlgItemText( g_bug_hWnd, IDC_BUG_BUILD_LABEL, buildName );

	V_FileBase( g_bug_mapInfo.mapPath, mapName, sizeof( mapName ) );
	char *pExtension = V_stristr( mapName, ".bsp" );
	if ( pExtension )
	{
		*pExtension = '\0';
	}
	pExtension = V_stristr( mapName, ".360" );
	if ( pExtension )
	{
		*pExtension = '\0';
	}

	V_snprintf( miscInfo, sizeof( miscInfo ), "skill %d", g_bug_mapInfo.skill );

	// Stuff bug data files up to server
	g_bug_pReporter->StartNewBugReport();

	g_bug_pReporter->SetOwner( g_bug_pReporter->GetUserNameForDisplayName( g_bug_szOwner ) );
	g_bug_pReporter->SetSubmitter( NULL );

	if ( mapName[0] )
		V_snprintf( title, sizeof( title ), "%s: %s", mapName, g_bug_szTitle );
	else
		V_snprintf( title, sizeof( title ), "%s", g_bug_szTitle );
	g_bug_pReporter->SetTitle( title );

	g_bug_pReporter->SetDescription( g_bug_szDescription );
	g_bug_pReporter->SetLevel( mapName );
	g_bug_pReporter->SetPosition( positionName );
	g_bug_pReporter->SetOrientation( orientationName );
	g_bug_pReporter->SetBuildNumber( buildName );

	g_bug_pReporter->SetSeverity( g_bug_szSeverity );
	g_bug_pReporter->SetPriority( g_bug_szPriority );
	g_bug_pReporter->SetArea( g_bug_szArea );
	g_bug_pReporter->SetMapNumber( g_bug_szMapNumber );
	g_bug_pReporter->SetReportType( g_bug_szReportType );
	g_bug_pReporter->SetMiscInfo( miscInfo );

	g_bug_pReporter->SetDriverInfo( "" );
	g_bug_pReporter->SetExeName( "" );
	g_bug_pReporter->SetGameDirectory( "" );
	g_bug_pReporter->SetRAM( 0 );
	g_bug_pReporter->SetCPU( 0 );
	g_bug_pReporter->SetProcessor( "" );
	g_bug_pReporter->SetDXVersion( 0, 0, 0, 0 );
	g_bug_pReporter->SetOSVersion( "" );
	g_bug_pReporter->ResetIncludedFiles();
	g_bug_pReporter->SetZipAttachmentName( "" );

	if ( g_bug_szScreenshot[0] )
	{
		if ( g_bug_bCompressScreenshot )
		{
			BugDlg_CompressScreenshot();
		}

		// strip the fully qualified path into filename only
		Sys_StripPath( g_bug_szScreenshot, basename, sizeof( basename ) );
		V_snprintf( filename, sizeof( filename ), "%s/BugId/%s", GetRepositoryURL(), basename );
		Sys_NormalizePath( filename, false );
		g_bug_pReporter->SetScreenShot( filename );
	}

	if ( g_bug_szSavegame[0] )
	{
		// strip the fully qualified path into filename only
		Sys_StripPath( g_bug_szSavegame, basename, sizeof( basename ) );
		V_snprintf( filename, sizeof( filename ), "%s/BugId/%s", GetRepositoryURL(), basename );
		Sys_NormalizePath( filename, false );
		g_bug_pReporter->SetSaveGame( filename );
	}

	if ( g_bug_szBSPName[0] )
	{
		// strip the fully qualified path into filename only
		Sys_StripPath( g_bug_szBSPName, basename, sizeof( basename ) );
		V_snprintf( filename, sizeof( filename ), "%s/BugId/%s", GetRepositoryURL(), basename );
		Sys_NormalizePath( filename, false );
		g_bug_pReporter->SetBSPName( filename );
	}
	
	int bugID = -1;

	bSuccess = g_bug_pReporter->CommitBugReport( bugID );
	if ( bSuccess )
	{
		if ( !BugDlg_UploadBugSubmission( bugID, g_bug_szSavegame, g_bug_szScreenshot, g_bug_szBSPName, NULL ) )
		{
			Sys_MessageBox( BUG_ERRORTITLE, "Unable to upload files to bug repository!\n" );
			bSuccess = false;
		}
	}
	else
	{
		Sys_MessageBox( BUG_ERRORTITLE, "Unable to post bug report to database!\n" );
	}

	if ( bSuccess )
	{
		if ( g_Games[g_bug_GameType].bUsesSystem1 )
		{
			ConsoleWindowPrintf( BUG_COLOR, "Bug Reporter: PVCS submission succeeded for bug! (%d)\n", bugID );
		}
		else
		{
			ConsoleWindowPrintf( BUG_COLOR, "Bug Reporter: BugBait submission succeeded for bug!\n" );
		}
	}
	else
	{
		ConsoleWindowPrintf( XBX_CLR_RED, "Bug Reporter: Submission failed\n" );
	}

	return bSuccess;
}

//-----------------------------------------------------------------------------
//	BugDlg_Proc
//
//-----------------------------------------------------------------------------
BOOL CALLBACK BugDlg_Proc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) 
{ 
	switch ( message ) 
	{ 
		case WM_INITDIALOG:
			BugDlg_Setup( hwnd );
			return ( TRUE );

		case WM_COMMAND: 
            switch ( LOWORD( wParam ) ) 
            {
				case IDC_BUG_TAKESHOT:
					BugDlg_TakeScreenshot( hwnd );
					break;

				case IDC_BUG_SAVEGAME:
					BugDlg_SaveGame( hwnd );
					break;

				case IDC_BUG_INCLUDEBSP:
					BugDlg_IncludeBSP( hwnd );
					break;

				case IDC_BUG_INCLUDEVMF:
					// not implemented, no reason to
					break;

				case IDC_BUG_CLEARFORM: 
					BugDlg_ResetAndPopulate( hwnd );
					return TRUE;

				case IDC_BUG_UPDATE: 
					BugDlg_GetAppData( hwnd );
					return TRUE;

				case IDC_BUG_OWNER:
				case IDC_BUG_SEVERITY:
				case IDC_BUG_REPORTTYPE:
				case IDC_BUG_PRIORITY:
				case IDC_BUG_AREA:
				case IDC_BUG_MAPNUMBER:
					if ( g_bug_bActive && HIWORD( wParam ) == CBN_CLOSEUP  )
					{
						BugDlg_GetChanges( hwnd );
						return TRUE;
					}
					break;

				case IDC_BUG_GAME:
					if ( HIWORD( wParam ) == CBN_CLOSEUP )
					{
						if ( BugDlg_UpdateReporter( hwnd ) )
						{
							// reporter changed, clear critical parts of form
							BugDlg_ResetAndPopulate( hwnd, false );
						}
						return TRUE;
					}
					break;

				case IDC_BUG_TITLE:
				case IDC_BUG_DESCRIPTION:
					if ( g_bug_bActive && HIWORD( wParam ) == EN_CHANGE  )
					{
						BugDlg_GetChanges( hwnd );
						return TRUE;
					}
					break;

				case IDC_BUG_COMPRESS_SCREENSHOT:
					BugDlg_GetChanges( hwnd );
					return TRUE;

				case IDC_BUG_SUBMIT: 
					if ( !BugDlg_Submit( hwnd ) )
						break;
					// fall through
				case IDCANCEL:
				case IDC_CANCEL: 
					if ( g_connectedToApp && g_bug_bFirstCommand )
					{
						ProcessCommand( "unpause" );
					}
					EndDialog( hwnd, wParam );
					return ( TRUE ); 
			}
			break; 
	}
	return ( FALSE ); 
} 

//-----------------------------------------------------------------------------
//	BugDlg_SaveConfig
// 
//-----------------------------------------------------------------------------
void BugDlg_SaveConfig()
{
	Sys_SetRegistryString( "bug_owner", g_bug_szOwner );
	Sys_SetRegistryString( "bug_severity", g_bug_szSeverity );
	Sys_SetRegistryString( "bug_reporttype", g_bug_szReportType );
	Sys_SetRegistryString( "bug_priority", g_bug_szPriority );
	Sys_SetRegistryInteger( "bug_gametype", g_bug_GameType );
}

//-----------------------------------------------------------------------------
//	BugDlg_LoadConfig	
// 
//-----------------------------------------------------------------------------
void BugDlg_LoadConfig()
{
	// get our config
	Sys_GetRegistryString( "bug_owner", g_bug_szOwner, "", sizeof( g_bug_szOwner ) );
	Sys_GetRegistryString( "bug_severity", g_bug_szSeverity, "", sizeof( g_bug_szSeverity ) );
	Sys_GetRegistryString( "bug_reporttype", g_bug_szReportType, "", sizeof( g_bug_szReportType ) );
	Sys_GetRegistryString( "bug_priority", g_bug_szPriority, "", sizeof( g_bug_szPriority ) );
	Sys_GetRegistryInteger( "bug_gametype", 0, g_bug_GameType );

	// start with expected reporter
	BugReporter_SelectReporter( g_Games[g_bug_GameType].pGameName );
}

//-----------------------------------------------------------------------------
//	BugDlg_Open
//
//-----------------------------------------------------------------------------
void BugDlg_Open( void )
{
	int		result;
	
	// need access to bug databases via DLLs
	if ( !BugReporter_GetInterfaces() )
	{
		return;
	}

	BugDlg_LoadConfig();

	result = DialogBox( g_hInstance, MAKEINTRESOURCE( IDD_BUG ), g_hDlgMain, ( DLGPROC )BugDlg_Proc );	
	if ( LOWORD( result ) == IDC_BUG_SUBMIT )
	{
		BugDlg_SaveConfig();
	}

	g_bug_hWnd = NULL;
}

//-----------------------------------------------------------------------------
//	BugDlg_Init
// 
//-----------------------------------------------------------------------------
bool BugDlg_Init()
{
	return true;
}

//-----------------------------------------------------------------------------
// rc_MapInfo
//
// Sent from application with bug dialog info
//-----------------------------------------------------------------------------
int rc_MapInfo( char* commandPtr )
{
	char*			cmdToken;
	int				errCode;
	int				infoAddr;
	int				retVal;
	int				retAddr;
	char			buff[128];

	// success
	errCode = 0;

	// get address of data
	cmdToken = GetToken( &commandPtr );
	if ( !cmdToken[0] )
		goto cleanUp;
	sscanf( cmdToken, "%x", &infoAddr );

	// get retAddr
	cmdToken = GetToken( &commandPtr );
	if ( !cmdToken[0] )
		goto cleanUp;
	sscanf( cmdToken, "%x", &retAddr );

	// get the caller's info data 
	DmGetMemory( ( void* )infoAddr, sizeof( xrMapInfo_t ), &g_bug_mapInfo, NULL );

	// swap the structure
	BigFloat( &g_bug_mapInfo.position[0], &g_bug_mapInfo.position[0] );
	BigFloat( &g_bug_mapInfo.position[1], &g_bug_mapInfo.position[1] );
	BigFloat( &g_bug_mapInfo.position[2], &g_bug_mapInfo.position[2] );
	BigFloat( &g_bug_mapInfo.angle[0], &g_bug_mapInfo.angle[0] );
	BigFloat( &g_bug_mapInfo.angle[1], &g_bug_mapInfo.angle[1] );
	BigFloat( &g_bug_mapInfo.angle[2], &g_bug_mapInfo.angle[2] );
	g_bug_mapInfo.build = BigDWord( g_bug_mapInfo.build );
	g_bug_mapInfo.skill = BigDWord( g_bug_mapInfo.skill );

	Sys_NormalizePath( g_bug_mapInfo.savePath, false );
	Sys_NormalizePath( g_bug_mapInfo.mapPath, false );

	if ( g_bug_hWnd )
	{
		if ( g_bug_mapInfo.mapPath[0] )
		{
			Sys_StripPath( g_bug_mapInfo.mapPath, buff, sizeof( buff ) );
			SetDlgItemText( g_bug_hWnd, IDC_BUG_MAP_LABEL, buff );

			if ( !g_Games[g_bug_GameType].bUsesSystem1 )
			{
				char *pExtension = V_stristr( buff, ".bsp" );
				if ( pExtension )
				{
					*pExtension = '\0';
				}
				pExtension = V_stristr( buff, ".360" );
				if ( pExtension )
				{
					*pExtension = '\0';
				}
				V_strncpy( g_bug_szMapNumber, buff, sizeof( g_bug_szMapNumber ) );

				int curSel = SendDlgItemMessage( g_bug_hWnd, IDC_BUG_MAPNUMBER, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPCSTR)g_bug_szMapNumber );
				if ( curSel == CB_ERR )
					curSel = 0;
				SendDlgItemMessage( g_bug_hWnd, IDC_BUG_MAPNUMBER, CB_SETCURSEL, curSel, 0 );
			}

			sprintf( buff, "%.2f %.2f %.2f", g_bug_mapInfo.position[0], g_bug_mapInfo.position[1], g_bug_mapInfo.position[2] );
			SetDlgItemText( g_bug_hWnd, IDC_BUG_POSITION_LABEL, buff );

			sprintf( buff, "%.2f %.2f %.2f", g_bug_mapInfo.angle[0], g_bug_mapInfo.angle[1], g_bug_mapInfo.angle[2] );
			SetDlgItemText( g_bug_hWnd, IDC_BUG_ORIENTATION_LABEL, buff );
		}
		else
		{
			SetDlgItemText( g_bug_hWnd, IDC_BUG_MAP_LABEL, "" );
			SetDlgItemText( g_bug_hWnd, IDC_BUG_POSITION_LABEL, "" );
			SetDlgItemText( g_bug_hWnd, IDC_BUG_ORIENTATION_LABEL, "" );
		}

		sprintf( buff, "%d", g_bug_mapInfo.build );
		SetDlgItemText( g_bug_hWnd, IDC_BUG_BUILD_LABEL, buff );

		EnableWindow( GetDlgItem( g_bug_hWnd, IDC_BUG_SAVEGAME ), g_bug_mapInfo.savePath[0] != '\0' && g_bug_mapInfo.mapPath[0] != '\0' );
		EnableWindow( GetDlgItem( g_bug_hWnd, IDC_BUG_INCLUDEBSP ), g_bug_mapInfo.mapPath[0] != '\0' );
	}
	
	// return the result
	retVal = 0;
	int xboxRetVal = BigDWord( retVal );
	DmSetMemory( ( void* )retAddr, sizeof( int ), &xboxRetVal, NULL );

	DebugCommand( "0x%8.8x = MapInfo( 0x%8.8x )\n", retVal, infoAddr );

cleanUp:	
	return errCode;
}