int AFX_CDECL AfxCriticalNewHandler(size_t nSize)
// nSize is already rounded
{
// called during critical memory allocation
// free up part of the app's safety cache
TRACE0("Warning: Critical memory allocation failed!\n");
_AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
if (pThreadState != NULL && pThreadState->m_pSafetyPoolBuffer != NULL)
{
size_t nOldBufferSize = _msize(pThreadState->m_pSafetyPoolBuffer);
if (nOldBufferSize <= nSize + MIN_MALLOC_OVERHEAD)
{
// give it all up
TRACE0("Warning: Freeing application's memory safety pool!\n");
free(pThreadState->m_pSafetyPoolBuffer);
pThreadState->m_pSafetyPoolBuffer = NULL;
}
else
{
BOOL bEnable = AfxEnableMemoryTracking(FALSE);
_expand(pThreadState->m_pSafetyPoolBuffer,
nOldBufferSize - (nSize + MIN_MALLOC_OVERHEAD));
AfxEnableMemoryTracking(bEnable);
TRACE3("Warning: Shrinking safety pool from %d to %d to satisfy request of %d bytes.\n",
nOldBufferSize, _msize(pThreadState->m_pSafetyPoolBuffer), nSize);
}
return 1; // retry it
}
TRACE0("ERROR: Critical memory allocation from safety pool failed!\n");
AfxThrowMemoryException(); // oops
return 0;
}
BOOL BlitzIDE::InitInstance(){
#ifdef _DEBUG
AfxEnableMemoryTracking( true );
#endif
AfxInitRichEdit();
prefs.open();
initLibs();
mainFrame=new MainFrame();
m_pMainWnd = mainFrame;
#ifdef DEMO
aboutBlitz( true );
#endif
mainFrame->LoadFrame( IDR_MAINFRAME );
mainFrame->MoveWindow( CRect( prefs.win_rect ) );
mainFrame->ShowWindow( m_nCmdShow );
mainFrame->UpdateWindow();
if( prefs.win_maximized ) mainFrame->ShowWindow( SW_SHOWMAXIMIZED );
return TRUE;
}
static CHandleMap* afxMapHIMAGELIST(BOOL bCreate)
{
AFX_THREAD_STATE* pState = AfxGetThreadState();
if (pState->m_pmapHIMAGELIST == NULL && bCreate)
{
BOOL bEnable = AfxEnableMemoryTracking(FALSE);
#ifndef _AFX_PORTABLE
_PNH pnhOldHandler = _set_new_handler(&AfxCriticalNewHandler);
#endif
pState->m_pmapHIMAGELIST = new CHandleMap(RUNTIME_CLASS(CImageList),
offsetof(CImageList, m_hImageList));
#ifndef _AFX_PORTABLE
_set_new_handler(pnhOldHandler);
#endif
AfxEnableMemoryTracking(bEnable);
}
return pState->m_pmapHIMAGELIST;
}
static CHandleMap* afxMapHGDIOBJ(BOOL bCreate)
{
AFX_MODULE_THREAD_STATE* pState = AfxGetModuleThreadState();
if (pState->m_pmapHGDIOBJ == NULL && bCreate)
{
BOOL bEnable = AfxEnableMemoryTracking(FALSE);
#ifndef _AFX_PORTABLE
_PNH pnhOldHandler = AfxSetNewHandler(&AfxCriticalNewHandler);
#endif
pState->m_pmapHGDIOBJ = new CHandleMap(RUNTIME_CLASS(CGdiObject),
offsetof(CGdiObject, m_hObject));
#ifndef _AFX_PORTABLE
AfxSetNewHandler(pnhOldHandler);
#endif
AfxEnableMemoryTracking(bEnable);
}
return pState->m_pmapHGDIOBJ;
}
CHandleMap* PASCAL afxMapHDC(BOOL bCreate)
{
AFX_MODULE_THREAD_STATE* pState = AfxGetModuleThreadState();
if (pState->m_pmapHDC == NULL && bCreate)
{
BOOL bEnable = AfxEnableMemoryTracking(FALSE);
#ifndef _AFX_PORTABLE
_PNH pnhOldHandler = AfxSetNewHandler(&AfxCriticalNewHandler);
#endif
pState->m_pmapHDC = new CHandleMap(RUNTIME_CLASS(CDC),
ConstructDestruct<CDC>::Construct, ConstructDestruct<CDC>::Destruct,
offsetof(CDC, m_hDC), 2);
#ifndef _AFX_PORTABLE
AfxSetNewHandler(pnhOldHandler);
#endif
AfxEnableMemoryTracking(bEnable);
}
return pState->m_pmapHDC;
}
BOOL CPCSpimApp::InitInstance()
{
// SPIM is bad about cleaning up after itself...
AfxEnableMemoryTracking(FALSE);
// Standard initialization
// Turn on registry (vs. INI) support, and set the "company" tag.
SetRegistryKey("LarusStone");
// If registry settings for this user do not exist, copy them from
// the "Default Settings" tree in HKLM.
HKEY hKeySrc, hKeySettings;
HKEY hKeyDest = GetAppRegistryKey();
if (S_OK != RegMan_OpenKey(hKeyDest, "Settings", &hKeySettings))
{
if (S_OK == RegMan_OpenKey(HKEY_LOCAL_MACHINE,
SPIM_REG_DEFAULTSETTINGS,
&hKeySrc))
{
RegMan_CopyTree(hKeySrc, hKeyDest);
RegMan_CloseKey(hKeySrc);
}
}
else
{
RegMan_CloseKey(hKeySettings);
}
RegMan_CloseKey(hKeyDest);
LoadStdProfileSettings(0); // Load standard INI file options (including MRU)
// Register the application's document templates. Document templates
// serve as the connection between documents, frame windows and views.
CSingleDocTemplate* pDocTemplate;
pDocTemplate = new CSingleDocTemplate(IDR_MAINFRAME,
RUNTIME_CLASS(CPCSpimDoc),
// main SDI frame window
RUNTIME_CLASS(CMainFrame),
RUNTIME_CLASS(CPCSpimView));
AddDocTemplate(pDocTemplate);
// We do our own cmdline processing later. Even though we aren't using
// MFC's standard cmdline processing (we aren't calling ParseCommandLine),
// we _must_ call ProcessShellCommand...
CCommandLineInfo cmdInfo;
if (!ProcessShellCommand(cmdInfo))
{
return FALSE;
}
return TRUE;
}
BootLoader::BootLoader()
{
m_MDumpHandle.showMessageBox(true);
AfxEnableMemoryTracking(FALSE);
InitCommonControls();
hasAdminRights = false;
m_pUICore = NULL;
m_bRetCode = false;
}
void PASCAL CAsyncSocket::AttachHandle(
SOCKET hSocket, CAsyncSocket* pSocket, BOOL bDead)
{
ASSERT(CAsyncSocket::LookupHandle(hSocket, bDead) == NULL);
AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
BOOL bEnable = AfxEnableMemoryTracking(FALSE);
if (!bDead)
{
if (pThreadState->m_mapSocketHandle.IsEmpty())
{
ASSERT(pThreadState->m_mapDeadSockets.IsEmpty());
ASSERT(pThreadState->m_hSocketWindow == NULL);
CSocketWnd* pWnd = new CSocketWnd;
pWnd->m_hWnd = NULL;
if (!pWnd->CreateEx(0, AfxRegisterWndClass(0),
_T("Socket Notification Sink"),
WS_OVERLAPPED, 0, 0, 0, 0, NULL, NULL))
{
TRACE0("Warning: unable to create socket notify window!\n");
AfxThrowResourceException();
}
ASSERT(pWnd->m_hWnd != NULL);
ASSERT(CWnd::FromHandlePermanent(pWnd->m_hWnd) == pWnd);
pThreadState->m_hSocketWindow = pWnd->m_hWnd;
}
pThreadState->m_mapSocketHandle.SetAt((void*)hSocket, pSocket);
}
else
{
pThreadState->m_mapDeadSockets.SetAt((void*)hSocket, pSocket);
}
AfxEnableMemoryTracking(bEnable);
}
BOOL CStkUIApp::InitInstance()
{
// Standard initialization
// If you are not using these features and wish to reduce the size
// of your final executable, you should remove from the following
// the specific initialization routines you do not need.
AfxSocketInit( );
AfxOleInit();
// 程序只能启动一个实例
m_pMutex = CreateMutex(NULL, FALSE, _T("TsKing"));
if (m_pMutex != NULL)
{
if (GetLastError() == ERROR_ALREADY_EXISTS)
{
CloseHandle(m_pMutex);
m_pMutex = NULL;
return FALSE;
}
}
GetVersionNumber();
AfxGetProfile().LoadProfile( );
::SetCurrentDirectory( AfxGetProfile().GetWorkDirectory() );
AfxGetSView().Load( AfxGetProfile().GetSViewFile() );
// Change the registry key under which our settings are stored.
// TODO: You should modify this string to be something appropriate
// such as the name of your company or organization.
// SetRegistryKey( szRegKeyCompany );
AfxRegSetValue( szRegKeyCompany, szRegKeyApp, "Install", "Path", AfxGetProfile().GetWorkDirectory() );
AfxRegSetValue( szRegKeyCompany, szRegKeyApp, "Install", "Version", AfxGetProfile().GetVersion() );
// change profile ( INI file )
BOOL bEnable = AfxEnableMemoryTracking(FALSE);
if( m_pszProfileName ) free((void*)m_pszProfileName);
m_pszProfileName = _tcsdup(AfxGetProfile().GetWorkDirectory()+m_pszExeName+".ini");
AfxEnableMemoryTracking(bEnable);
LoadStdProfileSettings(64); // Load standard INI file options (including MRU)
// Register the application's document templates. Document templates
// serve as the connection between documents, frame windows and views.
// Enable DDE Execute open
EnableShellOpen();
AfxUnregisterShellFileTypes();
// AfxRegisterShellFileTypes(FALSE);
// Empty Temp Directory
{
CNetDatabase netdb;
if (netdb.SetRootPath(AfxGetProfile().GetSelfDBPath(), IStStore::dbtypeSelfDB))
netdb.EmptyTempDirectory();
}
AfxSetDB(&AfxGetNetDB());
//*/
// Load Data
char szErr[1024];
if (!AfxInitializeDB(szErr, sizeof(szErr)))
{
AfxMessageBox(szErr, MB_OK | MB_ICONINFORMATION);
return FALSE;
}
// 初始化
AfxGetStockContainer().Load(&AfxGetDB(), NULL, NULL); // 读取证券信息，代码表、财务、除权等
AfxGetDomainContainer().Load(AfxGetProfile().GetDomainFile()); // 读取板块
AfxGetGroupContainer().Load(AfxGetProfile().GetGroupFile()); // 读取自选板块
// 分析标准外壳命令、DDE、打开文件操作的命令行
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
#ifdef _TSK_MAINFRAME
// 注册应用程序的文档模板。文档模板
// 将用作文档、框架窗口和视图之间的连接
CSingleDocTemplate* pDocTemplate;
pDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
RUNTIME_CLASS(CStaticDoc),
RUNTIME_CLASS(CMainFrame), // 主 SDI 框架窗口
RUNTIME_CLASS(CSListView));
if (!pDocTemplate)
return FALSE;
AddDocTemplate(pDocTemplate);
// 调度在命令行中指定的命令。如果
// 用 /RegServer、/Register、/Unregserver 或 /Unregister 启动应用程序，则返回 FALSE。
if (!ProcessShellCommand(cmdInfo))
return FALSE;
#else
// Create MainFrame and Static Doc and child frames and static views
CStaticDoc* pStaticDoc = CStaticDoc::OpenDocumentFile(NULL);
if (pStaticDoc == NULL)
{
AfxMessageBox(IDS_STATICDOC_FAILED, MB_OK | MB_ICONINFORMATION);
return FALSE;
}
pStaticDoc->m_bAutoDelete = FALSE;
CString strAppTitle;
strAppTitle.LoadString(AFX_IDS_APP_TITLE);
pStaticDoc->SetTitle(strAppTitle);
SetStaticDoc(pStaticDoc);
// Create MainFrame
CMainFrame* pMainFrame = CMainFrame::CreateNewFrame();
if (pMainFrame == NULL)
{
AfxMessageBox(IDS_STATICDOC_FAILED, MB_OK | MB_ICONINFORMATION);
delete pStaticDoc;
SetStaticDoc(NULL);
return FALSE;
}
SetMainWnd(pMainFrame);
#endif
// 股票行情接收
AfxGetStkReceiver().CreateReceiver(m_pMainWnd);
AfxGetStkReceiver().NetEngineSetAutoReport(FALSE);
/* Show Startup Window
CStartupDlg startup;
CBitmap bmp;
bmp.LoadBitmap(IDB_DLGLEFTLOGO);
startup.SetBitmap((HBITMAP)bmp.GetSafeHandle());
startup.SetLoadProgramFunc(LoadProgram);
if (IDOK != startup.DoModal())
{
pMainFrame->SendMessage(WM_CLOSE);
return FALSE;
}
//*/
/* Show Splash Window
CSplashDlg splash;
CBitmap bmp;
bmp.LoadBitmap(IDB_SPLASH);
splash.SetBitmap(HBITMAP(bmp.GetSafeHandle()));
splash.Create(NULL, 0, AfxGetSView().GetU(), AfxGetSView().GetS(), AfxGetVersionString(), FALSE, 0, STKLIB_MAX_PROGRESS);
splash.ShowWindow(SW_SHOW);
splash.UpdateWindow();
LoadProgram(splash.GetSafeHwnd(), 0, STKLIB_MAX_PROGRESS);
splash.DestroyWindow();
//*/
// //////////////////////////////////////////////////////////////
// Open Simulation Strategy
if (GetFirstStrategyPosition() == NULL)
{
if (OpenLastOpenedStrategy() == 0)
OpenDefaultStrategy();
}
//if (!AfxGetStaticDoc()->GetViewIfExist(RUNTIME_CLASS(CSListView)))
// AfxGetStaticDoc()->ShowStaticView(RUNTIME_CLASS(CSListView), TRUE);
//AfxSwitchToStaticView(RUNTIME_CLASS(CSListView));
AfxGetProfile().SetCurrentStock(STKLIB_CODE_SZZS, FALSE);
((CMainFrame*)m_pMainWnd)->m_SearchBox.InitStocks( TRUE, TRUE, TRUE );
((CMainFrame*)m_pMainWnd)->m_SearchBox.SetCurrentWindowText();
//*//////////////////////////////////////////////////////////////
// Dispatch commands specified on the command line
if( CCommandLineInfo::AppUnregister == cmdInfo.m_nShellCommand )
{
AfxUnregisterShellFileTypes();
if (!cmdInfo.m_bRunEmbedded)
AfxMessageBox(AFX_IDP_UNREG_DONE, MB_OK | MB_ICONINFORMATION);
if (m_pCmdInfo == NULL)
{
m_pCmdInfo = new CCommandLineInfo;
m_pCmdInfo->m_nShellCommand = CCommandLineInfo::AppUnregister;
}
return FALSE;
}
// Dispatch commands specified on the command line
if (cmdInfo.m_nShellCommand == CCommandLineInfo::FileOpen)
{
OpenStrategyFile(cmdInfo.m_strFileName);
AfxSwitchToStaticView(RUNTIME_CLASS(CSimuView));
}
// 启动通视接收系统，不显示选择接收系统对话框
//AfxGetStkReceiver().EngineBeginWorking(FALSE);
// The one and only window has been initialized, so show and update it.
// Load Last WindowPlacement
WINDOWPLACEMENT wp;
if (AfxGetProfile().GetWindowPlacement(&wp))
m_pMainWnd->SetWindowPlacement(&wp);
else
m_pMainWnd->ShowWindow(SW_SHOWMAXIMIZED);
// Enable drag/drop open
//m_pMainWnd->DragAcceptFiles();
// Check New Version
m_pMainWnd->SetTimer(TIMER_AUTOUPDATE, 5000, NULL);
return TRUE;
}
BOOL AFXAPI AfxUnlockTempMaps(BOOL bDeleteTemps)
{
AFX_MODULE_THREAD_STATE* pState = AfxGetModuleThreadState();
if (pState->m_nTempMapLock != 0 && --pState->m_nTempMapLock == 0)
{
if (bDeleteTemps)
{
if (bDeleteTemps != -1)
{
// allow COM libraries to be freed
CWinThread* pThread = AfxGetThread();
if (pThread != NULL && pThread->m_lpfnOleTermOrFreeLib != NULL)
(*pThread->m_lpfnOleTermOrFreeLib)(FALSE, FALSE);
}
// clean up temp objects
// pState->m_pmapHGDIOBJ->DeleteTemp();
// pState->m_pmapHDC->DeleteTemp();
// pState->m_pmapHMENU->DeleteTemp();
// pState->m_pmapHWND->DeleteTemp();
// pState->m_pmapHIMAGELIST->DeleteTemp();
}
#ifndef _AFX_PORTABLE
CWinApp* pApp = AfxGetApp();
_AFX_THREAD_STATE* pThreadState = _afxThreadState.GetDataNA();
if( pThreadState != NULL )
{
// restore safety pool after temp objects destroyed
if (pApp != NULL &&
(pThreadState->m_pSafetyPoolBuffer == NULL ||
_msize(pThreadState->m_pSafetyPoolBuffer) < pApp->m_nSafetyPoolSize) &&
pApp->m_nSafetyPoolSize != 0)
{
// attempt to restore the safety pool to its max size
size_t nOldSize = 0;
if (pThreadState->m_pSafetyPoolBuffer != NULL)
{
nOldSize = _msize(pThreadState->m_pSafetyPoolBuffer);
nb_free(pThreadState->m_pSafetyPoolBuffer);
}
// undo handler trap for the following allocation
BOOL bEnable = AfxEnableMemoryTracking(FALSE);
try
{
pThreadState->m_pSafetyPoolBuffer = nb_malloc(pApp->m_nSafetyPoolSize);
if (pThreadState->m_pSafetyPoolBuffer == NULL)
{
// at least get the old buffer back
if (nOldSize != 0)
{
//get it back
pThreadState->m_pSafetyPoolBuffer = nb_malloc(nOldSize);
ASSERT(pThreadState->m_pSafetyPoolBuffer != NULL);
}
}
}
catch( CException * )
{
AfxEnableMemoryTracking(bEnable);
throw;
}
AfxEnableMemoryTracking(bEnable);
}
}
#endif // !_AFX_PORTABLE
}
// return TRUE if temp maps still locked
return pState->m_nTempMapLock != 0;
}
void CHandleMap::SetPermanent(HANDLE h, CObject* permOb)
{
BOOL bEnable = AfxEnableMemoryTracking(FALSE);
m_permanentMap[(LPVOID)h] = permOb;
AfxEnableMemoryTracking(bEnable);
}
CObject* CHandleMap::FromHandle(HANDLE h)
{
ASSERT(m_pClass != NULL);
ASSERT(m_nHandles == 1 || m_nHandles == 2);
if (h == NULL)
return NULL;
CObject* pObject = LookupPermanent(h);
if (pObject != NULL)
return pObject; // return permanent one
else if ((pObject = LookupTemporary(h)) != NULL)
{
HANDLE* ph = (HANDLE*)((BYTE*)pObject + m_nOffset);
ASSERT(ph[0] == h || ph[0] == NULL);
ph[0] = h;
if (m_nHandles == 2)
{
ASSERT(ph[1] == h || ph[1] == NULL);
ph[1] = h;
}
return pObject; // return current temporary one
}
// This handle wasn't created by us, so we must create a temporary
// C++ object to wrap it. We don't want the user to see this memory
// allocation, so we turn tracing off.
BOOL bEnable = AfxEnableMemoryTracking(FALSE);
#ifndef _AFX_PORTABLE
_PNH pnhOldHandler = AfxSetNewHandler(&AfxCriticalNewHandler);
#endif
CObject* pTemp = NULL;
TRY
{
pTemp = m_pClass->CreateObject();
if (pTemp == NULL)
AfxThrowMemoryException();
m_temporaryMap.SetAt((LPVOID)h, pTemp);
}
CATCH_ALL(e)
{
#ifndef _AFX_PORTABLE
AfxSetNewHandler(pnhOldHandler);
#endif
AfxEnableMemoryTracking(bEnable);
THROW_LAST();
}
END_CATCH_ALL
#ifndef _AFX_PORTABLE
AfxSetNewHandler(pnhOldHandler);
#endif
AfxEnableMemoryTracking(bEnable);
// now set the handle in the object
HANDLE* ph = (HANDLE*)((BYTE*)pTemp + m_nOffset); // after CObject
ph[0] = h;
if (m_nHandles == 2)
ph[1] = h;
return pTemp;
}
