自学教程：C++ ErrorMessageBox函数代码示例

// loads the demux into the FilterGraphHRESULTCBDAFilterGraph::LoadDemux(){    HRESULT hr = S_OK;        hr = CoCreateInstance(            CLSID_MPEG2Demultiplexer,             NULL,             CLSCTX_INPROC_SERVER,            IID_IBaseFilter,             reinterpret_cast<void**>(&m_pDemux)            );    if (FAILED (hr))    {        ErrorMessageBox(TEXT("Could not CoCreateInstance CLSID_MPEG2Demultiplexer/n"));        return hr;    }    hr = m_pFilterGraph->AddFilter(m_pDemux, L"Demux");    if(FAILED(hr))    {        ErrorMessageBox(TEXT("Unable to add demux filter to graph/n"));        return hr;    }    return hr;}

bool FileSystemInitializer::Initialize(){	if (initSuccess)		return true;	try {		Platform::SetOrigCWD();		dataDirLocater.LocateDataDirs();		dataDirLocater.Check();		archiveScanner = new CArchiveScanner();		vfsHandler = new CVFSHandler();		initSuccess = true;	} catch (const std::exception& ex) {		// abort VFS-init thread		initFailure = true;		// even if we end up here, do not clean up configHandler yet		// since it can already have early observers registered that		// do not remove themselves until exit		Cleanup(false);		ErrorMessageBox(ex.what(), "Spring: caught std::exception", MBF_OK | MBF_EXCL);	} catch (...) {		initFailure = true;		Cleanup(false);		ErrorMessageBox("", "Spring: caught generic exception", MBF_OK | MBF_EXCL);	}	return (initSuccess && !initFailure);}

voidCMainFrame::OnCmdResetDevice(DWORD dwSlotNo){	ndas::DevicePtr pDevice;	if (!ndas::FindDeviceBySlotNumber(pDevice, dwSlotNo))	{		return;	}	if (!pDevice->Enable(FALSE)) 	{		ErrorMessageBox(IDS_ERROR_RESET_DEVICE);		return;	}	::SetCursor(AtlLoadSysCursor(IDC_WAIT));	CSimpleWaitDlg().DoModal(m_hWnd, 2000);	::SetCursor(AtlLoadSysCursor(IDC_ARROW));	if (!pDevice->Enable(TRUE)) 	{		ErrorMessageBox(IDS_ERROR_RESET_DEVICE);	}	ndas::UpdateDeviceList();}

void CNdasDevicePropGeneralPage::OnModifyWriteKey(UINT, int, HWND){	ACCESS_MASK access = m_pDevice->GetGrantedAccess();		if (access & GENERIC_WRITE) 	{		int response = pTaskDialogVerify(			m_hWnd,			IDS_REMOVE_WRITE_KEY_CONFIRM_TITLE,			IDS_REMOVE_WRITE_KEY_CONFIRM,			IDS_REMOVE_WRITE_KEY_CONFIRM_DESC,			_T("DontConfirmRemoveWriteKey"),			TDCBF_YES_BUTTON | TDCBF_NO_BUTTON,			IDNO, 			IDYES);		if (IDYES == response) 		{			BOOL fSuccess = m_pDevice->SetAsReadOnly();			if (!fSuccess) 			{				ErrorMessageBox(m_hWnd, IDS_ERROR_REMOVE_WRITE_KEY);			}			else 			{				_UpdateDeviceData();			}		}	}	else 	{		CNdasDeviceAddWriteKeyDlg dlg;		dlg.SetDeviceId(m_pDevice->GetStringId());		dlg.SetDeviceName(m_pDevice->GetName());		INT_PTR iResult = dlg.DoModal();		ATLTRACE("iResult = %d/n", iResult);		if (iResult == IDOK) 		{			BOOL fSuccess = m_pDevice->SetAsReadWrite(dlg.GetWriteKey());			if (!fSuccess) 			{				ErrorMessageBox(m_hWnd, IDS_ERROR_ADD_WRITE_KEY);			}			else 			{				_UpdateDeviceData();			}		}		else 		{			;		}	}}

static int CALLBACK DIJoystick_EnumAxisObjectsProc(LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef){	joystick_type* joystick = (joystick_type*)pvRef;	DIPROPRANGE diprg;	HRESULT hr;	joystick->axes[joystick->num_axes].guid = lpddoi->guidType;	joystick->axes[joystick->num_axes].name = (TCHAR *)malloc((_tcslen(lpddoi->tszName) + 1) * sizeof(TCHAR));	_tcscpy(joystick->axes[joystick->num_axes].name, lpddoi->tszName);	joystick->axes[joystick->num_axes].offset = lpddoi->dwOfs;	/*ErrorMessageBox("got axis %s, offset %i",lpddoi->tszName, lpddoi->dwOfs);*/	memset(&diprg, 0, sizeof(DIPROPRANGE));	diprg.diph.dwSize = sizeof(DIPROPRANGE);	diprg.diph.dwHeaderSize = sizeof(DIPROPHEADER);	diprg.diph.dwObj = lpddoi->dwOfs;	diprg.diph.dwHow = DIPH_BYOFFSET;	diprg.lMin = 0;	diprg.lMax = 255;	hr = IDirectInputDevice2_SetProperty(joystick->did, DIPROP_RANGE, &diprg.diph);	if (FAILED(hr)) /* if this fails, don't use this axis */	{		free(joystick->axes[joystick->num_axes].name);		joystick->axes[joystick->num_axes].name = NULL;		return DIENUM_CONTINUE;	}#ifdef JOY_DEBUG	if (FAILED(hr))	{		ErrorMessageBox("DirectInput SetProperty() joystick axis %s failed - %s/n",				 joystick->axes[joystick->num_axes].name,				 DirectXDecodeError(hr));	}#endif	/* Set axis dead zone to 0; we need accurate #'s for analog joystick reading. */	SetDIDwordProperty(joystick->did, DIPROP_DEADZONE, lpddoi->dwOfs, DIPH_BYOFFSET, 0);#ifdef JOY_DEBUG	if (FAILED(hr))	{		ErrorMessageBox("DirectInput SetProperty() joystick axis %s dead zone failed - %s/n",				 joystick->axes[joystick->num_axes].name,				 DirectXDecodeError(hr));	}#endif	joystick->num_axes++;	return DIENUM_CONTINUE;}

HRESULTCBDAFilterGraph::ChangeChannel(        LONG lMajorChannel,         LONG lMinorChannel        ){    HRESULT hr = S_OK;    m_lMajorChannel = lMajorChannel;    m_lMinorChannel = lMinorChannel;    CComPtr <IScanningTuner> pIScanningTuner;    if (!m_pNetworkProvider)    {        ErrorMessageBox(TEXT("The FilterGraph is not yet built./n"));        return E_FAIL;    }    hr = m_pNetworkProvider.QueryInterface (&pIScanningTuner);    if (FAILED(hr))    {        ErrorMessageBox(TEXT("Cannot QI for IScanningTuner/n"));        return hr;    }    // create tune request    CComPtr <IATSCChannelTuneRequest> pTuneRequest;    hr = CreateATSCTuneRequest(        m_lPhysicalChannel,         lMajorChannel,         lMinorChannel,        &pTuneRequest        );    if(SUCCEEDED(hr))    {        hr = m_pITuner->put_TuneRequest (pTuneRequest);        if (FAILED (hr))            ErrorMessageBox(TEXT("Cannot submit tune request/n"));    }    else    {        ErrorMessageBox(TEXT("Cannot Change Channels/n"));    }    return hr;}

static void error_code_messagebox(HWND hwnd, DWORD error_code){    TCHAR title[256];    if (!LoadString(hInst, IDS_ERROR, title, COUNT_OF(title)))        lstrcpy(title, TEXT("Error"));    ErrorMessageBox(hwnd, title, error_code);}

void MainFunc(int argc, char** argv, int* ret) {#ifdef __MINGW32__	// For the MinGW backtrace() implementation we need to know the stack end.	{		extern void* stack_end;		char here;		stack_end = (void*) &here;	}#endif	while (!Threading::IsMainThread())		;#ifdef USE_GML	set_threadnum(GML_DRAW_THREAD_NUM);  #if GML_ENABLE_TLS_CHECK	if (gmlThreadNumber != GML_DRAW_THREAD_NUM) {		ErrorMessageBox("Thread Local Storage test failed", "GML error:", MBF_OK | MBF_EXCL);	}  #endif#endif	try {		SpringApp app;		*ret = app.Run(argc, argv);	} CATCH_SPRING_ERRORS}

voidCDeviceAdvancedPage::OnDeactivateDevice(UINT uCode, int nCtrlID, HWND hwndCtrl){	ATLASSERT(NULL != m_pDevice.get());	CString strMessage = (LPCTSTR) IDS_CONFIRM_DEACTIVATE_DEVICE;	CString strTitle = (LPCTSTR) IDS_MAIN_TITLE;	ATLASSERT(!strMessage.IsEmpty());	ATLASSERT(!strTitle.IsEmpty());	INT_PTR iResponse = MessageBox(		strMessage, 		strTitle, 		MB_YESNO | MB_ICONQUESTION);	if (IDYES != iResponse) 	{		return;	}	if (!m_pDevice->Enable(FALSE)) 	{		ErrorMessageBox(m_hWnd, IDS_ERROR_DISABLE_DEVICE);	}	m_wndDeactivate.EnableWindow(FALSE);	m_wndReset.EnableWindow(FALSE);}

LPBYTE CBZDoc::QueryMapView1(LPBYTE pBegin, DWORD dwOffset){    LPBYTE p = pBegin + dwOffset;    if(IsOutOfMap1(p)) {        if(p == m_pData + m_dwTotal && p == m_pMapStart + m_dwMapSize) return pBegin;	// ###1.61a        DWORD dwBegin = pBegin - m_pData;        VERIFY(::UnmapViewOfFile(m_pMapStart));        m_dwFileOffset = (p - m_pData) & FILEOFFSET_MASK;        m_dwMapSize = min(options.dwMaxMapSize, m_dwTotal - m_dwFileOffset);        if(m_dwMapSize == 0) {	// ###1.61a            m_dwFileOffset = (m_dwTotal - (~FILEOFFSET_MASK + 1)) & FILEOFFSET_MASK;            m_dwMapSize = m_dwTotal - m_dwFileOffset;        }        m_pMapStart = (LPBYTE)::MapViewOfFile(m_hMapping, m_bReadOnly ? FILE_MAP_READ : FILE_MAP_WRITE, 0, m_dwFileOffset, m_dwMapSize);        TRACE("MapViewOfFile Doc=%X, %X, Offset:%X, Size:%X/n", this, m_pMapStart, m_dwFileOffset, m_dwMapSize);        if(!m_pMapStart) {            ErrorMessageBox();            AfxPostQuitMessage(0);            return NULL;        }        m_pData = m_pMapStart - m_dwFileOffset;        pBegin = m_pData + dwBegin;    }    return pBegin;}

	void NewHandler() {		LOG_L(L_ERROR, "Failed to allocate memory"); // make sure this ends up in the log also		OutputStacktrace();		ErrorMessageBox("Failed to allocate memory", "Spring: Fatal Error", MBF_OK | MBF_CRASH);	}

voidCNdasDevicePropAdvancedPage::OnDeactivateDevice(UINT uCode, int nCtrlID, HWND hwndCtrl){	ATLASSERT(NULL != m_pDevice.get());	int response = AtlTaskDialogEx(		m_hWnd,		IDS_MAIN_TITLE,		IDS_CONFIRM_DEACTIVATE_DEVICE,		IDS_CONFIRM_DEACTIVATE_DEVICE_DESC,		TDCBF_YES_BUTTON | TDCBF_NO_BUTTON,		TD_INFORMATION_ICON);	if (IDYES != response) 	{		return;	}	if (!m_pDevice->Enable(FALSE)) 	{		ErrorMessageBox(m_hWnd, IDS_ERROR_DISABLE_DEVICE);	}	m_wndDeactivate.EnableWindow(FALSE);	m_wndReset.EnableWindow(FALSE);}

void EAE_Engine::Tools::OutputErrorMessage( const char* const i_errorMessage, const char* const i_optionalFileName ){    // This formatting causes the errors to show up in Visual Studio's "Error List" tab    std::cerr << ( i_optionalFileName ? i_optionalFileName : "Asset Build" ) << ": error: " << i_errorMessage << "/n";    ErrorMessageBox(i_errorMessage);//	DEBUG_PRINT("For file %s, Asset Build: error: %s/n", i_optionalFileName, i_errorMessage);}

/** * @brief main * @return exit code * @param argc argument count * @param argv array of argument strings * * Main entry point function */int main(int argc, char* argv[]){// PROFILE builds exit on execv ...// HEADLESS run mostly in parallel for testing purposes, 100% omp threads wouldn't help then#if !defined(PROFILE) && !defined(HEADLESS)	bool restart = false;	restart |= SetNvOptimusProfile(argv);	restart |= SetOpenMpEnvVars(argv);  #ifndef WIN32	if (restart) {		std::vector<std::string> args(argc-1);		for (int i=1; i<argc; i++) {			args[i-1] = argv[i];		}		const std::string err = Platform::ExecuteProcess(argv[0], args);		ErrorMessageBox(err, "Execv error:", MBF_OK | MBF_EXCL);	}  #endif#endif	int ret = Run(argc, argv);	std::string exe = EngineTypeHandler::GetRestartExecutable();	if (exe != "") {		std::vector<std::string> args;		for (int i=1; i<argc; i++)			args.push_back(argv[i]);		if (!EngineTypeHandler::RestartEngine(exe, args)) {			handleerror(NULL, EngineTypeHandler::GetRestartErrorMessage(), "Missing engine type", MBF_OK | MBF_EXCL);		}	}	return ret;}

static BOOL UnloadHive(HWND hWnd){    WCHAR Caption[128];    LPCWSTR pszKeyPath;    HKEY hRootKey;    LONG regUnloadResult;    /* get the item key to unload */    pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);    /* load and set the caption and flags for dialog */    LoadStringW(hInst, IDS_UNLOAD_HIVE, Caption, COUNT_OF(Caption));    /* Enable the 'restore' privilege, unload the hive, disable the privilege */    EnablePrivilege(SE_RESTORE_NAME, NULL, TRUE);    regUnloadResult = RegUnLoadKeyW(hRootKey, pszKeyPath);    EnablePrivilege(SE_RESTORE_NAME, NULL, FALSE);    if(regUnloadResult == ERROR_SUCCESS)    {        /* refresh tree and list views */        RefreshTreeView(g_pChildWnd->hTreeWnd);        pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);        RefreshListView(g_pChildWnd->hListWnd, hRootKey, pszKeyPath);    }    else    {        ErrorMessageBox(hWnd, Caption, regUnloadResult);        return FALSE;    }    return TRUE;}

void CNdasDevicePropGeneralPage::OnRename(UINT, int, HWND){	CNdasDeviceRenameDlg wndRename;	wndRename.SetName(m_pDevice->GetName());		INT_PTR iResult = wndRename.DoModal();	if (IDOK == iResult) 	{		CString strNewName = wndRename.GetName();		if (0 != strNewName.Compare(m_pDevice->GetName())) 		{			if (!m_pDevice->SetName(strNewName)) 			{				ErrorMessageBox(m_hWnd, IDS_ERROR_RENAME_DEVICE);			} 			else 			{				m_wndDeviceName.SetWindowText(strNewName);				CString strTitle;				strTitle.FormatMessage(IDS_DEVICE_PROP_TITLE, strNewName);				GetParent().SetWindowText(strTitle);				_UpdateDeviceData();			}		}	}}

int Run(int argc, char* argv[]){	int ret = -1;#ifdef __MINGW32__	// For the MinGW backtrace() implementation we need to know the stack end.	{		extern void* stack_end;		char here;		stack_end = (void*) &here;	}#endif	Threading::DetectCores();	Threading::SetMainThread();	// run	try {		SpringApp app(argc, argv);		ret = app.Run();	} CATCH_SPRING_ERRORS	// check if (a thread in) Spring crashed, if so display an error message	Threading::Error* err = Threading::GetThreadError();	if (err != NULL) {		ErrorMessageBox(" error: " + err->message, err->caption, err->flags, true);	}	return ret;}

// Returns true if successfulstatic int DoExchangeItem(HWND hFrom, HWND hTo, int nMinItem){	LVITEM lvi;	wchar_t buf[80];	lvi.iItem = ListView_GetNextItem(hFrom, -1, LVIS_SELECTED | LVIS_FOCUSED);	if (lvi.iItem < nMinItem)	{		if (lvi.iItem != -1) 	// Can't remove the first column			ErrorMessageBox("Cannot move selected item");		SetFocus(hFrom);		return 0;	}	lvi.iSubItem = 0;	lvi.mask = LVIF_PARAM | LVIF_TEXT;	lvi.pszText = buf;	lvi.cchTextMax = WINUI_ARRAY_LENGTH(buf);	if (ListView_GetItem(hFrom, &lvi))	{		// Add this item to the Show and delete it from Available		(void)ListView_DeleteItem(hFrom, lvi.iItem);		lvi.iItem = ListView_GetItemCount(hTo);		(void)ListView_InsertItem(hTo, &lvi);		ListView_SetItemState(hTo, lvi.iItem, LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED);		SetFocus(hTo);		return lvi.iItem;	}	return 0;}

void CMainFrame::OnCmdMountDeviceRO(NDAS_LOGICALDEVICE_ID logDeviceId){	ndas::LogicalDevicePtr pLogDevice;	if (!ndas::FindLogicalDevice(pLogDevice, logDeviceId))	{		ATLTRACE("Invalid logical device id specified: %d/n", logDeviceId);		return;	}	if (!pLogDevice->PlugIn(FALSE))	{		ErrorMessageBox(IDS_ERROR_MOUNT_DEVICE_RO);		return;	}	if (!pLogDevice->UpdateStatus())	{		// Service Communication failure?		return;	}	if (NDAS_LOGICALDEVICE_STATUS_MOUNT_PENDING == pLogDevice->GetStatus())	{		CWaitMountDialog().DoModal(m_hWnd, pLogDevice);	}}

static BOOL UnloadHive(HWND hWnd){    TCHAR Caption[128];    LPCTSTR pszKeyPath;    HKEY hRootKey;    LONG regUnloadResult;    /* get the item key to unload */    pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);    /* load and set the caption and flags for dialog */    LoadString(hInst, IDS_UNLOAD_HIVE, Caption, COUNT_OF(Caption));    /* now unload the hive */    regUnloadResult = RegUnLoadKey(hRootKey, pszKeyPath);    if(regUnloadResult == ERROR_SUCCESS)    {        /* refresh tree and list views */        RefreshTreeView(g_pChildWnd->hTreeWnd);        pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);        RefreshListView(g_pChildWnd->hListWnd, hRootKey, pszKeyPath);    }    else    {        ErrorMessageBox(hWnd, Caption, regUnloadResult);        return FALSE;    }    return TRUE;}

// LoadNetworkProvider loads network providerHRESULTCBDAFilterGraph::LoadNetworkProvider(){    HRESULT     hr = S_OK;    CComBSTR    bstrNetworkType;    CLSID       CLSIDNetworkType;    // obtain tuning space then load network provider    if(m_pITuningSpace == NULL)    {        hr = LoadTuningSpace();        if(FAILED(hr))        {            ErrorMessageBox(TEXT("Cannot load TuningSpace/n"));            return hr;        }    }    // Get the current Network Type clsid    hr = m_pITuningSpace->get_NetworkType(&bstrNetworkType);    if (FAILED (hr))    {        ErrorMessageBox(TEXT("ITuningSpace::Get Network Type failed/n"));        return hr;    }    hr = CLSIDFromString(bstrNetworkType, &CLSIDNetworkType);    if (FAILED (hr))    {        ErrorMessageBox(TEXT("Couldn't get CLSIDFromString/n"));        return hr;    }    // create the network provider based on the clsid obtained from the tuning space    hr = CoCreateInstance(CLSIDNetworkType, NULL, CLSCTX_INPROC_SERVER,            IID_IBaseFilter, reinterpret_cast<void**>(&m_pNetworkProvider));    if (FAILED (hr))    {        ErrorMessageBox(TEXT("Couldn't CoCreate Network Provider/n"));        return hr;    }    //add the Network Provider filter to the graph    hr = m_pFilterGraph->AddFilter(m_pNetworkProvider, L"Network Provider");    return hr;}

voidcreateDialog(void){    STARTUPINFOA startinfo;    WNDCLASSEXA WndClass;    g_hInstance = GetModuleHandle(NULL);    GetStartupInfoA(&startinfo);    WndClass.cbSize        = sizeof WndClass;    WndClass.style         = 0;    WndClass.lpfnWndProc   = WndProc;    WndClass.cbClsExtra    = 0;    WndClass.cbWndExtra    = 0;    WndClass.hInstance     = g_hInstance;    WndClass.hIcon         = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_MAINICON));    WndClass.hCursor       = LoadCursor(NULL, IDC_ARROW);    WndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);    WndClass.lpszMenuName  = MAKEINTRESOURCEA(IDM_MAINMENU);    WndClass.lpszClassName = "DrMingw";    WndClass.hIconSm       = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_MAINICON));    if (!RegisterClassExA(&WndClass)) {        ErrorMessageBox("RegisterClassEx: %s", LastErrorMessage());        exit(EXIT_FAILURE);    }    g_hWnd = CreateWindowExA(        WS_EX_CLIENTEDGE,        WndClass.lpszClassName,        "Dr. Mingw",        WS_OVERLAPPEDWINDOW,        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,        NULL,        NULL,        g_hInstance,        NULL    );    if (g_hWnd == NULL) {        ErrorMessageBox("CreateWindowEx: %s", LastErrorMessage());        exit(EXIT_FAILURE);    }    ShowWindow(g_hWnd, (startinfo.dwFlags & STARTF_USESHOWWINDOW) ? startinfo.wShowWindow : SW_SHOWDEFAULT);    UpdateWindow(g_hWnd);}

voidCMainFrame::OnCmdUnregisterDevice(DWORD dwSlotNo){	ndas::DevicePtr pDevice;	if (!ndas::FindDeviceBySlotNumber(pDevice, dwSlotNo))	{		return;	}	CString strMessage;	strMessage.FormatMessage(		IDS_CONFIRM_UNREGISTER_FMT,		pDevice->GetName());	int response = pTaskDialogVerify(		m_hWnd,		IDS_MAIN_TITLE,		static_cast<LPCTSTR>(strMessage),		static_cast<LPCTSTR>(NULL),		_T("DontConfirmUnregister"),		TDCBF_YES_BUTTON | TDCBF_NO_BUTTON,		IDNO, 		IDYES);	if (IDYES != response) 	{		return;	}	if (NDAS_DEVICE_STATUS_NOT_REGISTERED != pDevice->GetStatus()) 	{		if (!pDevice->Enable(FALSE)) 		{			ErrorMessageBox(IDS_ERROR_UNREGISTER_DEVICE);			ndas::UpdateDeviceList();			return;		}	}	if (!::NdasUnregisterDevice(dwSlotNo))	{		ErrorMessageBox(IDS_ERROR_UNREGISTER_DEVICE);	}	ndas::UpdateDeviceList();}

	void HandleSignal(int signal)	{		std::string error;		std::queue<std::string> addresses;		logOutput.RemoveAllSubscribers();		{			LogObject log;			if (signal == SIGSEGV)				error = "Segmentation fault (SIGSEGV)";			else if (signal == SIGILL)				error = "Illegal instruction (SIGILL)";			else if (signal == SIGPIPE)				error = "Broken pipe (SIGPIPE)";			else if (signal == SIGIO)				error = "IO-Error (SIGIO)";			else if (signal == SIGABRT)				error = "Aborted (SIGABRT)";			log << error << " in spring " << SpringVersion::GetFull() << "/nStacktrace:/n";			std::vector<void*> buffer(128);			const int numptr = backtrace(&buffer[0], buffer.size()); // stack pointers			char ** strings = backtrace_symbols(&buffer[0], numptr); // give them meaningfull names			if (strings == NULL)			{				log << "Unable to create stacktrace/n";			}			else			{				for (int j = 0; j < numptr; j++)				{					std::string addrline(strings[j]);					log << addrline << "/n";					size_t begin = addrline.find_first_of('[');					if (begin != std::string::npos)					{						size_t end = addrline.find_first_of(']');						if (end != std::string::npos)						{							addresses.push(addrline.substr(begin+1, end-begin-1));						}					}				}				delete strings;			}		}		logOutput.End();  // Stop writing to log.		std::ostringstream buf;		buf << "addr2line " << "--exe=/"" << Platform::GetBinaryFile() << "/"";		while (!addresses.empty())		{			buf << " " << addresses.front();			addresses.pop();		}		buf << " >> infolog.txt"; // pipe to infolog (which will be in CWD)		system(buf.str().c_str());		ErrorMessageBox(error, "Spring crashed", 0);	};

int CKMotionIO::SetLatency(UCHAR LatencyTimer){	FT_STATUS ftStatus;			unsigned char c;		Mutex->Lock();	ftStatus = FT_GetLatencyTimer (ftHandle, &c);	ftStatus = FT_SetLatencyTimer(ftHandle,LatencyTimer);		if (ftStatus == FT_OK) 	{ 		ftStatus = FT_GetLatencyTimer (ftHandle, &c);		// LatencyTimer set 		ftStatus = FT_SetChars (ftHandle, '/n', 1, 0,0);		if (ftStatus == FT_OK) 		{ 			// Event set 			Mutex->Unlock();			return 0;		}		else 		{ 			// FT_SetLatencyTimer FAILED!			ErrorMessageBox("Unable to set USB Event Character");			Mutex->Unlock();			return 1;		}	}	else 	{ 		// FT_SetLatencyTimer FAILED!		ErrorMessageBox("Unable to set USB Latency timer");		Mutex->Unlock();		return 1;	}}

static BOOL LoadHive(HWND hWnd){    OPENFILENAME ofn;    WCHAR Caption[128];    LPCWSTR pszKeyPath;    WCHAR xPath[LOADHIVE_KEYNAMELENGTH];    HKEY hRootKey;    WCHAR Filter[1024];    FILTERPAIR filter;    /* get the item key to load the hive in */    pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);    /* initialize the "open file" dialog */    InitOpenFileName(hWnd, &ofn);    /* build the "All Files" filter up */    filter.DisplayID = IDS_FLT_ALLFILES;    filter.FilterID = IDS_FLT_ALLFILES_FLT;    BuildFilterStrings(Filter, &filter, 1);    ofn.lpstrFilter = Filter;    /* load and set the caption and flags for dialog */    LoadStringW(hInst, IDS_LOAD_HIVE, Caption, COUNT_OF(Caption));    ofn.lpstrTitle = Caption;    ofn.Flags |= OFN_ENABLESIZING;    /*    ofn.lCustData = ;*/    /* now load the hive */    if (GetOpenFileName(&ofn))    {        if (DialogBoxParamW(hInst, MAKEINTRESOURCEW(IDD_LOADHIVE), hWnd,                            &LoadHive_KeyNameInHookProc, (LPARAM)xPath))        {            LONG regLoadResult;            /* Enable the 'restore' privilege, load the hive, disable the privilege */            EnablePrivilege(SE_RESTORE_NAME, NULL, TRUE);            regLoadResult = RegLoadKeyW(hRootKey, xPath, ofn.lpstrFile);            EnablePrivilege(SE_RESTORE_NAME, NULL, FALSE);            if(regLoadResult == ERROR_SUCCESS)            {                /* refresh tree and list views */                RefreshTreeView(g_pChildWnd->hTreeWnd);                pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);                RefreshListView(g_pChildWnd->hListWnd, hRootKey, pszKeyPath);            }            else            {                ErrorMessageBox(hWnd, Caption, regLoadResult);                return FALSE;            }        }    }    else    {        CheckCommDlgError(hWnd);    }    return TRUE;}

void CMainFrame::OnCmdRefreshStatus(UINT /* wNotifyCode */, int /* wID */, HWND /* hWndCtl */){	BOOL fSuccess;	fSuccess = pUpdateDeviceList();	if (!fSuccess) 	{		ErrorMessageBox(IDS_ERROR_UPDATE_DEVICE_LIST);	}	pUpdateMenuItems();}