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, PTSTR, int nShowCmd) { AtlInitCommonControls(ICC_WIN95_CLASSES); _Module.Init(NULL, hInstance); CMainFrame *frameWnd = new CMainFrame; if (!frameWnd->Create(NULL, NULL, PDBEXP_WNDCAPTION)) { delete frameWnd; return EXIT_FAILURE; } frameWnd->CenterWindow(); frameWnd->ShowWindow(nShowCmd); MSG msg; HACCEL hAccTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR)); while (GetMessage(&msg, NULL, 0, 0)) { if (0 == TranslateAccelerator(*frameWnd, hAccTable, &msg)) { TranslateMessage(&msg); DispatchMessage(&msg); } } _Module.Term(); return (int)msg.wParam; }
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) { 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 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*/) { 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 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); // 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 | ICC_WIN95_CLASSES | ICC_DATE_CLASSES | ICC_USEREX_CLASSES | ICC_COOL_CLASSES | ICC_PAGESCROLLER_CLASS | ICC_NATIVEFNTCTL_CLASS); // add flags to support other controls hRes = _Module.Init(NULL, hInstance); ATLASSERT(SUCCEEDED(hRes)); CString strCmd(lpstrCmdLine); if (-1 != strCmd.Find(_T("/FloatBar"))) Config::StartupShowFloatBar = true; int nRet = _Module.Main(); //Run(lpstrCmdLine, nCmdShow); _Module.Term(); ::CoUninitialize(); return nRet; }
/** * @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 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 = 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) { _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)); // 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; }
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_BAR_CLASSES); // add flags to support other controls hRes = _Module.Init(NULL, hInstance); ATLASSERT(SUCCEEDED(hRes)); CMessageLoop theLoop; CMessageFilter * filter = new CMouseWheelFilter(); theLoop.AddMessageFilter(filter); _Module.AddMessageLoop(&theLoop); CMainDlg dlgMain; dlgMain.Create(NULL); dlgMain.ShowWindow(SW_NORMAL); int nRet = theLoop.Run(); delete filter; _Module.RemoveMessageLoop(); //_Module.Term(); ::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 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 _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); // 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 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)); // 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; }
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)); _isSysInstall = isServiceRunning(SERVICE_NAME); int nRet = EXIT_SUCCESS; if (_isSysInstall) { while (1) { CLoginDlg dlg; if (IDOK == dlg.DoModal(NULL)) { if (login(dlg.m_passWord.GetBuffer(0))) { lstrcpy(_passWord, dlg.m_passWord.GetBuffer(0)); Run(lpstrCmdLine, nCmdShow); break; } else { MessageBox(NULL, _T("ÃÜÂë´íÎó£¬ÇëÖØÐÂÊäÈëÃÜÂë!"), _T("´íÎó"), MB_OK | MB_ICONERROR); } } else { break; } } } else { nRet = Run(lpstrCmdLine, nCmdShow); } _Module.Term(); ::CoUninitialize(); return nRet; }
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow) { HRESULT hRes = CoInitialize(nullptr); ATLASSERT(SUCCEEDED(hRes)); ::DefWindowProc(nullptr, 0, 0, 0L); AtlInitCommonControls(ICC_BAR_CLASSES); hRes = _Module.Init(nullptr, 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) { OleInitialize(NULL); AtlInitCommonControls(ICC_COOL_CLASSES|ICC_BAR_CLASSES|ICC_WIN95_CLASSES); _Module.Init(NULL, hInstance); g_bXPOrLater = _winmajor > 5 || (_winmajor == 5 && _winminor > 0); int nRet = Run ( lpstrCmdLine, nCmdShow ); _Module.Term(); OleUninitialize(); return nRet; }
int WINAPI _tWinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPTSTR cmdline,int nCmdShow) { if (FindWindowEx(NULL,NULL,NULL,_T("怫UUFile")) != NULL) { return -1; } else { HRESULT hRes = ::CoInitialize(NULL); ::DefWindowProc(NULL, 0, 0, 0L); AtlInitCommonControls(ICC_BAR_CLASSES); hRes = _Module.Init(NULL, hInstance); int nRet = Run(cmdline, nCmdShow); _Module.Term(); ::CoUninitialize(); return nRet; } }
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow) { // 防止服务进程开启输入法 ImmDisableIME(-1); 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)); RimeSetupLogging("rime.weasel"); // command line option /q stops the running server bool quit = !wcscmp(L"/q", lpstrCmdLine) || !wcscmp(L"/quit", lpstrCmdLine); //bool restart = !wcscmp(L"/restart", lpstrCmdLine); //if (quit || restart) { weasel::Client client; if (client.Connect()) client.ShutdownServer(); if (quit) return 0; } int nRet = 0; try { WeaselServerApp app; nRet = app.Run(); } catch (...) { // bad luck... nRet = -1; } _Module.Term(); ::CoUninitialize(); return nRet; }
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow) { tstring strFileName = ZYM::CPath::GetAppPath() + _T("ImageOleCtrl.dll"); BOOL bRet = DllRegisterServer(strFileName.c_str()); // 注册COM组件 if (!bRet) { ::MessageBox(NULL, _T("COM组件注册失败,应用程序无法完成初始化操作!"), _T("提示"), MB_OK); return 0; } HRESULT hRes = ::OleInitialize(NULL); //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 HMODULE hRichEditDll = ::LoadLibrary(CRichEditCtrl::GetLibraryName()); // 加载RichEdit控件DLL hRes = _Module.Init(NULL, hInstance); ATLASSERT(SUCCEEDED(hRes)); CSkinManager::Init(); // 初始化皮肤管理器 tstring strSkinPath = ZYM::CPath::GetAppPath() + _T("Skins\\"); // 设置皮肤文件夹路径 CSkinManager::GetInstance()->SetSkinPath(strSkinPath.c_str()); CSkinManager::GetInstance()->LoadConfigXml(); // 加载皮肤列表配置文件 int nRet = Run(lpstrCmdLine, nCmdShow); CSkinManager::UnInit(); // 反初始化皮肤管理器 if (hRichEditDll != NULL) // 卸载RichEdit控件DLL { ::FreeLibrary(hRichEditDll); hRichEditDll = NULL; } _Module.Term(); //::CoUninitialize(); ::OleUninitialize(); 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)); RimeSetupLogging("rime.weasel"); CreateDirectory(WeaselUserDataPath().c_str(), NULL); int ret = 0; HANDLE hMutex = CreateMutex(NULL, TRUE, L"WeaselDeployerExclusiveMutex"); if (!hMutex) { ret = 1; } else if (GetLastError() == ERROR_ALREADY_EXISTS) { ret = 1; } else { ret = Run(lpCmdLine); } if (hMutex) { CloseHandle(hMutex); } _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(0); // add flags to support other controls hRes = _Module.Init(NULL, hInstance); ATLASSERT(SUCCEEDED(hRes)); InitWindowsThemeColorApi(); int nRet = 0; COLORREF dwmColor; bool dwmColorValid = GetColorParam(L"-dwm_color", &dwmColor); COLORREF accentColor; bool accentColorValid = GetColorParam(L"-accent_color", &accentColor); if(dwmColorValid || accentColorValid) { if(accentColorValid) { SetAccentColor(accentColor); } if(dwmColorValid) { SetDwmColorizationColor(dwmColor); } } else // BLOCK: Run application { CMainDlg dlgMain; nRet = dlgMain.DoModal(); } _Module.Term(); ::CoUninitialize(); return nRet; }