1577 lines
43 KiB
C++
1577 lines
43 KiB
C++
//========= 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( <ime );
|
|
tm *pTime = localtime( <ime );
|
|
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;
|
|
}
|
|
|