int _tmain(int argc, _TCHAR* argv[]) { /* //MT4|ASK!EURUSD char szApp[] = "MT4"; char szTopic[] = "ASK"; //char szCmd1[] = "[APP.MINIMIZE()]"; char szItem1[] = "USDJPY"; char szDesc1[] = "A1 Contains: "; char szItem2[] = "USDCHF"; char szDesc2[] = "A2 Contains: "; //char szItem3[] = "R3C1"; char szData3[] = "Data from DDE Client"; //char szCmd2[] = "[SELECT(\"R3C1\")][FONT.PROPERTIES(,\"Bold\")][SAVE()][QUIT()]"; */ //DDE Initialization UINT iReturn; iReturn = DdeInitialize(&idInst, (PFNCALLBACK)DdeCallback, APPCLASS_STANDARD | APPCMD_CLIENTONLY, 0 ); if (iReturn!=DMLERR_NO_ERROR) { printf("DDE Initialization Failed: 0x%04x\n", iReturn); Sleep(1500); return 0; } //Start DDE Server and wait for it to become idle. //HINSTANCE hRet = ShellExecute(0, "open", szTopic, 0, 0, SW_SHOWNORMAL); //if ((int)hRet < 33) //{ // printf("Unable to Start DDE Server: 0x%04x\n", hRet); // Sleep(1500); DdeUninitialize(idInst); // return 0; //} //Sleep(1000); //DDE Connect to Server using given AppName and topic. HCONV hConv; hszApp = DdeCreateStringHandle(idInst, szApp, 0); hszTopic = DdeCreateStringHandle(idInst, szTopic, 0); hConv = DdeConnect(idInst, hszApp, hszTopic, NULL); DdeFreeStringHandle(idInst, hszApp); DdeFreeStringHandle(idInst, hszTopic); if (hConv == NULL) { printf("DDE Connection Failed.\n"); Sleep(1500); DdeUninitialize(idInst); return 0; } //Execute commands/requests specific to the DDE Server. //DDEExecute(idInst, hConv, szCmd1); DDERequest(idInst, hConv, szItem1, szDesc1); DDERequest(idInst, hConv, szItem2, szDesc2); //DDEPoke(idInst, hConv, szItem3, szData3); //DDEExecute(idInst, hConv, szCmd2); BOOL bRet; MSG msg; while( (bRet = GetMessage( &msg, NULL, 0, 0 )) != 0) { if (bRet == -1) { // handle the error and possibly exit } else { TranslateMessage(&msg); DispatchMessage(&msg); } } //DDE Disconnect and Uninitialize. DdeDisconnect(hConv); DdeUninitialize(idInst); Sleep(3000); return 1; }
void SampleMain() { SfwOpenWindow("Gainput: Gesture sample"); gainput::TrackingAllocator allocator(gainput::GetDefaultAllocator()); gainput::InputManager manager(true, allocator); const gainput::DeviceId keyboardId = manager.CreateDevice<gainput::InputDeviceKeyboard>(); const gainput::DeviceId mouseId = manager.CreateDevice<gainput::InputDeviceMouse>(); gainput::InputDeviceTouch* touchDevice = manager.CreateAndGetDevice<gainput::InputDeviceTouch>(); GAINPUT_ASSERT(touchDevice); gainput::DeviceId touchId = touchDevice->GetDeviceId(); #if defined(GAINPUT_PLATFORM_LINUX) || defined(GAINPUT_PLATFORM_WIN) manager.SetDisplaySize(SfwGetWidth(), SfwGetHeight()); #endif SfwSetInputManager(&manager); gainput::InputMap map(manager, "testmap", allocator); map.MapBool(ButtonConfirm, mouseId, gainput::MouseButtonLeft); gainput::DoubleClickGesture* dcg = manager.CreateAndGetDevice<gainput::DoubleClickGesture>(); GAINPUT_ASSERT(dcg); dcg->Initialize(mouseId, gainput::MouseButtonLeft, mouseId, gainput::MouseAxisX, 0.01f, mouseId, gainput::MouseAxisY, 0.01f, 500); map.MapBool(ButtonConfirmDouble, dcg->GetDeviceId(), gainput::DoubleClickTriggered); gainput::SimultaneouslyDownGesture* sdg = manager.CreateAndGetDevice<gainput::SimultaneouslyDownGesture>(); GAINPUT_ASSERT(sdg); sdg->AddButton(mouseId, gainput::MouseButtonLeft); sdg->AddButton(keyboardId, gainput::KeyShiftL); map.MapBool(ButtonConfirmExtra, sdg->GetDeviceId(), gainput::SimultaneouslyDownTriggered); MultiTouchEmulator* mte = manager.CreateAndGetDevice<MultiTouchEmulator>(); mte->Initialize(sdg->GetDeviceId(), gainput::SimultaneouslyDownTriggered, mouseId, gainput::MouseAxisX, mouseId, gainput::MouseAxisY, mouseId, gainput::MouseButtonLeft, mouseId, gainput::MouseAxisX, mouseId, gainput::MouseAxisY); if (!touchDevice->IsAvailable() || touchDevice->GetVariant() == gainput::InputDevice::DV_NULL) { touchId = mte->GetDeviceId(); } gainput::HoldGesture* hg = manager.CreateAndGetDevice<gainput::HoldGesture>(); GAINPUT_ASSERT(hg); hg->Initialize(touchId, gainput::Touch0Down, touchId, gainput::Touch0X, 0.1f, touchId, gainput::Touch0Y, 0.1f, true, 800); map.MapBool(ButtonHoldGesture, hg->GetDeviceId(), gainput::HoldTriggered); gainput::TapGesture* tg = manager.CreateAndGetDevice<gainput::TapGesture>(); GAINPUT_ASSERT(tg); tg->Initialize(touchId, gainput::Touch0Down, 500); map.MapBool(ButtonTapGesture, tg->GetDeviceId(), gainput::TapTriggered); gainput::PinchGesture* pg = manager.CreateAndGetDevice<gainput::PinchGesture>(); GAINPUT_ASSERT(pg); pg->Initialize(touchId, gainput::Touch0Down, touchId, gainput::Touch0X, touchId, gainput::Touch0Y, touchId, gainput::Touch1Down, touchId, gainput::Touch1X, touchId, gainput::Touch1Y); map.MapBool(ButtonPinching, pg->GetDeviceId(), gainput::PinchTriggered); map.MapFloat(ButtonPinchScale, pg->GetDeviceId(), gainput::PinchScale); gainput::RotateGesture* rg = manager.CreateAndGetDevice<gainput::RotateGesture>(); GAINPUT_ASSERT(rg); rg->Initialize(touchId, gainput::Touch0Down, touchId, gainput::Touch0X, touchId, gainput::Touch0Y, touchId, gainput::Touch1Down, touchId, gainput::Touch1X, touchId, gainput::Touch1Y); map.MapBool(ButtonRotating, rg->GetDeviceId(), gainput::RotateTriggered); map.MapFloat(ButtonRotateAngle, rg->GetDeviceId(), gainput::RotateAngle); bool doExit = false; while (!SfwIsDone() && !doExit) { manager.Update(); #if defined(GAINPUT_PLATFORM_LINUX) XEvent event; while (XPending(SfwGetXDisplay())) { XNextEvent(SfwGetXDisplay(), &event); manager.HandleEvent(event); if (event.type == DestroyNotify || event.type == ClientMessage) { doExit = true; } } #elif defined(GAINPUT_PLATFORM_WIN) MSG msg; while (PeekMessage(&msg, SfwGetHWnd(), 0, 0, PM_REMOVE)) { TranslateMessage(&msg); DispatchMessage(&msg); manager.HandleMessage(msg); } #endif SfwUpdate(); if (map.GetBoolWasDown(ButtonConfirm)) { SFW_LOG("Confirmed!\n"); SFW_LOG("Memory: %u allocs, %u deallocs, %u used bytes\n", static_cast<unsigned>(allocator.GetAllocateCount()), static_cast<unsigned>(allocator.GetDeallocateCount()), static_cast<unsigned>(allocator.GetAllocatedMemory())); } if (map.GetBoolWasDown(ButtonConfirmDouble)) { SFW_LOG("Confirmed doubly!\n"); } if (map.GetBoolWasDown(ButtonConfirmExtra)) { SFW_LOG("Confirmed alternatively!\n"); } if (map.GetBool(ButtonHoldGesture)) { SFW_LOG("Hold triggered!\n"); } if (map.GetBoolWasDown(ButtonTapGesture)) { SFW_LOG("Tapped!\n"); } if (map.GetBool(ButtonPinching)) { SFW_LOG("Pinching: %f\n", map.GetFloat(ButtonPinchScale)); } if (map.GetBool(ButtonRotating)) { SFW_LOG("Rotation angle: %f\n", map.GetFloat(ButtonRotateAngle)); } } SfwCloseWindow(); }
int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpCmdLine, int /*nCmdShow*/) { SetDllDirectory(L""); SetTaskIDPerUUID(); CRegStdDWORD loc = CRegStdDWORD(_T("Software\\TortoiseGit\\LanguageID"), 1033); long langId = loc; CoInitializeEx(NULL, COINIT_APARTMENTTHREADED); CLangDll langDLL; hResource = langDLL.Init(_T("TortoiseIDiff"), langId); if (hResource == NULL) hResource = hInstance; CCmdLineParser parser(lpCmdLine); if (parser.HasKey(_T("?")) || parser.HasKey(_T("help"))) { TCHAR buf[1024] = { 0 }; LoadString(hResource, IDS_COMMANDLINEHELP, buf, _countof(buf)); MessageBox(NULL, buf, _T("TortoiseIDiff"), MB_ICONINFORMATION); langDLL.Close(); return 0; } MSG msg; hInst = hInstance; INITCOMMONCONTROLSEX used = { sizeof(INITCOMMONCONTROLSEX), ICC_STANDARD_CLASSES | ICC_BAR_CLASSES | ICC_WIN95_CLASSES }; InitCommonControlsEx(&used); // load the cursors we need curHand = (HCURSOR)LoadImage(hInst, MAKEINTRESOURCE(IDC_PANCUR), IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE); curHandDown = (HCURSOR)LoadImage(hInst, MAKEINTRESOURCE(IDC_PANDOWNCUR), IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE); std::unique_ptr<CMainWindow> mainWindow(new CMainWindow(hResource)); mainWindow->SetRegistryPath(_T("Software\\TortoiseGit\\TortoiseIDiffWindowPos")); std::wstring leftfile = parser.HasVal(_T("left")) ? parser.GetVal(_T("left")) : _T(""); std::wstring rightfile = parser.HasVal(_T("right")) ? parser.GetVal(_T("right")) : _T(""); if ((leftfile.empty()) && (lpCmdLine[0] != 0)) { int nArgs; LPWSTR * szArglist = CommandLineToArgvW(GetCommandLineW(), &nArgs); if (szArglist) { if (nArgs == 3) { // Four parameters: // [0]: Program name // [1]: left file // [2]: right file if (PathFileExists(szArglist[1]) && PathFileExists(szArglist[2])) { leftfile = szArglist[1]; rightfile = szArglist[2]; } } } // Free memory allocated for CommandLineToArgvW arguments. LocalFree(szArglist); } mainWindow->SetLeft(leftfile.c_str(), parser.HasVal(_T("lefttitle")) ? parser.GetVal(_T("lefttitle")) : _T("")); mainWindow->SetRight(rightfile.c_str(), parser.HasVal(_T("righttitle")) ? parser.GetVal(_T("righttitle")) : _T("")); if (parser.HasVal(L"base")) mainWindow->SetSelectionImage(FileTypeBase, parser.GetVal(L"base"), parser.HasVal(L"basetitle") ? parser.GetVal(L"basetitle") : L""); if (parser.HasVal(L"mine")) mainWindow->SetSelectionImage(FileTypeMine, parser.GetVal(L"mine"), parser.HasVal(L"minetitle") ? parser.GetVal(L"minetitle") : L""); if (parser.HasVal(L"theirs")) mainWindow->SetSelectionImage(FileTypeTheirs, parser.GetVal(L"theirs"), parser.HasVal(L"theirstitle") ? parser.GetVal(L"theirstitle") : L""); if (parser.HasVal(L"result")) mainWindow->SetSelectionResult(parser.GetVal(L"result")); if (mainWindow->RegisterAndCreateWindow()) { HACCEL hAccelTable = LoadAccelerators(hResource, MAKEINTRESOURCE(IDR_TORTOISEIDIFF)); if (!parser.HasVal(L"left") && parser.HasVal(L"base") && !parser.HasVal(L"mine") && !parser.HasVal(L"theirs")) { PostMessage(*mainWindow, WM_COMMAND, ID_FILE_OPEN, 0); } if (parser.HasKey(_T("overlay"))) { PostMessage(*mainWindow, WM_COMMAND, ID_VIEW_OVERLAPIMAGES, 0); } if (parser.HasKey(_T("fit"))) { PostMessage(*mainWindow, WM_COMMAND, ID_VIEW_FITIMAGEHEIGHTS, 0); PostMessage(*mainWindow, WM_COMMAND, ID_VIEW_FITIMAGEWIDTHS, 0); } if (parser.HasKey(_T("fitwidth"))) { PostMessage(*mainWindow, WM_COMMAND, ID_VIEW_FITIMAGEWIDTHS, 0); } if (parser.HasKey(_T("fitheight"))) { PostMessage(*mainWindow, WM_COMMAND, ID_VIEW_FITIMAGEHEIGHTS, 0); } if (parser.HasKey(_T("showinfo"))) { PostMessage(*mainWindow, WM_COMMAND, ID_VIEW_IMAGEINFO, 0); } // Main message loop: while (GetMessage(&msg, NULL, 0, 0)) { if (!TranslateAccelerator(*mainWindow, hAccelTable, &msg)) { TranslateMessage(&msg); DispatchMessage(&msg); } } return (int) msg.wParam; } langDLL.Close(); DestroyCursor(curHand); DestroyCursor(curHandDown); CoUninitialize(); return 1; }
int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd) { // define our window class WNDCLASSEX wc = { 0 }; wc.cbSize = sizeof(wc); wc.lpfnWndProc = WindowProc; wc.hInstance = hInstance; wc.lpszClassName = "Module 3"; RegisterClassExA(&wc); DWORD dwExStyle = 0; DWORD dwStyle = WS_OVERLAPPEDWINDOW; //BOOL Fullscreen = FALSE; // //if (Fullscreen) //{ // DEVMODE dmScreenSettings = { 0 }; // dmScreenSettings.dmSize = sizeof(dmScreenSettings); // dmScreenSettings.dmPelsWidth = BufferWidth; // dmScreenSettings.dmPelsHeight = BufferHeight; // dmScreenSettings.dmBitsPerPel = 32; // dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT; // // if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) == //DISP_CHANGE_SUCCESSFUL) // { // dwExStyle = WS_EX_APPWINDOW; // dwStyle = WS_POPUP; // } // else // { // Fullscreen = FALSE; // } //} // create rectangle for window RECT r = { 0 }; r.right = WindowWidth; r.bottom = WindowHeight; AdjustWindowRectEx(&r, dwStyle, 0, dwExStyle); // create our window HWND MainWindow = CreateWindowEx( dwExStyle, "Module 3", "Lesson 3.5", dwStyle, CW_USEDEFAULT, CW_USEDEFAULT, r.right - r.left, r.bottom - r.top, NULL, NULL, hInstance, 0); //if (Fullscreen) // SetWindowLong(MainWindow, GWL_STYLE, 0); ShowWindow(MainWindow, nShowCmd); // define our bitmap info BitMapInfo.bmiHeader.biSize = sizeof(BitMapInfo.bmiHeader); BitMapInfo.bmiHeader.biWidth = BufferWidth; BitMapInfo.bmiHeader.biHeight = -BufferHeight; BitMapInfo.bmiHeader.biPlanes = 1; BitMapInfo.bmiHeader.biBitCount = 8 * BytesPerPixel; BitMapInfo.bmiHeader.biCompression = BI_RGB; BackBuffer = malloc(BufferWidth * BufferHeight * BytesPerPixel); //if (BytesPerPixel == 1) { FILE *Palette = fopen("palette.lmp", "rb"); void *RawData = malloc(256 * 3); unsigned char* PaletteData = RawData; size_t Ret = fread(PaletteData, 1, 768, Palette); for (int i = 0; i < 256; i++) { BitMapInfo.acolors[i].rgbRed = *PaletteData++; BitMapInfo.acolors[i].rgbGreen = *PaletteData++; BitMapInfo.acolors[i].rgbBlue = *PaletteData++; } free(RawData); fclose(Palette); } FILE * Disc = fopen("DISC.lmp", "rb"); int DiscWidth, DiscHeight; size_t RetVal = fread(&DiscWidth, 1, 4, Disc); RetVal = fread(&DiscHeight, 1, 4, Disc); void* DiscData = malloc(DiscWidth * DiscHeight); RetVal = fread(DiscData, 1, DiscWidth * DiscHeight, Disc); fclose(Disc); FILE *Pause = fopen("pause.lmp", "rb"); int PauseWidth, PauseHeight; RetVal = fread(&PauseWidth, 1, 4, Pause); RetVal = fread(&PauseHeight, 1, 4, Pause); void *PauseData = malloc(PauseWidth * PauseHeight); RetVal = fread(PauseData, 1, PauseWidth * PauseHeight, Pause); fclose(Pause); MSG msg; while (Running) { while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) { TranslateMessage(&msg); DispatchMessage(&msg); } if (BytesPerPixel == 4) { int *MemoryWalker = (int*)BackBuffer; for (int Height = 0; Height < BufferHeight; Height++) { for (int Width = 0; Width < BufferWidth; Width++) { unsigned char Red = rand() % 256; unsigned char Green = rand() % 256; unsigned char Blue = rand() % 256; *MemoryWalker++ = ((Red << 16) | (Green << 8) | Blue); } } DrawPic32(10, 10, DiscWidth, DiscHeight, DiscData, BackBuffer); DrawPic32(100, 100, PauseWidth, PauseHeight, PauseData, BackBuffer); //DrawRect(10, 10, 300, 150, 255, 0, 255, BackBuffer); } else if (BytesPerPixel == 1) { unsigned char *MemoryWalker = BackBuffer; for (int Height = 0; Height < BufferHeight; Height++) { for (int Width = 0; Width < BufferWidth; Width++) { *MemoryWalker++ = rand() % 256; } } //DrawPic8(10, 10, DiscWidth, DiscHeight, DiscData, BackBuffer); //DrawPic8(100, 100, PauseWidth, PauseHeight, PauseData, BackBuffer); //DrawRect8(10, 10, 300, 150, 1, BackBuffer); } HDC dc = GetDC(MainWindow); StretchDIBits(dc, 0, 0, WindowWidth, WindowHeight, 0, 0, BufferWidth, BufferHeight, BackBuffer, (BITMAPINFO*)&BitMapInfo, DIB_RGB_COLORS, SRCCOPY); ReleaseDC(MainWindow, dc); } free(BackBuffer); free(DiscData); free(PauseData); return EXIT_SUCCESS; }
int WINAPI wWinMain ( HINSTANCE hInstance , HINSTANCE prevInstance , LPWSTR cmdLine , int cmdShow ) { UNREFERENCED_PARAMETER ( prevInstance ); UNREFERENCED_PARAMETER ( cmdLine ); WNDCLASSEX wndClass = { 0 }; wndClass.cbSize = sizeof ( WNDCLASSEX ); wndClass.style = CS_HREDRAW | CS_VREDRAW; wndClass.lpfnWndProc = WndProc; wndClass.hInstance = hInstance; wndClass.hCursor = LoadCursor ( NULL , IDC_ARROW ); wndClass.hbrBackground = ( HBRUSH ) ( COLOR_WINDOW + 1 ); wndClass.lpszMenuName = NULL; wndClass.lpszClassName = "DX11BookWindowClass"; if( !RegisterClassEx( &wndClass )) { return -1; } RECT rc = { 0 , 0 , 640 , 480 }; AdjustWindowRect( &rc , WS_OVERLAPPEDWINDOW , FALSE ); HWND hwnd = CreateWindowEx ( WS_EX_OVERLAPPEDWINDOW, "DX11BookWindowClass" , "Blank Direct3D 11 Window" , WS_OVERLAPPEDWINDOW , CW_USEDEFAULT , CW_USEDEFAULT , rc.right - rc.left , rc.bottom - rc.top , NULL , NULL , hInstance , NULL ); /* HWND hwnd = CreateWindowA ( "DX11BookWindowClass" , "Blank Direct 3D 11 Window" , WS_OVERLAPPEDWINDOW , CW_USEDEFAULT , CW_USEDEFAULT , rc.right - rc.left , rc.bottom - rc.top , NULL , NULL , hInstance , NULL ); */ if( !hwnd ) return -1; ShowWindow( hwnd , cmdShow ); std :: auto_ptr< Dx11DemoBase >demo ( new ColorInversionDemo()); //Demo Initialize bool result = demo ->Initialize ( hInstance , hwnd ); //Error reporting if there is an issue if( result == false ) return -1; MSG msg = { 0 }; while ( msg.message != WM_QUIT ) { if( PeekMessage ( &msg , 0 , 0 , 0 , PM_REMOVE )) { TranslateMessage( & msg ); DispatchMessage ( & msg ); } else { //Update and draw demo ->Update (0.0f); demo ->Render ( ); } } //demo shutdown demo ->Shutdown( ); return static_cast<int>( msg.wParam ); }
void ShowErrorPane(const char *text) { if (Window == NULL || ConWindow == NULL) { if (text != NULL) { MessageBox (Window, text, GAMESIG " Fatal Error", MB_OK|MB_ICONSTOP|MB_TASKMODAL); } return; } if (StartScreen != NULL) // Ensure that the network pane is hidden. { StartScreen->NetDone(); } if (text != NULL) { char caption[100]; mysnprintf(caption, countof(caption), "Fatal Error - "GAMESIG" %s "X64, GetVersionString()); SetWindowText (Window, caption); ErrorIcon = CreateWindowEx (WS_EX_NOPARENTNOTIFY, "STATIC", NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | SS_OWNERDRAW, 0, 0, 0, 0, Window, NULL, g_hInst, NULL); if (ErrorIcon != NULL) { SetWindowLong (ErrorIcon, GWL_ID, IDC_ICONPIC); } } ErrorPane = CreateDialogParam (g_hInst, MAKEINTRESOURCE(IDD_ERRORPANE), Window, ErrorPaneProc, (LONG_PTR)NULL); if (text != NULL) { CHARRANGE end; CHARFORMAT2 oldformat, newformat; PARAFORMAT2 paraformat; // Append the error message to the log. end.cpMax = end.cpMin = GetWindowTextLength (ConWindow); SendMessage (ConWindow, EM_EXSETSEL, 0, (LPARAM)&end); // Remember current charformat. oldformat.cbSize = sizeof(oldformat); SendMessage (ConWindow, EM_GETCHARFORMAT, SCF_SELECTION, (LPARAM)&oldformat); // Use bigger font and standout colors. newformat.cbSize = sizeof(newformat); newformat.dwMask = CFM_BOLD | CFM_COLOR | CFM_SIZE; newformat.dwEffects = CFE_BOLD; newformat.yHeight = oldformat.yHeight * 5 / 4; newformat.crTextColor = RGB(255,170,170); SendMessage (ConWindow, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&newformat); // Indent the rest of the text to make the error message stand out a little more. paraformat.cbSize = sizeof(paraformat); paraformat.dwMask = PFM_STARTINDENT | PFM_OFFSETINDENT | PFM_RIGHTINDENT; paraformat.dxStartIndent = paraformat.dxOffset = paraformat.dxRightIndent = 120; SendMessage (ConWindow, EM_SETPARAFORMAT, 0, (LPARAM)¶format); SendMessage (ConWindow, EM_REPLACESEL, FALSE, (LPARAM)"\n"); // Find out where the error lines start for the error icon display control. SendMessage (ConWindow, EM_EXGETSEL, 0, (LPARAM)&end); ErrorIconChar = end.cpMax; // Now start adding the actual error message. SendMessage (ConWindow, EM_REPLACESEL, FALSE, (LPARAM)"Execution could not continue.\n\n"); // Restore old charformat but with light yellow text. oldformat.crTextColor = RGB(255,255,170); SendMessage (ConWindow, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&oldformat); // Add the error text. SendMessage (ConWindow, EM_REPLACESEL, FALSE, (LPARAM)text); // Make sure the error text is not scrolled below the window. SendMessage (ConWindow, EM_LINESCROLL, 0, SendMessage (ConWindow, EM_GETLINECOUNT, 0, 0)); // The above line scrolled everything off the screen, so pretend to move the scroll // bar thumb, which clamps to not show any extra lines if it doesn't need to. SendMessage (ConWindow, EM_SCROLL, SB_PAGEDOWN, 0); } BOOL bRet; MSG msg; while ((bRet = GetMessage(&msg, NULL, 0, 0)) != 0) { if (bRet == -1) { MessageBox (Window, text, GAMESIG " Fatal Error", MB_OK|MB_ICONSTOP|MB_TASKMODAL); return; } else if (!IsDialogMessage (ErrorPane, &msg)) { TranslateMessage (&msg); DispatchMessage (&msg); } } }
int WINAPI WinMain( HINSTANCE hInstance, // Instance HINSTANCE hPrevInstance, // Previous Instance LPSTR lpCmdLine, // Command Line Parameters int nCmdShow) // Window Show State { MSG msg; // Windows Message Structure BOOL bDone = FALSE; // Bool Variable To Exit Loop // Ask The User Which Screen Mode They Prefer if (MessageBox(NULL, MSG_RUNINFULLSCREEN, MSG_STARTFULLSCREEN, MB_YESNO | MB_ICONQUESTION) == IDNO) { g_bFullscreen = FALSE; // Windowed Mode } // Create Our OpenGL Window if (!CreateGLWindow(WINDOW_TITLE, WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_BIT, g_bFullscreen)) { return 0; // Quit If Window Was Not Created } while (!bDone) // Loop That Runs While done=FALSE { if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) // Is There A Message Waiting? { if (msg.message == WM_QUIT) // Have We Received A Quit Message? { bDone = TRUE; // If So done=TRUE } else // If Not, Deal With Window Messages { TranslateMessage(&msg); // Translate The Message DispatchMessage(&msg); // Dispatch The Message } } else // If There Are No Messages { // Draw The Scene. Watch For ESC Key And Quit Messages From DrawGLScene() if (g_bActive) // Program Active? { if (g_bKeysArr[VK_ESCAPE]) // Was ESC Pressed? { bDone = TRUE; // ESC Signalled A Quit } else // Not Time To Quit, Update Screen { DrawGLScene(); // Draw The Scene SwapBuffers(hDC); // Swap Buffers (Double Buffering) if (g_bKeysArr['L'] && !g_bLPress) // L key being pressed not held? { g_bLPress = TRUE; // Become TRUE g_bLight = !g_bLight; // Toggle light TRUE/FALSE if (!g_bLight) { glDisable(GL_LIGHTING); // Disable lighting } else { glEnable(GL_LIGHTING); // Enable lighting } } if (!g_bKeysArr['L']) // Has L key been released? { g_bLPress = FALSE; // If so, become FALSE } if (g_bKeysArr['F'] && !g_bFPress) // Is F key being pressed not held? { g_bFPress = TRUE; g_uFilter += 1; if (g_uFilter > 2) { g_uFilter = 0; } } if (!g_bKeysArr['F']) { g_bFPress = FALSE; } } } if (g_bKeysArr[VK_F1]) // Is F1 Being Pressed? { g_bKeysArr[VK_F1] = FALSE; // If So Make Key FALSE KillGLWindow(); // Kill Our Current Window g_bFullscreen = !g_bFullscreen; // Toggle Full screen / Windowed Mode // Recreate Our OpenGL Window if (!CreateGLWindow(WINDOW_TITLE, WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_BIT, g_bFullscreen)) { return 0; // Quit If Window Was Not Created } } // Handle move left-right if (g_bKeysArr[VK_LEFT]) { g_bKeysArr[VK_LEFT] = FALSE; g_MoveX -= g_MDeltaX; } if (g_bKeysArr[VK_RIGHT]) { g_bKeysArr[VK_RIGHT] = FALSE; g_MoveX += g_MDeltaX; } // Handle move up-down if (g_bKeysArr[VK_UP]) { g_bKeysArr[VK_UP] = FALSE; g_MoveY += g_MDeltaY; } if (g_bKeysArr[VK_DOWN]) { g_bKeysArr[VK_DOWN] = FALSE; g_MoveY -= g_MDeltaY; } // Handle move forward-backward if (g_bKeysArr[VK_ADD]) { g_bKeysArr[VK_ADD] = FALSE; g_MoveZ -= g_MDeltaZ; } // Handle rotate follow X asix if (g_bKeysArr[VK_INSERT]) { g_bKeysArr[VK_INSERT] = FALSE; g_RotateX += g_RDeltaX; } if (g_bKeysArr[VK_DELETE]) { g_bKeysArr[VK_DELETE] = FALSE; g_RotateX -= g_RDeltaX; } // Handle rotate follow Y asix if (g_bKeysArr[VK_HOME]) { g_bKeysArr[VK_HOME] = FALSE; g_RotateY += g_RDeltaY; } if (g_bKeysArr[VK_END]) { g_bKeysArr[VK_END] = FALSE; g_RotateY -= g_RDeltaY; } // Handle rotate follow Z axis if (g_bKeysArr[VK_PRIOR]) { g_bKeysArr[VK_PRIOR] = FALSE; //g_RotateZ += g_RDeltaZ; g_MoveZ -= 0.02f; } if (g_bKeysArr[VK_NEXT]) { g_bKeysArr[VK_NEXT] = FALSE; //g_RotateZ -= g_RDeltaZ; g_MoveZ += 0.02f; } if (g_bKeysArr[VK_SUBTRACT]) { g_bKeysArr[VK_SUBTRACT] = FALSE; g_MoveZ += g_MDeltaZ; } if (g_bKeysArr[VK_TAB]) { g_bKeysArr[VK_TAB] = FALSE; } } } // Shutdown KillGLWindow(); // Kill The Window return (msg.wParam); // Exit The Program }
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { WNDCLASSEX wcex; HMENU menu, popupMenu; wcex.cbSize = sizeof(WNDCLASSEX); wcex.style = CS_HREDRAW | CS_VREDRAW; wcex.lpfnWndProc = WndProc; wcex.cbClsExtra = 0; wcex.cbWndExtra = 0; wcex.hInstance = hInstance; wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_APPLICATION)); wcex.hCursor = LoadCursor(hInstance, IDC_ARROW); wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); wcex.lpszMenuName = NULL; wcex.lpszClassName = szWindowClass; wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_APPLICATION)); if (!RegisterClassEx(&wcex)) { MessageBox(NULL, _T("Call to RegisterClassEx failed!"), _T("Win32 Guided Tour"), NULL); return 1; } hInst = hInstance; // Store instance handle in our global variable // The parameters to CreateWindow explained: // szWindowClass: the name of the application // szTitle: the text that appears in the title bar // WS_SYSMENU: the type of window to create // CW_USEDEFAULT, CW_USEDEFAULT: initial position (x, y) // 500, 100: initial size (width, length) // NULL: the parent of this window // TODO: // NULL: this application does not have a menu bar // hInstance: the first parameter from WinMain // NULL: not used in this application hWnd = CreateWindow( szWindowClass, szTitle, WS_SYSMENU, CW_USEDEFAULT, CW_USEDEFAULT, WindowWidth, WindowHeight, NULL, NULL, hInstance, NULL ); if (!hWnd) { MessageBox(NULL, _T("Call to CreateWindow failed!"), _T("Win32 Guided Tour"), NULL); return 1; } hButtonRefresh = CreateWindow(L"button", NULL, WS_CHILD | WS_VISIBLE | BS_OWNERDRAW, 0, 0, 32, 32, hWnd, (HMENU)IDC_BUTTON_REFRESH, hInst, NULL); hButtonClear = CreateWindow(L"button", NULL, WS_CHILD | WS_VISIBLE | BS_OWNERDRAW, 0, 32, 32, 32, hWnd, (HMENU)IDC_BUTTON_CLEAR, hInst, NULL); // The parameters to ShowWindow explained: // hWnd: the value returned from CreateWindow // nCmdShow: the fourth parameter from WinMain ShowWindow(hWnd, nCmdShow); UpdateWindow(hWnd); // Main message loop: MSG msg; while (GetMessage(&msg, NULL, 0, 0)) { TranslateMessage(&msg); DispatchMessage(&msg); } return (int)msg.wParam; }
/*********************************************************************************** WinMain - Entry point for program. ***********************************************************************************/ int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { CLog *pLog = CLog::Instance(); pLog->Log(" "); pLog->Log("***************************************"); pLog->Log("Program Start"); pLog->LogDate(); pLog->Log("***************************************"); //request player choose fullscreen or windowed mode CConfigData cfg; cfg.LoadConfigFile("assets//data//config.cfg"); bool bFullscreen = false; bFullscreen = cfg.FullScreen; //int msgReturn = ::MessageBox(NULL, "Fullscreen? (Y/N)", "Select Display Option", MB_YESNO); //if(msgReturn == IDYES) // bFullscreen = true; //variable declarations CGameData gameData; CTimer gTimerFPS; int gLoopCount = 0; int gSecondCount = 0; bool g_bRunning = true; bool gExitProgram = false; //this is set true with ESC, for rendering to stop properly //determine if we play new or saved game /* gameData.m_playNewGame = true; HRESULT hr = ::MessageBox(0, "Play new game?", "New or saved game!", MB_YESNO); if(hr == IDYES) gameData.m_playNewGame = true; else gameData.m_playNewGame = false; */ gameData.m_playNewGame = true; //setup game data pLog->Log("Program Name", cfg.ProgramName); pLog->Log("Version", cfg.ProgramVersion); //create window HWND hWnd; WNDCLASSEX wc; ZeroMemory(&wc, sizeof(WNDCLASSEX)); wc.cbSize = sizeof(WNDCLASSEX); wc.style = CS_HREDRAW | CS_VREDRAW; wc.lpfnWndProc = (WNDPROC)WindowProc; wc.hInstance = hInstance; wc.hCursor = LoadCursor(NULL, IDC_ARROW); wc.lpszClassName = "WindowClass"; wc.hIconSm = LoadIcon (hInstance, MAKEINTRESOURCE(IDI_ICON1)); RegisterClassEx(&wc); //screen data - need at least 800x600 int cxScreen = ::GetSystemMetrics(SM_CXFULLSCREEN); int cyScreen = ::GetSystemMetrics(SM_CYFULLSCREEN); if(cfg.ScreenWidth < 800 || cfg.ScreenWidth > cxScreen) cfg.ScreenWidth = cxScreen; if(cfg.ScreenHeight < 600 || cfg.ScreenHeight > cyScreen) cfg.ScreenHeight = cyScreen; cfg.ScreenLeft = cxScreen/2 - cfg.ScreenWidth/2; cfg.ScreenTop = cyScreen/2 - cfg.ScreenHeight/2; //create window std::string sCaption = cfg.ProgramName + " - " + cfg.ProgramVersion; hWnd = CreateWindowEx(NULL, "WindowClass", sCaption.c_str(), //cfg.ProgramVersion.c_str(), bFullscreen == true ? WS_EX_TOPMOST | WS_POPUP : WS_BORDER | WS_CAPTION | WS_SYSMENU, cfg.ScreenLeft, cfg.ScreenTop, bFullscreen == true ? CW_USEDEFAULT : cfg.ScreenWidth, bFullscreen == true ? CW_USEDEFAULT : cfg.ScreenHeight, NULL,NULL,hInstance,NULL); ShowWindow(hWnd, nCmdShow); pLog->Log("Window Loaded and Displayed!"); gameData.m_hWnd = hWnd; // set up and initialize Direct3D CGraphics con(hWnd, cfg.ScreenWidth, cfg.ScreenHeight,bFullscreen);// cfg.FullScreen); if(con.InitializeDirectX() == false){ pLog->Log("Failure initializing DirectX!"); ::MessageBox(hWnd,"Failed to initialize DirectX", "Error", 0); return 0; } pLog->Log("DirectX Initialized"); //load framework assets if(con.LoadAssetFile(cfg.FrameworkAssetFile) == false){ pLog->Log("Failure loading " + cfg.FrameworkAssetFile); ::MessageBox(hWnd,"Failed to load editor.dat file", "Error", 0); return 0; } else pLog->Log(cfg.FrameworkAssetFile + " (frame graphics) was loaded successfully!"); //load game play assets if(con.LoadAssetFile(cfg.GamePlayAssetFile) == false){ pLog->Log("Failure loading " + cfg.GamePlayAssetFile); ::MessageBox(hWnd,"Failed to load assets.dat file", "Error", 0); return 0; } else pLog->Log(cfg.GamePlayAssetFile + " (game play graphics) was loaded successfully!"); //load objects //*************************************************************************** if(gameData.LoadObjectFile(cfg.GameObjectFile) == false){ pLog->Log("Failure loading " + cfg.GameObjectFile); ::MessageBox(hWnd,"Failed to load objects.dat file", "Error", 0); return 0; } else{ pLog->Log(cfg.GameObjectFile + " (objects file) was loaded successfully!"); for(int i = 0; i < gameData.m_catalog.GetTableSize();++i){ pLog->Log("object", gameData.m_catalog.GetTerm(i, 0), gameData.m_catalog.GetTerm(i, 2)); } } gTimerKey.Initialize(); gTimerKey.ResetTimer(); mouse.SetHandle(hWnd); gTimerFPS.Initialize(); //game timer for update CTimer timerGame; timerGame.Initialize(); //define events for changing game states //************************************************************************* //g_pStateIntro->AddTransitionEvent(EVENT_GO_PLAY1, g_pStatePlay1); //g_pStatePlay1->AddTransitionEvent(EVENT_GO_CREDITS, g_pStateCredits); g_pStateIntro->AddTransitionEvent(EVENT_GO_MAIN, g_pStateMain); g_pStateMain->AddTransitionEvent(EVENT_GO_PLAY1, g_pStatePlay1); g_pStateMain->AddTransitionEvent(EVENT_GO_HELP, g_pStateHelp); g_pStateMain->AddTransitionEvent(EVENT_GO_CREDITS, g_pStateCredits); g_pStatePlay1->AddTransitionEvent(EVENT_GO_MAIN, g_pStateMain); g_pStateHelp->AddTransitionEvent(EVENT_GO_MAIN, g_pStateMain); g_pStateCredits->AddTransitionEvent(EVENT_GO_QUIT, g_pStateQuit); g_pCurrent = g_pStateIntro; //************************************** S O U N D ************************ //initialize sound manager //audio setup CAudioManager *pAudio = CAudioManager::Instance(); pAudio->LoadFile("assets\\data\\sounds.dat"); //load sound asset file pAudio->LoadFile(cfg.SoundAssetFile); /* if(pAudio->LoadFile(cfg.SoundAssetFile) == false){ pLog->Log("Failure loading " + cfg.GamePlayAssetFile);//assets.dat audio files!"); ::MessageBox(hWnd,"Failed to load assets.dat audio files!", "Error", 0); } else pLog->Log(cfg.GamePlayAssetFile + " (audio) was loaded successfully!"); */ /* if(pAudio->IsValidSound() == true) pLog->Log("Audio system initialized (size)", pAudio->Size()); else pLog->Log("Audio failure!"); */ //log all audio files if(cfg.LogDebugInfo == true){ pLog->Log("************************** Audio Files Loaded **************"); // for(int i = 0; i < pAudio->Size(); i++){ // pLog->Log(pAudio->GetFilename(i)); // } pLog->Log(""); } // enter the main loop //************************************** M A I N L O O P ***************** MSG msg; pLog->Log("Entering Main Control Loop"); float timeDiff = 0.0f; g_pCurrent->Activate(gameData, cfg, con); //********************* // PYRO //con.InitializePyro(); while(g_bRunning) { DWORD starting_point = GetTickCount(); if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { if (msg.message == WM_QUIT) break; TranslateMessage(&msg); DispatchMessage(&msg); } //manage frame count determination gLoopCount++; if(gTimerFPS.getTimer(1.0) == true){ gameData.m_FPS = static_cast<float>(gLoopCount); gLoopCount = 0; gSecondCount++; if(gSecondCount > 30){ //log every 30 seconds gSecondCount = 0; if(cfg.LogDebugInfo == true) pLog->Log("FPS",gameData.m_FPS); } } //stores mouse button status for use in other classes gameData.m_bLeftMouseDown = mouse.LeftButtonDown(); gameData.m_bRightMouseDown = mouse.RightButtonDown(); //update g_pLast = g_pCurrent; g_pNext = g_pCurrent->Update(timerGame.getTimeDifference(), gameData, cfg, con); if(g_pNext == g_pStateQuit) g_bRunning = false; else if(NULL != g_pNext) { if(g_pNext != g_pLast){ g_pLast->Deactivate(gameData, cfg, con); g_pCurrent = g_pNext; g_pCurrent->Activate(gameData, cfg, con); } } //render g_pCurrent->Render(con, gameData, cfg); // check the 'escape' key if(g_bRunning == false){ gExitProgram = true; PostMessage(hWnd, WM_DESTROY, 0, 0); } } pLog->Log("Exited main loop"); //************************** // PYRO //con.ClosePyro(); // clean up DirectX and COM con.CleanupDirectX(); Shutdown(); pLog->Log("DirectX Cleaned Up"); pLog->Log("Shutdown complete!"); pLog->Log("***************************************"); pLog->Log(" Program Terminated Normally"); pLog->Log("***************************************"); return static_cast<int>(msg.wParam); }
void mswin_display_RIP_window (HWND hWnd) { MSG msg; RECT rt; PNHRIPWindow data; HWND mapWnd; RECT riprt; RECT clientrect; RECT textrect; HDC hdc; HFONT OldFont; data = (PNHRIPWindow)GetWindowLong(hWnd, GWL_USERDATA); GetNHApp()->hPopupWnd = hWnd; mapWnd = mswin_hwnd_from_winid(WIN_MAP); if( !IsWindow(mapWnd) ) mapWnd = GetNHApp()->hMainWnd; GetWindowRect(mapWnd, &rt); GetWindowRect(hWnd, &riprt); GetClientRect (hWnd, &clientrect); textrect = clientrect; textrect.top += RIP_OFFSET_Y; textrect.left += RIP_OFFSET_X; textrect.right -= RIP_OFFSET_X; if (data->window_text) { hdc = GetDC (hWnd); OldFont = SelectObject (hdc, mswin_get_font(NHW_TEXT, 0, hdc, FALSE)); DrawText (hdc, data->window_text, strlen(data->window_text), &textrect, DT_LEFT | DT_NOPREFIX | DT_CALCRECT); SelectObject (hdc, OldFont); ReleaseDC(hWnd, hdc); } if (textrect.right - textrect.left > RIP_WIDTH) clientrect.right = textrect.right + RIP_OFFSET_X - clientrect.right; else clientrect.right = textrect.left + 2 * RIP_OFFSET_X + RIP_WIDTH - clientrect.right; clientrect.bottom = textrect.bottom + RIP_HEIGHT + RIP_OFFSET_Y - clientrect.bottom; GetWindowRect (GetDlgItem(hWnd, IDOK), &textrect); textrect.right -= textrect.left; textrect.bottom -= textrect.top; clientrect.bottom += textrect.bottom + RIP_OFFSET_Y; riprt.right -= riprt.left; riprt.bottom -= riprt.top; riprt.right += clientrect.right; riprt.bottom += clientrect.bottom; rt.left += (rt.right - rt.left - riprt.right) / 2; rt.top += (rt.bottom - rt.top - riprt.bottom) / 2; MoveWindow(hWnd, rt.left, rt.top, riprt.right, riprt.bottom, TRUE); GetClientRect (hWnd, &clientrect); MoveWindow (GetDlgItem(hWnd, IDOK), (clientrect.right - clientrect.left - textrect.right) / 2, clientrect.bottom - textrect.bottom - RIP_OFFSET_Y, textrect.right, textrect.bottom, TRUE); ShowWindow(hWnd, SW_SHOW); while( IsWindow(hWnd) && GetMessage(&msg, NULL, 0, 0)!=0 ) { if( !IsDialogMessage(hWnd, &msg) ) { TranslateMessage(&msg); DispatchMessage(&msg); } } GetNHApp()->hPopupWnd = NULL; }
int PASCAL WinMain(HANDLE hInstance, HANDLE hPrevInstance, LPSTR lpszCmdLine, int iCmd) { int i; MSG msg; LPSTR pch,pch1; WORD ret; WOWINFO wowinfo; char aszWOWDEB[CCHMAX]; LPSTR pchWOWDEB; HANDLE hMMDriver; char szBuffer[150]; BOOL bFinished; int iStart; int iEnd; hAppInstance = hInstance ; // Only Want One WOWExec if (hPrevInstance != NULL) { return(FALSE); } if (!InitializeApp(lpszCmdLine)) { OutputDebugString("WOWEXEC: InitializeApp failure!\n"); return 0; } /* * Look for a drivers= line in the [boot] section of SYSTEM.INI * If present it is the 16 bit MultiMedia interface, so load it */ #ifdef OLD_MMSYSTEM_LOAD if (GetPrivateProfileString((LPSTR)"boot", (LPSTR)"drivers",(LPSTR)"", aszMMDriver, sizeof(aszMMDriver), (LPSTR)"SYSTEM.INI")) { /* * We have now discovered an app that rewrites the "drivers" entry with * multiple drivers - so the existing load method fails. As a temporary fix * while we decide what the "proper" fix is I will always load MMSYSTEM and * ONLY MMSYSTEM. * * aszMMDriver[sizeof(aszMMDriver)-1] = '\0'; * hMMDriver = LoadLibrary((LPSTR)aszMMDriver); * #ifdef DEBUG * if (hMMDriver < 32) { * OutputDebugString("WOWEXEC: Load of MultiMedia driver failed\n"); * } * #endif */ LoadLibrary("MMSYSTEM.DLL"); } #else /* Load DDL's from DRIVERS section in system.ini */ GetPrivateProfileString( (LPSTR)"boot", /* [Boot] section */ (LPSTR)"drivers", /* Drivers= */ (LPSTR)"", /* Default if no match */ szBuffer, /* Return buffer */ sizeof(szBuffer), (LPSTR)"system.ini" ); if (!*szBuffer) { goto Done; } bFinished = FALSE; iStart = 0; while (!bFinished) { iEnd = iStart; while (szBuffer[iEnd] && (szBuffer[iEnd] != ' ') && (szBuffer[iEnd] != ',')) { iEnd++; } if (szBuffer[iEnd] == NULL) { bFinished = TRUE; } else { szBuffer[iEnd] = NULL; } /* Load and enable the driver. */ OpenDriver( &(szBuffer[iStart]), NULL, NULL ); iStart = iEnd + 1; } Done: #endif /* * Look for a debug= line in the [boot] section of SYSTEM.INI * If present it is the 16 bit MultiMedia interface, so load it */ if ( WOWQueryDebug() & 0x0001 ) { pchWOWDEB = "WOWDEB.EXE"; } else { pchWOWDEB = ""; } GetPrivateProfileString((LPSTR)"boot", (LPSTR)"debug",pchWOWDEB, aszWOWDEB, sizeof(aszWOWDEB), (LPSTR)"SYSTEM.INI"); aszWOWDEB[sizeof(aszWOWDEB)-1] = '\0'; if ( lstrlen(pchWOWDEB) != 0 ) { WinExec((LPSTR)aszWOWDEB,SW_SHOW); } #if 0 /* Preload winspool.exe. Apps will keep loading and freeing it * which is slow. We might as well load it now so the reference * count is 1 so it will never be loaded or freed */ // // Disabled load of winspool.exe to save 8k. Size vs. speed, // which one do we care about? Right now, size! // LoadLibrary("WINSPOOL.EXE"); #endif // Always load SHELL.DLL, FileMaker Pro and Lotus Install require it. LoadLibrary("SHELL.DLL"); // // Start any apps pending in basesrv queue // while (StartRequestedApp() && gfSharedWOW) { /* null stmt */ ; } while (1) { if (!WowWaitForMsgAndEvent(ghwndMain) && PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) && msg.message != WM_WOWEXECHEARTBEAT ) { if (msg.message != WM_QUIT) { TranslateMessage(&msg); DispatchMessage(&msg); } } } return 1; }
int main(int argc, char *argv[]) { CommandLineArgs args(argc, argv); if (!args.ok) { PrintUsage(); return 1; } // Print init info std::cout << "AbsoluteTouch v" << VERSION_NAME << std::endl; std::cout << "Author: " << AUTHOR << std::endl; std::cout << "Project page: " << PROJECT_URL << std::endl; std::cout << "--------------------------------------------------" << std::endl; std::cout << "Starting..." << std::endl; // Initialize COM CCoInitialize init; // Set cleanup handler g_mainThreadId = GetCurrentThreadId(); if (!SetConsoleCtrlHandler(OnConsoleSignal, TRUE)) { std::cerr << "Error: failed to register console control handler" << std::endl; CleanUp(); return 1; } std::cout << "Registered console control handler" << std::endl; // Initialize touchpad manager try { g_touchpadManager = new TouchpadManager(); } catch (const TouchpadInitException &e) { std::cerr << "Error: could not initialize touchpad manager" << std::endl; std::cerr << e.what() << std::endl; CleanUp(); return 1; } std::cout << "Initialized touchpad manager" << std::endl; // Acquire exclusive touchpad access if (!g_touchpadManager->Acquire()) { std::cerr << "Error: could not acquire exclusive touchpad access" << std::endl; CleanUp(); return 1; } std::cout << "Acquired exclusive touchpad access" << std::endl; // Register touchpad touch callback g_touchCallback = new AbsoluteTouchCallback(); g_touchCallback->SetScreenRect(Rect<long>(0, 0, 65535, 65535).scale(args.screenRect)); g_touchCallback->SetTouchpadRect(g_touchpadManager->GetTouchpadRect().scale(args.touchpadRect)); g_touchCallback->SetSmoothingWeight(args.smoothingWeight); g_touchCallback->SetSendClick(args.sendClick); g_touchpadManager->SetTouchCallback(g_touchCallback); std::cout << "Registered touch listener" << std::endl; // Enable touchpad if option was specified if (args.manageTouchpad && !g_touchpadManager->IsTouchpadEnabled()) { g_touchpadManager->SetTouchpadEnabled(true); g_touchpadEnabledModified = true; std::cout << "Enabled touchpad" << std::endl; } // Print usage instructions std::cout << "--------------------------------------------------" << std::endl; std::cout << "Initialization complete, absolute touch mode enabled!" << std::endl; std::cout << "Keep this window open until you wish to exit absolute touch mode." << std::endl; std::cout << "To exit the program, you can use CTRL-C." << std::endl; // Main message loop MSG msg; BOOL ret; while ((ret = GetMessage(&msg, nullptr, 0, 0)) > 0) { TranslateMessage(&msg); DispatchMessage(&msg); } CleanUp(); g_cleanupFinished = true; return 0; }
int WINAPI WinMain( HINSTANCE hinstance, HINSTANCE hprevinstance, LPSTR lpcmdline, int ncmdshow) { WNDCLASSEX winclass; // this will hold the class we create HWND hwnd; // generic window handle MSG msg; // generic message HDC hdc; // graphics device context // first fill in the window class stucture winclass.cbSize = sizeof(WNDCLASSEX); winclass.style = CS_DBLCLKS | CS_OWNDC | CS_HREDRAW | CS_VREDRAW; winclass.lpfnWndProc = WindowProc; winclass.cbClsExtra = 0; winclass.cbWndExtra = 0; winclass.hInstance = hinstance; winclass.hIcon = LoadIcon(NULL, IDI_APPLICATION); winclass.hCursor = LoadCursor(NULL, IDC_ARROW); winclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH); winclass.lpszMenuName = NULL; winclass.lpszClassName = WINDOW_CLASS_NAME; winclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION); // save hinstance in global hinstance_app = hinstance; // register the window class if (!RegisterClassEx(&winclass)) return(0); // create the window if (!(hwnd = CreateWindowEx(NULL, // extended style WINDOW_CLASS_NAME, // class "DirectDraw 24-Bit Bitmap Loading", // title WS_POPUP | WS_VISIBLE, 0,0, // initial x,y SCREEN_WIDTH,SCREEN_HEIGHT, // initial width, height NULL, // handle to parent NULL, // handle to menu hinstance,// instance of this application NULL))) // extra creation parms return(0); // save main window handle main_window_handle = hwnd; // initialize game here Game_Init(); // enter main event loop while(TRUE) { // test if there is a message in queue, if so get it if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) { // test if this is a quit if (msg.message == WM_QUIT) break; // translate any accelerator keys TranslateMessage(&msg); // send the message to the window proc DispatchMessage(&msg); } // end if // main game processing goes here Game_Main(); } // end while // closedown game here Game_Shutdown(); // return to Windows like this return(msg.wParam); } // end WinMain
int PASCAL WinMain( HINSTANCE instance, HINSTANCE previous_instance, LPSTR cmd_line, int cmd_show ) { // // Win32 locals. // HWND window = 0; MSG msg; // // Try to create our window. // window = Build_window_handle( instance, previous_instance ); if ( !window ) { MessageBox( 0, "Error creating window.", "Windows", MB_OK | MB_ICONSTOP ); return( 1 ); } // // Tell Bink to use DirectSound (must be before BinkOpen)! // BinkSoundUseDirectSound( 0 ); // // Try to open the Bink file. // Bink = BinkOpen( cmd_line, 0 ); if ( !Bink ) { MessageBox( window, BinkGetError( ), "Bink Error", MB_OK | MB_ICONSTOP ); DestroyWindow( window ); return( 3 ); } // // Try to open the Bink buffer. // Bink_buffer = BinkBufferOpen( window, Bink->Width, Bink->Height, 0 ); if ( !Bink_buffer ) { MessageBox( window, BinkBufferGetError( ), "Bink Error", MB_OK | MB_ICONSTOP ); DestroyWindow( window ); BinkClose( Bink ); return( 4 ); } // // Size the window such that its client area exactly fits our Bink movie. // SetWindowPos( window, 0, 0, 0, Bink_buffer->WindowWidth, Bink_buffer->WindowHeight, SWP_NOMOVE ); // // Now display the window and start the message loop. // ShowWindow( window, cmd_show ); for ( ; ; ) { // // Are there any messages to handle? // if ( PeekMessage( &msg, 0, 0, 0, PM_REMOVE ) ) { // // Yup, handle them. // if ( msg.message == WM_QUIT ) break; TranslateMessage( &msg ); DispatchMessage( &msg ); } else { // // Is it time for a new Bink frame? // if ( !BinkWait( Bink ) ) { // // Yup, draw the next frame. // Show_next_frame( Bink, Bink_buffer, window ); } else { // // Nope, give the rest of the system a chance to run (500 MICROseconds). // Good_sleep_us( 500 ); } } } // // Close the Bink file. // if ( Bink ) { BinkClose( Bink ); Bink = 0; } // // Close the Bink buffer. // if ( Bink_buffer ) { BinkBufferClose( Bink_buffer ); Bink_buffer = 0; } // // And exit. // return( 0 ); }
int APIENTRY _tWinMain(HINSTANCE hinst, HINSTANCE foo1, LPTSTR foo2, int foo3) { MSG msg; WNDCLASSEX wcex = {sizeof(wcex)}; HANDLE htray; HMENU hmenu; MENUITEMINFO mi = {sizeof(mi)}; INITCOMMONCONTROLSEX icex; RECT rect; int style; HWND hwnd; wcex.lpfnWndProc = WndProc; wcex.lpszClassName = WINDOW_CLASS; wcex.hCursor = LoadCursor(NULL, IDC_ARROW); RegisterClassEx(&wcex); icex.dwSize = sizeof(icex); icex.dwICC = ICC_DATE_CLASSES; InitCommonControlsEx(&icex); hwnd = CreateWindowEx(WS_EX_NOACTIVATE | WS_EX_TOPMOST, WINDOW_CLASS, WINDOW_TITLE, 0, 0, 0, 0, 0, NULL, NULL, hinst, NULL); if (!hwnd) return 1; style = GetWindowLong(hwnd, GWL_STYLE); if (style & WS_CAPTION) { style ^= WS_CAPTION; SetWindowLong(hwnd, GWL_STYLE, style); SetWindowPos(hwnd, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED); } hcal = CreateWindowEx(0, MONTHCAL_CLASS, _T(""), WS_CHILD | WS_VISIBLE | MCS_NOTODAY | MCS_NOTRAILINGDATES | MCS_SHORTDAYSOFWEEK | MCS_NOSELCHANGEONNAV, 0, 0, 0, 0, hwnd, NULL, hinst, NULL); MonthCal_GetMinReqRect(hcal, &rect); SetWindowPos(hcal, NULL, 0, 0, rect.right, rect.bottom, SWP_NOZORDER | SWP_NOMOVE); SetWindowPos(hwnd, NULL, 0, 0, rect.right, rect.bottom, SWP_NOZORDER | SWP_NOMOVE); tti.hwnd = hwnd; tti.hcal = hcal; tti.hnotify = CreateEvent(NULL, TRUE, FALSE, NULL); tti.exit = FALSE; htray = CreateThread(NULL, 0, &TrayThreadProc, &tti, 0, NULL); if (!htray) return 1; hsubmenu = CreateMenu(); mi.fMask = MIIM_STRING | MIIM_ID; mi.wID = 1; mi.dwTypeData = EXIT_STRING; InsertMenuItem(hsubmenu, 0, TRUE, &mi); hmenu = CreateMenu(); mi.fMask = MIIM_SUBMENU; mi.hSubMenu = hsubmenu; InsertMenuItem(hmenu, 0, TRUE, &mi); WM_TASKBARCREATED = RegisterWindowMessageA(_T("TaskbarCreated")); while (GetMessage(&msg, NULL, 0, 0)) { TranslateMessage(&msg); DispatchMessage(&msg); } DestroyMenu(hmenu); DestroyMenu(hsubmenu); WaitForSingleObject(htray, 1000); CloseHandle(htray); return (int)msg.wParam; }
/******************************************************************** * Function : WinMain() * Purpose : Mandatory Windows Init function. ********************************************************************/ int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { MSG msg; HWND hwnd; WNDCLASS wc; static char ClassName[] = "ChromeTestingFacility"; DDSURFACEDESC ddsd; DDSCAPS ddscaps; HRESULT ddreturn; int n; // Set all key booleans to FALSE, assume no key is pressed. bForwardKey = FALSE; bBackKey = FALSE; bLeftKey = FALSE; bRightKey = FALSE; nState = 0; nGauge = 0; lpCmdLine = lpCmdLine; hPrevInstance = hPrevInstance; RealTime = 0; /* Start of using spacebar for frameflipping. */ /* Register and realize our display window */ wc.style = CS_HREDRAW | CS_VREDRAW; wc.lpfnWndProc = WindowProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = hInstance; wc.hIcon = LoadIcon(hInstance, IDI_APPLICATION); wc.hCursor = LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = NULL; wc.lpszMenuName = ClassName; wc.lpszClassName = ClassName; RegisterClass(&wc); /* Initialize our test world. */ if (!InitWorld(XRES, YRES, Colormap)) { return FALSE; } /* Convert the Chrome colormap to a windows colormap. */ for (n = 0; n < 256; n++) { WinColormap[n].peRed = (unsigned char)((Colormap[n] & 0xFF0000) >> 16); WinColormap[n].peGreen = (unsigned char)((Colormap[n] & 0xFF00) >> 8); WinColormap[n].peBlue = (unsigned char)((Colormap[n] & 0xFF)); WinColormap[n].peFlags = 0; } /* Create a full screen window so that GDI won't ever be * called. */ hwnd = CreateWindowEx(WS_EX_TOPMOST, ClassName, ClassName, WS_POPUP, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), NULL, NULL, hInstance, NULL); if (hwnd == NULL) return FALSE; ShowWindow(hwnd, nCmdShow); UpdateWindow(hwnd); SetFocus(hwnd); ShowCursor(FALSE); /* Remove cursor to prevent GDI from writing. */ /* Instanciate our DirectDraw object */ ddreturn = DirectDrawCreate(NULL, &lpDirectDrawObject, NULL); if (ddreturn != DD_OK) { DestroyWindow(hwnd); return FALSE; } ddreturn = lpDirectDrawObject->SetCooperativeLevel(hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN| DDSCL_ALLOWMODEX); if (ddreturn != DD_OK) { DestroyWindow(hwnd); return FALSE; } /* Create a palette for the surfaces. */ ddreturn = lpDirectDrawObject->CreatePalette(DDPCAPS_8BIT | DDPCAPS_ALLOW256 | DDPCAPS_INITIALIZE, (LPPALETTEENTRY)WinColormap, &lpPalette, NULL); if (ddreturn != DD_OK) { DestroyWindow(hwnd); return FALSE; } /* Set the video mode to XRESxYRESx8. */ ddreturn = lpDirectDrawObject->SetDisplayMode(XRES, YRES, 8); if (ddreturn != DD_OK) { DestroyWindow(hwnd); return FALSE; } /* Create a default font for the application. */ AppFont = CreateFont(11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, NONANTIALIASED_QUALITY, VARIABLE_PITCH, "Comic Sans MS"); /* Create the primary surface and one back buffer surface */ ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX; ddsd.dwBackBufferCount = 1; ddreturn = lpDirectDrawObject->CreateSurface(&ddsd, &lpPrimary, NULL); if (ddreturn != DD_OK) { DestroyWindow(hwnd); return FALSE; } ddreturn = lpPrimary->SetPalette(lpPalette); if (ddreturn != DD_OK) { DestroyWindow(hwnd); return FALSE; } /* Get a surface pointer to our back buffer. */ ddscaps.dwCaps = DDSCAPS_BACKBUFFER; ddreturn = lpPrimary->GetAttachedSurface(&ddscaps, &lpBackbuffer); if (ddreturn != DD_OK) { DestroyWindow(hwnd); return FALSE; } /* ddreturn = lpBackbuffer->SetPalette(lpPalette); if (ddreturn != DD_OK) { DestroyWindow(hwnd); return FALSE; } */ { /* Clear the background once for both buffers so we don't get anoying flicker effect. */ DDBLTFX BltFx; BltFx.dwSize = sizeof(BltFx); BltFx.dwFillColor = 255; ddreturn = lpBackbuffer->Blt(NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &BltFx); BltFx.dwSize = sizeof(BltFx); BltFx.dwFillColor = 255; ddreturn = lpPrimary->Blt(NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &BltFx); } while (1) { if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) { if (!GetMessage(&msg, NULL, 0, 0)) return msg.wParam; TranslateMessage(&msg); DispatchMessage(&msg); } else { if (ActiveApp && RealTime) { // Simulation Iteration should go here. // Only do this when running Realtime. SimLoop(); } else { WaitMessage(); } } } }
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow ) { MyDirectX = new DirectX(); WNDCLASSEX wndClass; wndClass.cbSize = sizeof( WNDCLASSEX ); wndClass.style = CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS; wndClass.cbClsExtra = 0; wndClass.cbWndExtra = 0; wndClass.hbrBackground = ( HBRUSH )GetStockObject( BLACK_BRUSH ); wndClass.hInstance = hInstance; wndClass.hIcon = LoadIcon( NULL, IDI_APPLICATION ); wndClass.hIconSm = LoadIcon( NULL, IDI_WINLOGO ); wndClass.hCursor = LoadCursor( NULL, IDC_ARROW ); wndClass.lpfnWndProc = ( WNDPROC )WndProc; wndClass.lpszClassName = "MainWndClass"; wndClass.lpszMenuName = ( LPCSTR )NULL; if( !RegisterClassEx( &wndClass ) ) { MessageBox( HWND_DESKTOP, "Cannot register the main window\nclass.", "Error", MB_OK | MB_ICONERROR ); return 0; } HWND hWndMain = CreateWindowEx( WS_EX_STATICEDGE, "MainWndClass", "DirectX Tutorial #1", WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX, CW_USEDEFAULT, CW_USEDEFAULT, 800, 600, HWND_DESKTOP, ( HMENU )NULL, ( HINSTANCE )hInstance, ( LPVOID* )NULL ); if( !hWndMain ) { MessageBox( HWND_DESKTOP, "Cannot create the main window.", "Error", MB_OK | MB_ICONERROR ); UnregisterClass( "MainWndClass", hInstance ); return 0; } ShowWindow( hWndMain, SW_SHOWNORMAL ); UpdateWindow( hWndMain ); MyDirectX->Init( hWndMain ); MSG msg = {0}; while( msg.message != WM_QUIT ) { if( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) ) { TranslateMessage( &msg ); DispatchMessage( &msg ); } // Do game rendering/updating here MyDirectX->Render( ); } MyDirectX->CleanDirectX( ); delete [] MyDirectX; UnregisterClass( "MainWndClass", hInstance ); return 0; }
int PASCAL WinMain(HANDLE hInstance, HANDLE hPrevInstance, LPSTR CmdLine, int nCmdShow) { MSG msg; /* MSG structure to pass to windows proc */ WNDCLASS wndclass; char *AppName; /* Name for the window */ cbErrHandling (PRINTALL, STOPALL); /* Set library's error handling */ CmdLine = NULL; /* Not used */ AppName = "WINCDEMO"; /* The name of this application */ if(!hPrevInstance) { wndclass.style = CS_HREDRAW | CS_VREDRAW; wndclass.lpfnWndProc= MainMessageHandler; wndclass.cbClsExtra = 0; wndclass.cbWndExtra = 0; wndclass.hInstance = hInstance; wndclass.hIcon = LoadIcon (hInstance, AppName); wndclass.hCursor = LoadCursor (NULL, IDC_ARROW); wndclass.hbrBackground = GetStockObject (WHITE_BRUSH); wndclass.lpszMenuName = AppName; wndclass.lpszClassName = AppName; RegisterClass (&wndclass); } /* create application's Main window */ hWndMain = CreateWindow (AppName, /* Window class name */ "AInScan Foreground", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, /* Use default X, Y */ CW_USEDEFAULT, /* Use default X, Y */ GetSystemMetrics(SM_CXSIZE) * 12, /* x - fit text */ GetSystemMetrics(SM_CYSIZE) * 20, /* y - fit text */ NULL, /* Parent window's handle */ NULL, /* Default to Class Menu */ hInstance, /* Instance of window */ NULL); /* Create struct for WM_CREATE */ if (hWndMain == NULL) { MessageBox(NULL, "Could not create window in WinMain", NULL, MB_ICONEXCLAMATION); return (1); } ShowWindow(hWndMain, nCmdShow); /* Display main window */ UpdateWindow(hWndMain); /* Start a 500ms timer to update display */ // if(!SetTimer(hWndMain, TIMER_NUM, 500, NULL)) // { // MessageBox(NULL, "Error starting Windows timer", NULL, MB_OK | // MB_ICONEXCLAMATION); // return (1); // } while(GetMessage(&msg, NULL, 0, 0)) /* Main message loop */ { TranslateMessage(&msg); DispatchMessage(&msg); } UnregisterClass (AppName, hInstance); return (msg.wParam); }
int WINAPI WinMain(HINSTANCE hinstance, HINSTANCE hprev, PSTR cmdline, int ishow) { HDC hDCScreen = GetDC(NULL); int Horres = GetDeviceCaps(hDCScreen, HORZRES); int Vertres = GetDeviceCaps(hDCScreen, VERTRES); HWND hwnd = NULL; HMENU hmenu; MSG msg; WNDCLASSEX wndclass = { 1 }; wndclass.cbSize = sizeof(wndclass); wndclass.style = CS_HREDRAW | CS_VREDRAW; wndclass.lpfnWndProc = WinProc; wndclass.hInstance = hinstance; wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); wndclass.lpszClassName = "Class"; hmenu = LoadMenu(hinstance, MAKEINTRESOURCE(IDR_MENU1)); if (!hmenu) return EXIT_FAILURE; // Something bad happened :( RegisterClassEx(&wndclass); hwnd = CreateWindowEx(NULL, // No extra style, "Class", "RSA Шифрование", WS_OVERLAPPEDWINDOW | WS_THICKFRAME, GetDeviceCaps(hDCScreen, HORZRES) / 2 - WINDOW_WIDTH / 2, GetDeviceCaps(hDCScreen, VERTRES) / 2 - WINDOW_HEIGHT / 2, WINDOW_WIDTH, WINDOW_HEIGHT, NULL, hmenu, hinstance, NULL); SetCursorPos(GetDeviceCaps(hDCScreen, HORZRES) / 2, GetDeviceCaps(hDCScreen, VERTRES) / 2); ShowWindow(hwnd, ishow); UpdateWindow(hwnd); while (1) { if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { if (msg.message == WM_QUIT) break; TranslateMessage(&msg); DispatchMessage(&msg); } } UnregisterClass("Class", hinstance); return msg.wParam; }
int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow) { _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); UNREFERENCED_PARAMETER(hPrevInstance); UNREFERENCED_PARAMETER(lpCmdLine); // TODO: ここにコードを挿入してください。 MSG msg; HACCEL hAccelTable; // グローバル文字列を初期化しています。 LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING); LoadString(hInstance, IDC_WALL, szWindowClass, MAX_LOADSTRING); MyRegisterClass(hInstance); // アプリケーションの初期化を実行します: if (!InitInstance (hInstance, nCmdShow)) { return FALSE; } int ret; ret = OneTimeSceneInit(); if( ret ){ _ASSERT( 0 ); return FALSE; } hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WALL)); // Now we're ready to recieve and process Windows messages. BOOL bGotMsg; //MSG msg; PeekMessage( &msg, NULL, 0U, 0U, PM_NOREMOVE ); while( WM_QUIT != msg.message ) { // Use PeekMessage() if the app is active, so we can use idle time to // render the scene. Else, use GetMessage() to avoid eating CPU time. // if( m_bActive ) bGotMsg = PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ); //else // bGotMsg = GetMessage( &msg, NULL, 0U, 0U ); if( bGotMsg ) { // Translate and dispatch the message if( 0 == TranslateAccelerator(msg.hwnd, hAccelTable, &msg) ) { TranslateMessage( &msg ); DispatchMessage( &msg ); } }else{ if( Render3DEnvironment() != 0 ){ SendMessage( msg.hwnd, WM_CLOSE, 0, 0 ); } } } E3DBye(); return (int)msg.wParam; }
int PASCAL WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int nCmdShow) { WNDCLASSEX wcex; MSG Msg; HWND hWnd; // Initialize the COM system CoInitialize(NULL); // Create the window class here and register it wcex.cbSize = sizeof(wcex); wcex.style = CS_CLASSDC; wcex.lpfnWndProc = WindowProc; wcex.cbClsExtra = 0; wcex.cbWndExtra = 0; wcex.hInstance = hInst; wcex.hIcon = LoadIcon(NULL, IDI_APPLICATION); wcex.hCursor = LoadCursor(NULL, IDC_ARROW); wcex.hbrBackground = NULL; wcex.lpszMenuName = NULL; wcex.lpszClassName = g_szClass; wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION); if(!RegisterClassEx(&wcex)) return FALSE; // Create the main window hWnd = CreateWindow(g_szClass, g_szCaption, WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX, 0, 0, 640, 480, NULL, NULL, hInst, NULL); if(!hWnd) return FALSE; ShowWindow(hWnd, SW_NORMAL); UpdateWindow(hWnd); // Call init function and enter message pump if(DoInit(hWnd) == TRUE) { // Start message pump, waiting for user to exit ZeroMemory(&Msg, sizeof(MSG)); while(Msg.message != WM_QUIT) { if(PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE)) { TranslateMessage(&Msg); DispatchMessage(&Msg); } // Render a single frame DoFrame(); } } // Call shutdown DoShutdown(); // Unregister the window class UnregisterClass(g_szClass, hInst); // Shut down the COM system CoUninitialize(); return 0; }
long CWorkgroupDocument::CopyMoveFile(DWORD folder_id, _bstr_t filepath, VARIANT_BOOL bSilent, CProgressDlg* dlg) { long nFilesCopied = 0; DWORD attributes = GetFileAttributes(filepath); char* filepart = PathFindFileName(filepath); if (attributes & FILE_ATTRIBUTE_DIRECTORY) { folder_id = m_filesystem->FindOrCreateFolder(folder_id, filepart, L""); if (folder_id) { HANDLE hFindFile; WIN32_FIND_DATA wfd; char search[MAX_PATH]; wsprintf(search, "%S\\*.*", (BSTR)filepath); if ((hFindFile = FindFirstFile(search, &wfd)) != INVALID_HANDLE_VALUE) { do { if (wfd.cFileName[0] != '.') { char pathName[_MAX_PATH]; _makepath(pathName, NULL, filepath, wfd.cFileName, NULL); nFilesCopied += CopyMoveFile(folder_id, pathName, bSilent, dlg); if (dlg) { if (dlg->m_bCancel) break; } } } while (FindNextFile(hFindFile, &wfd)); FindClose(hFindFile); } } else { if (!bSilent) { CUString str; str.Format("Couldn't create folder %S", (BSTR)filepath); MessageBox(NULL, str, "LXFramework", MB_OK); } } } else { SAFEARRAY* dataArray = NULL; long dataSize = 0; FILE* fp = fopen(filepath, "rb"); if (fp) { fseek(fp, 0, SEEK_END); dataSize = ftell(fp); fseek(fp, 0, SEEK_SET); dataArray = SafeArrayCreateVector(VT_UI1, 0, dataSize); if (dataArray) { fread((dataArray)->pvData, 1, dataSize, fp); } fclose(fp); } else { if (!bSilent) { CUString str; str.Format("Couldn't open %S", (BSTR)filepath); MessageBox(NULL, str, "LXFramework", MB_OK); } } if (dataArray) { long file_id; VARIANT_BOOL success = m_filesystem->SaveArrayAsFile(folder_id, _bstr_t(filepart), dataArray, L"", &file_id); SafeArrayDestroy(dataArray); if (success) { nFilesCopied++; } else { if (!bSilent) { CUString str; str.Format("Failed to copy %s", filepart); MessageBox(NULL, str, "LXFramework", MB_OK); } } } if (dlg) { dlg->m_pos += dataSize/10; dlg->Invalidate(); MSG msg; while (PeekMessage(&msg, dlg->m_hWnd, 0, 0, PM_REMOVE)) { TranslateMessage(&msg); DispatchMessage(&msg); } } } return nFilesCopied; }
/* Initialize(). We already have a window from the screensaver, so store it and pass along all 0's to initialize a child window. */ bool CDisplayDX::Initialize( HWND _hWnd, bool _bPreview ) { m_bScreensaver = true; m_bPreview = _bPreview; m_WindowHandle = _hWnd; HMODULE hInstance = GetModuleHandle( NULL ); WNDCLASS wc = {0}; wc.style = CS_VREDRAW | CS_HREDRAW; wc.lpfnWndProc = (WNDPROC)CDisplayDX::wndProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = hInstance; wc.hIcon = LoadIcon (GetModuleHandle(NULL), MAKEINTRESOURCE(1)); wc.hCursor = NULL; wc.hbrBackground = NULL; wc.lpszMenuName = NULL; wc.lpszClassName = L"ElectricsheepWndClass"; RegisterClass( &wc ); if( _bPreview ) { g_bPreview = true; RECT rc; //GetWindowRect( _hWnd, &rc ); GetClientRect( _hWnd, &rc ); int32 cx = rc.right - rc.left; int32 cy = rc.bottom - rc.top; g_Log->Info( "rc: %d, %d", cx, cy ); DWORD dwStyle = WS_VISIBLE | WS_CHILD; AdjustWindowRect( &rc, dwStyle, FALSE ); m_WindowHandle = CreateWindow( L"ElectricsheepWndClass", L"Preview", dwStyle, rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top, _hWnd, NULL, hInstance, NULL ); g_Log->Info( "CDisplayDX::Initialize x=%u y=%u w=%u h=%u", rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top); if( m_WindowHandle == NULL ) { g_Log->Error( "CDisplayDX::Initialize unable to create window for preview" ); //ThrowStr( "Unable to create window..." ); return false; } m_Width = cx; m_Height = cy; g_Log->Info( "Screensaver preview (%dx%d)", cx, cy ); // In preview mode, "pause" (enter a limited message loop) briefly before proceeding, so the display control panel knows to update itself. m_bWaitForInputIdle = true; // Post a message to mark the end of the initial group of window messages PostMessage( m_WindowHandle, WM_USER, 0, 0 ); InvalidateRect( GetParent( _hWnd ), NULL, FALSE ); // Invalidate the hwnd so it gets drawn UpdateWindow( GetParent( _hWnd ) ); UpdateWindow( GetParent( _hWnd ) ); MSG msg; while( m_bWaitForInputIdle ) { // If GetMessage returns FALSE, it's quitting time. if( !GetMessage( &msg, m_WindowHandle, 0, 0 ) ) { // Post the quit message to handle it later PostQuitMessage(0); break; } TranslateMessage( &msg ); DispatchMessage( &msg ); } if( !InitDX9() ) return false; //ShowWindow( _hWnd, SW_SHOW ); //SetForegroundWindow( _hWnd ); SetFocus( _hWnd ); ShowCursor( true ); } else { // int32 cx = GetSystemMetrics( SM_CXSCREEN ); // int32 cy = GetSystemMetrics( SM_CYSCREEN ); RECT rc; GetWindowRect( _hWnd, &rc ); m_Width = rc.right - rc.left; m_Height = rc.bottom - rc.top; g_Log->Info( "CDisplayDX::Initialize right=%u left=%u bottom=%u top=%u", rc.right, rc.left, rc.bottom, rc.top); //DWORD exstyle = 0;//WS_EX_TOPMOST; //DWORD style = WS_CHILD | WS_VISIBLE; m_WindowHandle = _hWnd;//CreateWindowEx( exstyle, "Electricsheep", "Saver", style, 0, 0, cx, cy, _hWnd, NULL, hInstance, NULL ); if( m_WindowHandle == NULL ) { g_Log->Error( "CDisplayDX::Initialize unable to create window from _hWnd" ); return false; } g_Log->Info( "Screensaver (%dx%d)", m_Width, m_Height ); // Hide cursor. ShowCursor( false ); if( !InitDX9() ) return false; } return true; }
void mswin_display_RIP_window(HWND hWnd) { MSG msg; RECT rt; PNHRIPWindow data; HWND mapWnd; RECT riprt; RECT clientrect; RECT textrect; HFONT OldFont; MonitorInfo monitorInfo; win10_monitor_info(hWnd, &monitorInfo); data = (PNHRIPWindow) GetWindowLongPtr(hWnd, GWLP_USERDATA); data->x = (int)(RIP_OFFSET_X * monitorInfo.scale); data->y = (int)(RIP_OFFSET_Y * monitorInfo.scale); data->width = (int)(RIP_WIDTH * monitorInfo.scale); data->height = (int)(RIP_HEIGHT * monitorInfo.scale); data->graveX = (int)(RIP_GRAVE_X * monitorInfo.scale); data->graveY = (int)(RIP_GRAVE_Y * monitorInfo.scale); data->graveWidth = (int)(RIP_GRAVE_WIDTH * monitorInfo.scale); data->graveHeight = (int)(RIP_GRAVE_HEIGHT * monitorInfo.scale); GetNHApp()->hPopupWnd = hWnd; mapWnd = mswin_hwnd_from_winid(WIN_MAP); if (!IsWindow(mapWnd)) mapWnd = GetNHApp()->hMainWnd; GetWindowRect(mapWnd, &rt); GetWindowRect(hWnd, &riprt); GetClientRect(hWnd, &clientrect); textrect = clientrect; textrect.top += data->y; textrect.left += data->x; textrect.right -= data->x; if (data->window_text) { HDC hdc = GetDC(hWnd); OldFont = SelectObject(hdc, mswin_get_font(NHW_TEXT, 0, hdc, FALSE)->hFont); DrawText(hdc, data->window_text, strlen(data->window_text), &textrect, DT_LEFT | DT_NOPREFIX | DT_CALCRECT); SelectObject(hdc, OldFont); ReleaseDC(hWnd, hdc); } if (textrect.right - textrect.left > data->width) clientrect.right = textrect.right + data->y - clientrect.right; else clientrect.right = textrect.left + 2 * data->x + data->width - clientrect.right; clientrect.bottom = textrect.bottom + data->height + data->y - clientrect.bottom; GetWindowRect(GetDlgItem(hWnd, IDOK), &textrect); textrect.right -= textrect.left; textrect.bottom -= textrect.top; clientrect.bottom += textrect.bottom + data->y; riprt.right -= riprt.left; riprt.bottom -= riprt.top; riprt.right += clientrect.right; riprt.bottom += clientrect.bottom; rt.left += (rt.right - rt.left - riprt.right) / 2; rt.top += (rt.bottom - rt.top - riprt.bottom) / 2; MoveWindow(hWnd, rt.left, rt.top, riprt.right, riprt.bottom, TRUE); GetClientRect(hWnd, &clientrect); MoveWindow(GetDlgItem(hWnd, IDOK), (clientrect.right - clientrect.left - textrect.right) / 2, clientrect.bottom - textrect.bottom - data->y, textrect.right, textrect.bottom, TRUE); ShowWindow(hWnd, SW_SHOW); while (IsWindow(hWnd) && GetMessage(&msg, NULL, 0, 0) != 0) { if (!IsDialogMessage(hWnd, &msg)) { TranslateMessage(&msg); DispatchMessage(&msg); } } GetNHApp()->hPopupWnd = NULL; }
INT WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR szCmdLine, int iCmdShow) { WNDCLASSEX winClass ; winClass.lpszClassName = "Vertex Alpha"; winClass.cbSize = sizeof(WNDCLASSEX); winClass.style = CS_HREDRAW | CS_VREDRAW; winClass.lpfnWndProc = MsgProc; winClass.hInstance = hInstance; winClass.hIcon = NULL ; winClass.hIconSm = NULL ; winClass.hCursor = LoadCursor(NULL, IDC_ARROW) ; winClass.hbrBackground = NULL ; winClass.lpszMenuName = NULL ; winClass.cbClsExtra = 0; winClass.cbWndExtra = 0; RegisterClassEx (&winClass) ; HWND hWnd = CreateWindowEx(NULL, winClass.lpszClassName, // window class name "Vertex Alpha", // window caption WS_OVERLAPPEDWINDOW, // window style 32, // initial x position 32, // initial y position 600, // initial window width 600, // initial window height NULL, // parent window handle NULL, // window menu handle hInstance, // program instance handle NULL) ; // creation parameters // Create window failed if(hWnd == NULL) { MessageBoxA(hWnd, "Create Window failed!", "Error", 0) ; return -1 ; } // Initialize Direct3D if( SUCCEEDED(InitD3D(hWnd))) { // Show the window ShowWindow( hWnd, SW_SHOWDEFAULT ); UpdateWindow( hWnd ); MSG msg ; ZeroMemory( &msg, sizeof(msg) ); PeekMessage( &msg, NULL, 0U, 0U, PM_NOREMOVE ); // Get last time static DWORD lastTime = timeGetTime(); while (msg.message != WM_QUIT) { if(PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) != 0) { TranslateMessage (&msg) ; DispatchMessage (&msg) ; } else // Render the game if there is no message to process { // Get current time DWORD currTime = timeGetTime(); // Calculate time elapsed float timeDelta = (currTime - lastTime) * 0.001f; // Render Render() ; // Update last time to current time for next loop lastTime = currTime; } } } UnregisterClass(winClass.lpszClassName, hInstance) ; return 0; }
//-----------------------------------WinMain----------------------------------------- // Entry point for our windows application //----------------------------------------------------------------------------------- int WINAPI WinMain( HINSTANCE hinstance, HINSTANCE hprevinstance, LPSTR lpcmdline, int ncmdshow) { WNDCLASSEX winclass; HWND hwnd; MSG msg; // first fill in the window class stucture winclass.cbSize = sizeof(WNDCLASSEX); winclass.style = CS_HREDRAW | CS_VREDRAW; winclass.lpfnWndProc = WindowProc; winclass.cbClsExtra = 0; winclass.cbWndExtra = 0; winclass.hInstance = hinstance; winclass.hIcon = LoadIcon(hinstance, MAKEINTRESOURCE(IDI_ICON1)); winclass.hCursor = LoadCursor(NULL, IDC_ARROW); winclass.hbrBackground= NULL; winclass.lpszMenuName = NULL; winclass.lpszClassName= szWindowClassName; winclass.hIconSm = LoadIcon(hinstance, MAKEINTRESOURCE(IDI_ICON1)); // register the window class if (!RegisterClassEx(&winclass)) { MessageBox(NULL, "Error Registering Class!", "Error", 0); return 0; } // create the window (one that cannot be resized) if (!(hwnd = CreateWindowEx(NULL, szWindowClassName, szApplicationName, WS_OVERLAPPED | WS_VISIBLE | WS_CAPTION | WS_SYSMENU, GetSystemMetrics(SM_CXSCREEN)/2 - CParams::WindowWidth/2, GetSystemMetrics(SM_CYSCREEN)/2 - CParams::WindowHeight/2, CParams::WindowWidth, CParams::WindowHeight, NULL, NULL, hinstance, NULL))) { MessageBox(NULL, "Error Creating Window!", "Error", 0); return 0; } //Show the window ShowWindow(hwnd, SW_SHOWDEFAULT ); UpdateWindow(hwnd); //create a timer CTimer timer(CParams::iFramesPerSecond); //start the timer timer.Start(); // Enter the message loop bool bDone = FALSE; while(!bDone) { while( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) ) { if( msg.message == WM_QUIT ) { //Stop loop if it's a quit message bDone = TRUE; } else { TranslateMessage( &msg ); DispatchMessage( &msg ); } } if (timer.ReadyForNextFrame() || g_pController->FastRender()) { if(!g_pController->Update()) { //we have a problem, end app bDone = TRUE; } //this will call WM_PAINT which will render our scene InvalidateRect(hwnd, NULL, TRUE); UpdateWindow(hwnd); } }//end while // Clean up everything and exit the app Cleanup(); UnregisterClass( szWindowClassName, winclass.hInstance ); return 0; } // end WinMain
int _tmain(int argc, const TCHAR *argv) { HWND w; HINSTANCE hinst = GetModuleHandle(NULL); { WNDCLASS wc; wc.style = CS_HREDRAW|CS_VREDRAW; wc.lpfnWndProc = window_proc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = hinst; wc.hIcon = NULL; wc.hCursor = LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1); wc.lpszMenuName = NULL; wc.lpszClassName = _T("MainWindowClass"); RegisterClass(&wc); } // CreateWindow // http://msdn.microsoft.com/en-us/library/windows/desktop/ms632679(v=vs.85).aspx // > If an overlapped window is created with the WS_VISIBLE // > style bit set and the x parameter is set to // > CW_USEDEFAULT, then the y parameter determines how the // > window is shown. If the y parameter is CW_USEDEFAULT, // > then the window manager calls ShowWindow with the SW_SHOW // > flag after the window has been created. If the y // > parameter is some other value, then the window manager // > calls ShowWindow with that value as the nCmdShow // > parameter. // ShowWindow // http://msdn.microsoft.com/en-us/library/windows/desktop/ms633548(v=vs.85).aspx // > Controls how the window is to be shown. // > This parameter is ignored the first time an // > application calls ShowWindow, if the program that // > launched the application provides a STARTUPINFO // > structure. // > Otherwise, the first time ShowWindow is called, the value // > should be the value obtained by the WinMain function in // > its nCmdShow parameter. In subsequent calls, this // > parameter can be one of the following values. w = CreateWindow(_T("MainWindowClass"), _T("hello"), WS_OVERLAPPEDWINDOW|WS_VISIBLE, CW_USEDEFAULT, SW_SHOW, CW_USEDEFAULT, 0, NULL, NULL, hinst, NULL); while (1) { MSG msg; BOOL b = GetMessage(&msg, NULL, 0, 0); if (b == 0) { return msg.wParam; } if (b == -1) { return 1; } TranslateMessage(&msg); DispatchMessage(&msg); } return 0; }
int PASCAL WinMain ( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow ) { strcpy ( szMap, lpCmdLine ); //strcpy ( szMap, "csg1.x" ); char szFinal [ 256 ]; memset ( szFinal, 0, sizeof ( szFinal ) ); for ( int iTemp = strlen ( szMap ); iTemp > 0; iTemp-- ) { if ( szMap [ iTemp ] == '/' || szMap [ iTemp ] == '\\' ) { memcpy ( szFinal, &szMap [ iTemp + 1 ], sizeof ( char ) * iTemp ); break; } } strcpy ( szMap, szFinal ); //MessageBox ( NULL, szFinal, "info", MB_OK ); //MessageBox ( NULL, szMap, "info", MB_OK ); //MessageBox ( NULL, lpCmdLine, "lpCmdLine", MB_OK ); hInst = hInstance; hPrevInstance = hPrevInstance; MSG msg; BOOL perf_flag = FALSE; LONGLONG last_time = 0; LONGLONG cur_time; LONGLONG perf_cnt; float time_scale; if ( !doInit ( hInst, nCmdShow ) ) return FALSE; if ( QueryPerformanceFrequency ( ( LARGE_INTEGER* ) &perf_cnt ) ) { QueryPerformanceCounter ( ( LARGE_INTEGER* ) &last_time ); time_scale = 1.0f / perf_cnt; perf_flag = TRUE; } else { last_time = timeGetTime ( ); time_scale = 0.001f; } // SetCursorPos ( 320,200 ); // ShowCursor ( FALSE ); BOOL bGotMsg; while ( quit != 1 ) { while ( bGotMsg = PeekMessage ( &msg, NULL, 0U, 0U, PM_REMOVE ) ) { TranslateMessage ( &msg ); DispatchMessage ( &msg ); } if ( rendering == 1 ) { if ( perf_flag ) QueryPerformanceCounter ( ( LARGE_INTEGER* ) &cur_time ); else cur_time = timeGetTime ( ); time_elapsed = ( cur_time - last_time ) * time_scale; last_time = cur_time; // CheckInput ( ); // renderframe ( ); } } ShowCursor ( TRUE ); return msg.wParam; }
int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow) { UNREFERENCED_PARAMETER(hPrevInstance); UNREFERENCED_PARAMETER(nCmdShow); SetDllDirectory(L""); SetTaskIDPerUUID(); MSG msg; HACCEL hAccelTable; CCmdLineParser parser(lpCmdLine); if (parser.HasKey(_T("?")) || parser.HasKey(_T("help"))) { TCHAR buf[1024]; LoadString(hInstance, IDS_COMMANDLINEHELP, buf, sizeof(buf)/sizeof(TCHAR)); MessageBox(NULL, buf, _T("TortoiseGitUDiff"), MB_ICONINFORMATION); return 0; } INITCOMMONCONTROLSEX used = { sizeof(INITCOMMONCONTROLSEX), ICC_STANDARD_CLASSES | ICC_BAR_CLASSES }; InitCommonControlsEx(&used); HMODULE hSciLexerDll = ::LoadLibrary(_T("SciLexer.DLL")); if (hSciLexerDll == NULL) return FALSE; CMainWindow mainWindow(hInstance); mainWindow.SetRegistryPath(_T("Software\\TortoiseGit\\UDiffViewerWindowPos")); if (parser.HasVal(_T("title"))) mainWindow.SetTitle(parser.GetVal(_T("title"))); else if (parser.HasVal(_T("patchfile"))) mainWindow.SetTitle(parser.GetVal(_T("patchfile"))); else mainWindow.SetTitle(_T("diff from pipe")); if (!mainWindow.RegisterAndCreateWindow()) { FreeLibrary(hSciLexerDll); return 0; } bool bLoadedSuccessfully = false; if ( (lpCmdLine[0] == 0) || (parser.HasKey(_T("p"))) ) { // input from console pipe // set console to raw mode DWORD oldMode; GetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), &oldMode); SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), oldMode & ~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT)); bLoadedSuccessfully = mainWindow.LoadFile(GetStdHandle(STD_INPUT_HANDLE)); } else if (parser.HasVal(_T("patchfile"))) bLoadedSuccessfully = mainWindow.LoadFile(parser.GetVal(_T("patchfile"))); else if (lpCmdLine[0] != 0) bLoadedSuccessfully = mainWindow.LoadFile(lpCmdLine); if (!bLoadedSuccessfully) { FreeLibrary(hSciLexerDll); return 0; } ::ShowWindow(mainWindow.GetHWNDEdit(), SW_SHOW); ::SetFocus(mainWindow.GetHWNDEdit()); hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_TORTOISEUDIFF)); // Main message loop: while (GetMessage(&msg, NULL, 0, 0)) { if (!TranslateAccelerator(mainWindow, hAccelTable, &msg)) { TranslateMessage(&msg); DispatchMessage(&msg); } } FreeLibrary(hSciLexerDll); return (int) msg.wParam; }
int APIENTRY wWinMain(HINSTANCE, HINSTANCE, LPWSTR, int) { #else // _DEBUG void APIENTRY _myWinMain() { #endif // _DEBUG g_hinstExe = GetModuleHandle(NULL); int nExitCode = 1; //HANDLE hmtx = NULL; __try { ParseCommandLine(); if (!CheckVersion() && !(g_dwCmdLine & CCLF_NOCHECKVER)) { MessageBoxA(NULL, "This program requires features present in Windows XP/2003.", "Error", MB_OK | MB_ICONERROR | MB_TOPMOST | MB_SETFOREGROUND); __leave; } /*hmtx = CreateMutex(NULL, FALSE, g_szTaskSwitch); if (GetLastError() == ERROR_ALREADY_EXISTS) { ReportError(IDS_ERR_EXISTS); __leave; }*/ InitThreadLang2(); InitLanguage(); HWND hwndTs = FindWindowEx(NULL/*HWND_MESSAGE*/, NULL, g_szMainWnd, g_szWindowName); if (IsWindow(hwndTs)) { if (g_dwCmdLine != 0) { SetForegroundWindow(hwndTs); PostMessage(hwndTs, WM_REMOTECMD, g_dwCmdLine, 0); } else { if (ConfirmMessage(IDS_CONFIRM_RUNNING, MB_ICONEXCLAMATION | MB_DEFBUTTON2)) PostMessage(hwndTs, WM_DESTROY, 0, 0); //PostMessage(hwndTs, WM_RELOADSETTINGS, 0, 0); } __leave; } HINSTANCE hinstUser32 = LoadLibrary(L"user32.dll"); g_pfnIsHungAppWindow = (ISHUNGAPPWINDOW)GetProcAddress(hinstUser32, "IsHungAppWindow"); //g_pfnEndTask = (ENDTASK)GetProcAddress(hinstUser32, "EndTask"); WNDCLASSEX wcex; wcex.cbSize = sizeof(WNDCLASSEX); wcex.style = 0; wcex.lpfnWndProc = (WNDPROC)MainWndProc; wcex.cbClsExtra = 0; wcex.cbWndExtra = 0; wcex.hInstance = g_hinstExe; wcex.hIcon = NULL; wcex.hCursor = NULL; wcex.hbrBackground = NULL; wcex.lpszMenuName = NULL; wcex.lpszClassName = g_szMainWnd; wcex.hIconSm = NULL; if (!RegisterClassEx(&wcex)) __leave; if (!CreateWindowEx(WS_EX_TOOLWINDOW, g_szMainWnd, g_szWindowName, 0, 0, 0, 0, 0, NULL/*HWND_MESSAGE*/, NULL, g_hinstExe, NULL)) __leave; MSG msg; while (GetMessage(&msg, NULL, 0, 0)) { TranslateMessage(&msg); DispatchMessage(&msg); } nExitCode = (int)msg.wParam; } __finally { DestroyThreadLang2(); //if (hmtx) CloseHandle(hmtx); } #ifdef _DEBUG return(nExitCode); #else // _DEBUG ExitProcess((UINT)nExitCode); #endif }