int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR /*lpstrCmdLine*/, int /*nCmdShow*/)
{
HRESULT hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT(SUCCEEDED(hRes));
// this resolves ATL window thunking problem when Microsoft Layer for Unicode (MSLU) is used
::DefWindowProc(NULL, 0, 0, 0L);
AtlInitCommonControls(ICC_BAR_CLASSES); // add flags to support other controls
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
int nRet = 0;
// BLOCK: Run application
{
CMainDlg dlgMain;
nRet = dlgMain.DoModal();
}
_Module.Term();
::CoUninitialize();
return nRet;
}
BOOL WINAPI DllMain (HINSTANCE hInst, DWORD dwReason, LPVOID lpvReserved)
{
if(dwReason == DLL_PROCESS_ATTACH) {
hInstance = hInst;
HRESULT hRes = ::CoInitialize(NULL);
// If you are running on NT 4.0 or higher you can use the following call instead to
// make the EXE free threaded. This means that calls come in on a random RPC thread.
// HRESULT hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT(SUCCEEDED(hRes));
#if 0
INITCOMMONCONTROLSEX iccx;
iccx.dwSize = sizeof(iccx);
iccx.dwICC = ICC_BAR_CLASSES|ICC_PROGRESS_CLASS ; // change to support other controls
BOOL bRet = ::InitCommonControlsEx(&iccx);
bRet;
ATLASSERT(bRet);
#else
::InitCommonControls();
#endif
hRes = _Module.Init(NULL, hInstance);
V2::GUI::Initialize(); // 4 gdiplus
ATLASSERT(SUCCEEDED(hRes));
} else if(dwReason == DLL_PROCESS_DETACH) {
V2::GUI::Uninitialize(); // 4 gdiplus
_Module.Term();
::CoUninitialize();
}
return 1;
}
/**
* @brief Application entry point.
* @param hInstance - Handle to the current instance of the application.
* @param hPrevInstance - Handle to the previous instance of the application. This parameter is always NULL.
* @param pszCmdLine - Pointer to a null-terminated string specifying the command line for the application, excluding the program name.
* @param nCmdShow - Specifies how the window is to be shown.
*/
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, PTSTR pszCmdLine, int nCmdShow)
{
#ifdef _CRTDBG_MAP_ALLOC
// Watch for memory leaks.
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
HRESULT hRes = OleInitialize(NULL);
ATLASSERT(SUCCEEDED(hRes));
// This resolves ATL window thunking problem when Microsoft Layer for Unicode (MSLU) is used.
::DefWindowProc(NULL, 0, 0, 0L);
AtlInitCommonControls(ICC_LISTVIEW_CLASSES | ICC_BAR_CLASSES); // Add flags to support other controls.
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
int nRet = Run(pszCmdLine, nCmdShow);
_Module.Term();
OleUninitialize();
return nRet;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow)
{
#if 0
MessageBox(NULL, "attach debugger", "tips", IDOK);
#endif
//Initializes the COM library on the current thread and identifies the concurrency model as single-thread apartment (STA).
HRESULT hRes = ::CoInitialize(NULL);
ATLASSERT(SUCCEEDED(hRes));
// Ensures that the common control DLL (Comctl32.dll) is loaded, and registers specific common control classes from the DLL.
// An application must call this function before creating a common control.
AtlInitCommonControls(ICC_COOL_CLASSES | ICC_BAR_CLASSES);
hRes = _Module.Init(NULL, hInstance);
int nRet = Run(lpstrCmdLine, nCmdShow);
_Module.Term();
//Closes the COM library on the current thread, unloads all DLLs loaded by the thread,
//frees any other resources that the thread maintains, and forces all RPC connections on the thread to close.
::CoUninitialize();
return nRet;
}
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow)
{
HRESULT hRes = ::CoInitialize(NULL);
Gdiplus::GdiplusStartupInput gdiplusStartupInput;
ULONG_PTR gdiplusToken;
Gdiplus::GdiplusStartup( &gdiplusToken, &gdiplusStartupInput, NULL );
// If you are running on NT 4.0 or higher you can use the following call instead to
// make the EXE free threaded. This means that calls come in on a random RPC thread.
// HRESULT hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT( SUCCEEDED(hRes) );
// in WinMain
INITCOMMONCONTROLSEX icce;
icce.dwSize = sizeof(INITCOMMONCONTROLSEX);
icce.dwICC = ICC_BAR_CLASSES | ICC_COOL_CLASSES | ICC_USEREX_CLASSES;
InitCommonControlsEx(&icce);
// this resolves ATL window thunking problem when Microsoft Layer for Unicode (MSLU) is used
::DefWindowProc( NULL, 0, 0, 0L );
AtlInitCommonControls( ICC_BAR_CLASSES ); // add flags to support other controls
hRes = _Module.Init( NULL, hInstance );
ATLASSERT( SUCCEEDED(hRes) );
int nRet = Run( lpstrCmdLine, nCmdShow );
_Module.Term();
::CoUninitialize();
return nRet;
}
BOOL APIENTRY DllMain( HANDLE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
// init resource module
resutils::set_handle((HMODULE)hModule);
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
{
HRESULT hRes = _Module.Init(NULL, (HINSTANCE) hModule);
ATLASSERT(SUCCEEDED(hRes)); // Don't call important functions inside ASSERT.
}
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
break;
case DLL_PROCESS_DETACH:
_Module.Term();
break;
}
return TRUE;
}
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow)
{
HRESULT hRes = CMiniPieFrame::ActivatePreviousInstance(hInstance, lpstrCmdLine);
if(FAILED(hRes) || S_FALSE == hRes)
{
return hRes;
}
hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT(SUCCEEDED(hRes));
AtlInitCommonControls(ICC_DATE_CLASSES);
SHInitExtraControls();
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
AtlAxWinInit();
int nRet = CMiniPieFrame::AppRun(lpstrCmdLine, nCmdShow);
AtlAxWinTerm();
_Module.Term();
::CoUninitialize();
return nRet;
}
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR /*lpstrCmdLine*/, int /*nCmdShow*/)
{
HRESULT hRes = ::CoInitialize(NULL);
ATLASSERT(SUCCEEDED(hRes));
INITCOMMONCONTROLSEX iccx;
iccx.dwSize = sizeof(iccx);
iccx.dwICC = ICC_COOL_CLASSES | ICC_BAR_CLASSES;
BOOL bRet = ::InitCommonControlsEx(&iccx);
bRet;
ATLASSERT(bRet);
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
int nRet;
{
CMainDlg dlgMain;
nRet = dlgMain.DoModal();
}
_Module.Term();
::CoUninitialize();
return nRet;
}
int WINAPI wWinMain(_In_ HINSTANCE hInstance,
_In_opt_ HINSTANCE hPrevInstance,
_In_ PWSTR lpCmdLine,
_In_ int nCmdShow)
{
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
if (!CoInitializeSingle::Initialize()){
}
HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);
Metro::MUI::muiController.Init();
_Module.Init(nullptr, hInstance);
MSG msg;
::InitCommonControls();
Metro::MetroWindow iMetroWindow;
RECT rect = { (::GetSystemMetrics(SM_CXSCREEN) - 720) / 2, (::GetSystemMetrics(SM_CYSCREEN) - 450) / 2, (::GetSystemMetrics(SM_CXSCREEN) + 720) / 2, (::GetSystemMetrics(SM_CYSCREEN) + 450) / 2 };
if (iMetroWindow.Create(nullptr, rect, METRO_INTERNAL_WINDOWLNAME, WS_OVERLAPPED | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, WS_EX_ACCEPTFILES) == nullptr)
{
return -1;
}
DWORD dwExit = 0;
iMetroWindow.ShowWindow(nCmdShow);
iMetroWindow.UpdateWindow();
while (GetMessage(&msg, nullptr, 0, 0)>0)
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
dwExit = iMetroWindow.GetExitCode();
_Module.Term();
return dwExit;
}
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow)
{
HRESULT hRes = ::CoInitialize(NULL);
// If you are running on NT 4.0 or higher you can use the following call instead to
// make the EXE free threaded. This means that calls come in on a random RPC thread.
// HRESULT hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT(SUCCEEDED(hRes));
// this resolves ATL window thunking problem when Microsoft Layer for Unicode (MSLU) is used
::DefWindowProc(NULL, 0, 0, 0L);
AtlInitCommonControls(ICC_BAR_CLASSES); // add flags to support other controls
//hRes = _Module.Init(NULL, hInstance);
GUID guid;
hRes = _Module.Init(NULL,hInstance,&guid);
ATLASSERT(SUCCEEDED(hRes));
BkString::Load(IDR_BK_STRING_DEF);
BkFontPool::SetDefaultFont(BkString::Get(IDS_APP_FONT), -12);
BkSkin::LoadSkins(IDR_BK_SKIN_DEF);
BkStyle::LoadStyles(IDR_BK_STYLE_DEF);
CMainDlg dlgMain;
dlgMain.DoModal();
_Module.Term();
::CoUninitialize();
return 0;
}
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR /*lpstrCmdLine*/, int /*nCmdShow*/)
{
HRESULT hRes = ::CoInitialize(NULL); //初始化COM
// If you are running on NT 4.0 or higher you can use the following call instead to
// make the EXE free threaded. This means that calls come in on a random RPC thread.
// HRESULT hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT(SUCCEEDED(hRes));
// this resolves ATL window thunking problem when Microsoft Layer for Unicode (MSLU) is used
::DefWindowProc(NULL, 0, 0, 0L);
AtlInitCommonControls(ICC_BAR_CLASSES); // add flags to support other controls
hRes = _Module.Init(NULL, hInstance); //全局对象_Module被初始化
ATLASSERT(SUCCEEDED(hRes));
BkString::Load(IDR_BK_STRING_DEF); //加载指定资源ID的string定义xml
BkFontPool::SetDefaultFont(BkString::Get(IDS_APP_FONT), -12);
BkSkin::LoadSkins(IDR_BK_SKIN_DEF); //加载指定资源ID的skin定义xml
BkStyle::LoadStyles(IDR_BK_STYLE_DEF); //加载指定资源ID的Style定义xml
int nRet = 0;
// BLOCK: Run application, 将CMainDlg变量放在一个区块中是很重要的
{
CMainDlg dlgMain;
nRet = dlgMain.DoModal();
}
_Module.Term();
::CoUninitialize();
return nRet;
}
int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{
UNREFERENCED_PARAMETER(hPrevInstance);
HRESULT hRes = ::CoInitialize(NULL);
// If you are running on NT 4.0 or higher you can use the following call instead to
// make the EXE free threaded. This means that calls come in on a random RPC thread.
//HRESULT hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT(SUCCEEDED(hRes));
// this resolves ATL window thunking problem when Microsoft Layer for Unicode (MSLU) is used
::DefWindowProc(NULL, 0, 0, 0L);
AtlInitCommonControls(ICC_BAR_CLASSES); // add flags to support other controls
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
int ret = Run(lpCmdLine);
_Module.Term();
::CoUninitialize();
return ret;
}
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow)
{
HRESULT hRes = ::CoInitialize(NULL);
// If you are running on NT 4.0 or higher you can use the following call instead to
// make the EXE free threaded. This means that calls come in on a random RPC thread.
// HRESULT hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT(SUCCEEDED(hRes));
// this resolves ATL window thunking problem when Microsoft Layer for Unicode (MSLU) is used
::DefWindowProc(NULL, 0, 0, 0L);
AtlInitCommonControls(ICC_COOL_CLASSES | ICC_BAR_CLASSES); // add flags to support other controls
HINSTANCE hInstRich = ::LoadLibrary(CRichEditCtrl::GetLibraryName());
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
AtlAxWinInit();
int nRet = 0;
// BLOCK: Run application
{
CBoggleThreadManager mgr;
nRet = mgr.Run(lpstrCmdLine, nCmdShow);
}
_Module.Term();
::CoUninitialize();
return nRet;
}
extern "C" __declspec(dllexport) void LoadLuaRunTime(char* szInstallDir)
{
TSTRACEAUTO();
HRESULT hr = ::CoInitialize(NULL);
hr = _Module.Init(NULL, gInstance);
CMessageLoop theLoop;
_Module.AddMessageLoop(&theLoop);
CLRTAgent lrtAgent;
//lrtAgent.InitLua(szInstallDir);
//g_hXappLuaToolDll = lrtAgent.GetXappLuaToolDllModuleHandle();
if (lrtAgent.InitLua(szInstallDir))
{
TSDEBUG4CXX(_T(">>>>>theLoop.Run()"));
theLoop.Run();
TSDEBUG4CXX(_T("<<<<<theLoop.Run()"));
}
_Module.RemoveMessageLoop();
_Module.Term();
::CoUninitialize();
TerminateProcess(::GetCurrentProcess(), S_OK);
return;
}
int __stdcall WinMain(HINSTANCE hinst, HINSTANCE, PSTR cmdLine, int cmdShow)
{
_Module.Init(0, hinst, 0);
CMessageLoop msgLoop;
_Module.AddMessageLoop(&msgLoop);
int result = -1;
CMainFrame frame;
frame.Create(
::GetDesktopWindow(),
CWindow::rcDefault,
TEXT("Notepad--"));
if (frame.IsWindow()) {
frame.ShowWindow(cmdShow);
result = msgLoop.Run();
}
_Module.RemoveMessageLoop();
_Module.Term();
return result;
}
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow)
{
initWinDbg();
#ifdef _DEBUG
#ifndef VLD
_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
#endif
#endif
HRESULT hRes = ::CoInitialize(NULL);
ATLASSERT(SUCCEEDED(hRes));
::DefWindowProc(NULL, 0, 0, 0L); // this resolves ATL window thunking problem when Microsoft Layer for Unicode (MSLU) is used
AtlInitCommonControls(ICC_COOL_CLASSES | ICC_BAR_CLASSES); // add flags to support other controls
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
Run(lpstrCmdLine, nCmdShow);
_Module.Term();
::CoUninitialize();
releaseWinDbg();
return 0;
}
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
_In_opt_ HINSTANCE hPrevInstance,
_In_ LPWSTR lpCmdLine,
_In_ int nCmdShow)
{
int exitCode = -1;
HRESULT hr = ::CoInitialize(NULL);
ATLASSERT(SUCCEEDED(hr));
AtlInitCommonControls(ICC_COOL_CLASSES | ICC_BAR_CLASSES);
hr = _Module.Init(NULL, hInstance);
CString cmdLine(lpCmdLine);
bool isQuiet = (cmdLine.Find(L"/quiet") >= 0);
if (!CFxHelper::IsDotNet45OrHigherInstalled()) {
hr = CFxHelper::InstallDotNetFramework(isQuiet);
if (hr != S_OK) {
goto out;
}
}
exitCode = CUpdateRunner::ExtractUpdaterAndRun(lpCmdLine);
out:
_Module.Term();
::CoUninitialize();
return exitCode;
}
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow)
{
HRESULT hRes = ::CoInitialize(NULL);
ATLASSERT(SUCCEEDED(hRes));
::DefWindowProc(NULL, 0, 0, 0L);
AtlInitCommonControls(ICC_BAR_CLASSES);
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
///> ³õʼ»¯BKWIN
BkString::Load(IDR_BK_STRING_DEF);
BkSkin::LoadSkins(IDR_BK_SKIN_DEF);
BkStyle::LoadStyles(IDR_BK_STYLE_DEF);
int nRet = Run(lpstrCmdLine, nCmdShow);
_Module.Term();
::CoUninitialize();
return nRet;
}
int WINAPI wWinMain(_In_ HINSTANCE hInstance,
_In_opt_ HINSTANCE hPrevInstance,
_In_ PWSTR lpCmdLine,
_In_ int nCmdShow)
{
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
muiController->Init();
_Module.Init(nullptr, hInstance);
MSG msg;
::InitCommonControls();
Metro::MetroWindow iMetroWindow;
RECT rect = { (::GetSystemMetrics(SM_CXSCREEN) - 720) / 2, (::GetSystemMetrics(SM_CYSCREEN) - 450) / 2, (::GetSystemMetrics(SM_CXSCREEN) + 720) / 2, (::GetSystemMetrics(SM_CYSCREEN) + 450) / 2 };
if (iMetroWindow.Create(nullptr, rect, METRO_INTERNAL_WINDOWLNAME, WS_OVERLAPPED | WS_CLIPSIBLINGS | WS_MINIMIZEBOX | WS_POPUP | WS_SYSMENU, WS_EX_APPWINDOW | WS_EX_WINDOWEDGE|WS_EX_ACCEPTFILES) == nullptr)
{
return -1;
}
DWORD dwExit = 0;
iMetroWindow.ShowWindow(nCmdShow);
iMetroWindow.UpdateWindow();
while (GetMessage(&msg, nullptr, 0, 0)>0)
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
dwExit = iMetroWindow.GetExitCode();
::CoUninitialize();
_Module.Term();
return dwExit;
}
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR /*lpstrCmdLine*/, int /*nCmdShow*/)
{
HRESULT hRes = ::CoInitialize(NULL);
// If you are running on NT 4.0 or higher you can use the following call instead to
// make the EXE free threaded. This means that calls come in on a random RPC thread.
// HRESULT hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT(SUCCEEDED(hRes));
// this resolves ATL window thunking problem when Microsoft Layer for Unicode (MSLU) is used
::DefWindowProc(NULL, 0, 0, 0L);
AtlInitCommonControls(ICC_BAR_CLASSES); // add flags to support other controls
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
int nRet = 0;
// BLOCK: Run application
{
CMainDlg dlgMain;
nRet = dlgMain.DoModal();
}
_Module.Term();
::CoUninitialize();
return nRet;
}
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow)
{
HRESULT hRes = ::CoInitialize(NULL);
// If you are running on NT 4.0 or higher you can use the following call instead to
// make the EXE free threaded. This means that calls come in on a random RPC thread.
// HRESULT hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT(SUCCEEDED(hRes));
WSADATA wsaData;
WSAStartup(MAKEWORD(2,2), &wsaData);
Scintilla_RegisterClasses(hInstance);
// this resolves ATL window thunking problem when Microsoft Layer for Unicode (MSLU) is used
::DefWindowProc(NULL, 0, 0, 0L);
AtlInitCommonControls(ICC_COOL_CLASSES | ICC_BAR_CLASSES); // add flags to support other controls
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
int nRet = Run(lpstrCmdLine, nCmdShow);
_Module.Term();
Scintilla_ReleaseResources();
WSACleanup();
::CoUninitialize();
return nRet;
}
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow)
{
_tsetlocale(LC_CTYPE, L""); //make CRT character handling functions handle not only C string (lower/upper case funcs)
//maybe we need also to tell the compiler how to handle its chars (http://msdn.microsoft.com/en-us/library/3e22ty2t.aspx)
// If you are running on NT 4.0 or higher you can use the following call instead to
// make the EXE free threaded. This means that calls come in on a random RPC thread.
HRESULT hRes = ::CoInitializeEx(NULL, COINIT_APARTMENTTHREADED); //new call
ATLASSERT(SUCCEEDED(hRes));
// this resolves ATL window thunking problem when Microsoft Layer for Unicode (MSLU) is used
::DefWindowProc(NULL, 0, 0, 0L);
AtlInitCommonControls(ICC_BAR_CLASSES); // add flags to support other controls
// GDI+ initialization
ULONG_PTR gdiplusToken;
Gdiplus::GdiplusStartupInput gdiplusStartupInput;
Gdiplus::Status gdiPlusStatus = GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
ATLASSERT( gdiPlusStatus==Gdiplus::Ok );
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
srand(::GetTickCount());
int nRet = Run(lpstrCmdLine, nCmdShow);
// GDI+ deinitialization
GdiplusShutdown(gdiplusToken);
_Module.Term();
::CoUninitialize();
return nRet;
}
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow)
{
HRESULT hRes = ::CoInitialize(NULL);
// If you are running on NT 4.0 or higher you can use the following call instead to
// make the EXE free threaded. This means that calls come in on a random RPC thread.
// HRESULT hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT(SUCCEEDED(hRes));
#if (_WIN32_IE >= 0x0300)
INITCOMMONCONTROLSEX iccx;
iccx.dwSize = sizeof(iccx);
iccx.dwICC = ICC_BAR_CLASSES; // change to support other controls
BOOL bRet = ::InitCommonControlsEx(&iccx);
bRet;
ATLASSERT(bRet);
#else
::InitCommonControls();
#endif
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
int nRet = Run(lpstrCmdLine, nCmdShow);
_Module.Term();
::CoUninitialize();
return nRet;
}
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow)
{
HRESULT hRes = ::CoInitialize(NULL);
// If you are running on NT 4.0 or higher you can use the following call instead to
// make the EXE free threaded. This means that calls come in on a random RPC thread.
// HRESULT hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT(SUCCEEDED(hRes));
hRes= ::CoInitializeSecurity( NULL, //Points to security descriptor
-1, //Count of entries in asAuthSvc
NULL, //Array of names to register
NULL, //Reserved for future use
RPC_C_AUTHN_LEVEL_CONNECT, // RPC_C_AUTHN_LEVEL_NONE The default authentication //level for proxies
RPC_C_IMP_LEVEL_IDENTIFY, //The default impersonation //level for proxies
NULL, //Reserved; must be set to NULL
EOAC_NONE, //Additional client or //server-side capabilities
NULL //Reserved for future use
);
ATLASSERT(SUCCEEDED(hRes));
// this resolves ATL window thunking problem when Microsoft Layer for Unicode (MSLU) is used
::DefWindowProc(NULL, 0, 0, 0L);
AtlInitCommonControls(ICC_BAR_CLASSES); // add flags to support other controls
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
int nRet = Run(lpstrCmdLine, nCmdShow);
_Module.Term();
::CoUninitialize();
return nRet;
}
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow)
{
HRESULT hRes = ::CoInitialize(NULL);
// If you are running on NT 4.0 or higher you can use the following call instead to
// make the EXE free threaded. This means that calls come in on a random RPC thread.
// HRESULT hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT(SUCCEEDED(hRes));
g_settingsHandler.reset(new SettingsHandler());
g_imageHandler.reset(new ImageHandler());
// this resolves ATL window thunking problem when Microsoft Layer for Unicode (MSLU) is used
::DefWindowProc(NULL, 0, 0, 0L);
AtlInitCommonControls(ICC_COOL_CLASSES | ICC_BAR_CLASSES); // add flags to support other controls
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
int nRet = Run(lpstrCmdLine, nCmdShow);
_Module.Term();
g_settingsHandler.reset();
::CoUninitialize();
return nRet;
}
int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
CoInitialize(NULL);
SetUnhandledExceptionFilter(HandleUnknownException);
AtlInitCommonControls(ICC_LISTVIEW_CLASSES | ICC_TREEVIEW_CLASSES);
HRESULT hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
int nRet = 0;
// BLOCK: Run application
{
MainGui dlgMain;
pMainGui = &dlgMain; // o_O
CMessageLoop loop;
_Module.AddMessageLoop(&loop);
dlgMain.Create(GetDesktopWindow());
dlgMain.ShowWindow(SW_SHOW);
loop.Run();
}
_Module.Term();
CoUninitialize();
return nRet;
}
int __stdcall _tWinMain(HINSTANCE hInstance, HINSTANCE, LPTSTR lpCmdLine, int)
{
HRESULT hRes = ::CoInitialize(NULL);
// If you are running on NT 4.0 or higher you can use the following call instead to
// make the EXE free threaded. This means that calls come in on a random RPC thread.
// HRESULT hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT(SUCCEEDED(hRes));
// this resolves ATL window thunking problem when Microsoft Layer for Unicode (MSLU) is used
::DefWindowProc(NULL, 0, 0, 0L);
AtlInitCommonControls(ICC_BAR_CLASSES); // add flags to support other controls
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
#ifdef BAZISLIB_LOCALIZATION_ENABLED
RegistryParams params;
params.LoadFromRegistry();
InitializeLNGBasedTranslationEngine(params.Language);
#endif
int nRet = AppMain();
#ifdef BAZISLIB_LOCALIZATION_ENABLED
ShutdownTranslationEngine();
#endif
_Module.Term();
::CoUninitialize();
return nRet;
}
int WINAPI _tWinMain( HINSTANCE hInst, HINSTANCE, LPTSTR, int )
{
_tsetlocale( LC_ALL, _T(".OCP") );
ATLVERIFY( SUCCEEDED( _Module.Init( NULL, hInst ) ) );
if( !EnableDebugPrivilege() )
{
MessageBoxV( NULL, IDS_NO_DEBUG_PRIVILEGE, MB_OK | MB_ICONHAND );
return 0;
}
InitializeCriticalSection( &g_cs );
LoadInternalExceptionList();
LoadSettings();
DumpInit();
if( !ProcessCommandLine() )
{
AtlInitCommonControls( ICC_BAR_CLASSES );
LoadLibrary( CRichEditCtrl::GetLibraryName() );
CMainDlg dlgMain;
g_pMainWnd = &dlgMain;
int nRet = dlgMain.DoModal();
g_pMainWnd = NULL;
}
DumpUninit();
SaveSettings();
DeleteCriticalSection( &g_cs );
_Module.Term();
return 0;
}
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow)
{
// HRESULT hRes = ::CoInitialize(NULL);
// If you are running on NT 4.0 or higher you can use the following call instead to
// make the EXE free threaded. This means that calls come in on a random RPC thread.
HRESULT hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT(SUCCEEDED(hRes));
// this resolves ATL window thunking problem when Microsoft Layer for Unicode (MSLU) is used
::DefWindowProc(NULL, 0, 0, 0L);
AtlInitCommonControls(ICC_COOL_CLASSES | ICC_BAR_CLASSES); // add flags to support other controls
hRes = _Module.Init(NULL, hInstance);
ATLASSERT(SUCCEEDED(hRes));
AtlAxWinInit();
int nRet = 0;
BOOL bFirstInst = CSingleInstApp::InitInstance(APP_INST_UID);
if (!bFirstInst) {
if (::lstrcmpi(_T("/exit"), lpstrCmdLine) == 0) {
CSingleInstApp::PostInstanceMesage(AIMSG_EXIT, 0);
nRet = 251;
} else if (::lstrcmpi(_T("/restart"), lpstrCmdLine) == 0) {
CSingleInstApp::PostInstanceMesage(AIMSG_EXIT, 0);
CSingleInstApp::WaitInstance(APP_INST_UID);
nRet = Run(lpstrCmdLine, nCmdShow);
CSingleInstApp::InitInstance(APP_INST_UID);
} else {
CSingleInstApp::PostInstanceMesage(AIMSG_POPUP, 0);
nRet = 250;
}
// ATOM atCmdLine = ::GlobalAddAtom(lpstrCmdLine);
// if (NULL != atCmdLine) {
// }
} else {
nRet = Run(lpstrCmdLine, nCmdShow);
}
_Module.Term();
::CoUninitialize();
return nRet;
}
BOOL APIENTRY DllMain( HANDLE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
if( ul_reason_for_call == DLL_PROCESS_ATTACH ) _Module.Init(NULL, (HMODULE)hModule);
if( ul_reason_for_call == DLL_PROCESS_DETACH ) _Module.Term();
return TRUE;
}
