/************************************************************************* Win32 'Window Procedure' function *************************************************************************/ LRESULT CALLBACK Win32AppHelper::wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { switch(message) { case WM_CHAR: s_samplesFramework->injectChar((CEGUI::utf32)wParam); break; case WM_MOUSELEAVE: mouseLeaves(); break; case WM_NCMOUSEMOVE: mouseLeaves(); break; case WM_MOUSEMOVE: mouseEnters(); s_samplesFramework->injectMousePosition((float)(LOWORD(lParam)), (float)(HIWORD(lParam))); break; case WM_LBUTTONDOWN: s_samplesFramework->injectMouseButtonDown(CEGUI::LeftButton); break; case WM_LBUTTONUP: s_samplesFramework->injectMouseButtonUp(CEGUI::LeftButton); break; case WM_RBUTTONDOWN: s_samplesFramework->injectMouseButtonDown(CEGUI::RightButton); break; case WM_RBUTTONUP: s_samplesFramework->injectMouseButtonUp(CEGUI::RightButton); break; case WM_MBUTTONDOWN: s_samplesFramework->injectMouseButtonDown(CEGUI::MiddleButton); break; case WM_MBUTTONUP: s_samplesFramework->injectMouseButtonUp(CEGUI::MiddleButton); break; case 0x020A: // WM_MOUSEWHEEL: s_samplesFramework->injectMouseWheelChange(static_cast<float>((short)HIWORD(wParam)) / static_cast<float>(120)); break; case WM_DESTROY: PostQuitMessage(0); break; case WM_SIZE: { // get CEGUI::System as a pointer so we can detect if it's not // instantiated yet. CEGUI::System* cegui_system = CEGUI::System::getSingletonPtr(); // only continue if CEGUI is up an running and window was not // minimised (else it's just a waste of time) if ((cegui_system != 0) && (wParam != SIZE_MINIMIZED)) { // get renderer identification string CEGUI::Renderer* renderer = cegui_system->getRenderer(); CEGUI::String id(renderer->getIdentifierString()); // invoke correct function based on the renderer we have ID'd #ifdef CEGUI_BUILD_RENDERER_DIRECT3D9 if (id.find("Official Direct3D 9") != id.npos) DeviceReset_Direct3D9(hWnd, renderer); #endif #ifdef CEGUI_BUILD_RENDERER_DIRECT3D10 if (id.find("Official Direct3D 10") != id.npos) DeviceReset_Direct3D10(hWnd, renderer); #endif #ifdef CEGUI_BUILD_RENDERER_DIRECT3D11 if (id.find("Official Direct3D 11") != id.npos) DeviceReset_Direct3D11(hWnd, renderer); #endif } } break; case WM_PAINT: { HDC hDC; PAINTSTRUCT ps; hDC = BeginPaint(hWnd, &ps); EndPaint(hWnd, &ps); break; } default: return(DefWindowProc(hWnd, message, wParam, lParam)); break; } return 0; }
static int Desktop(HWND hWnd, int message, WPARAM wParam, LPARAM lParam) { char cwd[MAX_PATH + 1]; //DEB("-Desktop: \n "); switch (message) { case MSG_CREATE: { DEB("--MSG_CREATE\n "); /* CreateWindow(CTRL_LISTBOX, "", LBS_NOTIFY | WS_VSCROLL | WS_BORDER | WS_VISIBLE, IDC_FUN_3G_NOW_LISTBOX_FILE, 10, 30, 100, 100, hWnd, 0); */ CreateWindow(CTRL_LISTBOX, "", LBS_NOTIFY | WS_VSCROLL | WS_BORDER | WS_VISIBLE, IDC_FUN_3G_NOW_LISTBOX_FILE, 10, 30, 100, 100, hWnd, 0); CreateWindow(CTRL_LISTBOX, "", LBS_NOTIFY | WS_VSCROLL | WS_BORDER | WS_VISIBLE, IDC_FUN_3G_ADD_LISTBOX_FILE, 110, 30, 100, 100, hWnd, 0); CreateWindow(CTRL_STATIC, MSG_PATH, WS_VISIBLE | SS_SIMPLE, IDC_FUN_MPLAYER_MUSICADD_STATIC_PATH, 10, 10, 130, 15, hWnd, 0); CreateWindow(CTRL_BUTTON, MSG_DOWNLOAD, WS_TABSTOP | WS_VISIBLE | BS_DEFPUSHBUTTON, IDC_FUN_MPLAYER_MUSICADD_BUTTON_CHOOSE, 230, 50, 70, 25, hWnd, 0); CreateWindow(CTRL_BUTTON, MSG_CANCEL, WS_TABSTOP | WS_VISIBLE | BS_DEFPUSHBUTTON, IDC_FUN_MPLAYER_MUSICADD_BUTTON_CANCEL, 230, 100, 50, 25, hWnd, 0); SetNotificationCallback(GetDlgItem(hWnd, IDC_FUN_3G_NOW_LISTBOX_FILE), now_notif_proc); SetNotificationCallback(GetDlgItem(hWnd, IDC_FUN_3G_ADD_LISTBOX_FILE), file_notif_proc); fill_boxes(hWnd, getcwd(cwd, MAX_PATH)); } break; case MSG_COMMAND: { DEB("--MSG_COMMAND hWnd=%d\n ,hWnd"); switch (wParam) { case IDC_FUN_MPLAYER_MUSICADD_BUTTON_CHOOSE: DEB("---IDC_FUN_MPLAYER_MUSICADD_BUTTON_CHOOSE\n "); fn_3gFileSave(hWnd); DEB("---SendNotifyMessage fWnd=%d\n ",fWnd); SendNotifyMessage(fWnd, MSG_MUSIC_ADD, 0, 0L); DEB("---SendNotifyMessage end\n "); break; case IDC_FUN_MPLAYER_MUSICADD_BUTTON_CANCEL: DEB("---IDC_FUN_MPLAYER_MUSICADD_BUTTON_CANCEL\n "); DestroyMainWindow(hWnd); PostQuitMessage(hWnd); return 0; } DEB("--MSG_COMMAND END\n "); } break; case MSG_CLOSE: { DEB("--MSG_CLOSE\n "); DestroyMainWindow(hWnd); PostQuitMessage(hWnd); return 0; } } return DefaultMainWinProc(hWnd, message, wParam, lParam); }
/***************************************************************************** * WinVoutEventProc: This is the window event processing function. ***************************************************************************** * On Windows, when you create a window you have to attach an event processing * function to it. The aim of this function is to manage "Queued Messages" and * "Nonqueued Messages". * Queued Messages are those picked up and retransmitted by vout_Manage * (using the GetMessage and DispatchMessage functions). * Nonqueued Messages are those that Windows will send directly to this * procedure (like WM_DESTROY, WM_WINDOWPOSCHANGED...) *****************************************************************************/ static long FAR PASCAL WinVoutEventProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) { event_thread_t *p_event; if( message == WM_CREATE ) { /* Store vd for future use */ p_event = (event_thread_t *)((CREATESTRUCT *)lParam)->lpCreateParams; SetWindowLongPtr( hwnd, GWLP_USERDATA, (LONG_PTR)p_event ); return TRUE; } else { LONG_PTR p_user_data = GetWindowLongPtr( hwnd, GWLP_USERDATA ); p_event = (event_thread_t *)p_user_data; if( !p_event ) { /* Hmmm mozilla does manage somehow to save the pointer to our * windowproc and still calls it after the vout has been closed. */ return DefWindowProc(hwnd, message, wParam, lParam); } } vout_display_t *vd = p_event->vd; #if 0 if( message == WM_SETCURSOR ) { msg_Err(vd, "WM_SETCURSOR: %d (t2)", p_event->is_cursor_hidden); SetCursor( p_event->is_cursor_hidden ? p_event->cursor_empty : p_event->cursor_arrow ); return 1; } #endif if( message == WM_CAPTURECHANGED ) { for( int button = 0; p_event->button_pressed; button++ ) { unsigned m = 1 << button; if( p_event->button_pressed & m ) vout_display_SendEventMouseReleased( p_event->vd, button ); p_event->button_pressed &= ~m; } p_event->button_pressed = 0; return 0; } if( hwnd == p_event->hvideownd ) { #ifdef MODULE_NAME_IS_directdraw vlc_mutex_lock( &p_event->lock ); const bool use_overlay = p_event->use_overlay; vlc_mutex_unlock( &p_event->lock ); #endif switch( message ) { #ifdef MODULE_NAME_IS_directdraw case WM_ERASEBKGND: /* For overlay, we need to erase background */ return !use_overlay ? 1 : DefWindowProc(hwnd, message, wParam, lParam); case WM_PAINT: /* ** For overlay, DefWindowProc() will erase dirty regions ** with colorkey. ** For non-overlay, vout will paint the whole window at ** regular interval, therefore dirty regions can be ignored ** to minimize repaint. */ if( !use_overlay ) { ValidateRect(hwnd, NULL); } // fall through to default #else /* ** For OpenGL and Direct3D, vout will update the whole ** window at regular interval, therefore dirty region ** can be ignored to minimize repaint. */ case WM_ERASEBKGND: /* nothing to erase */ return 1; case WM_PAINT: /* nothing to repaint */ ValidateRect(hwnd, NULL); // fall through #endif default: return DefWindowProc(hwnd, message, wParam, lParam); } } switch( message ) { case WM_WINDOWPOSCHANGED: vlc_mutex_lock( &p_event->lock ); p_event->has_moved = true; vlc_mutex_unlock( &p_event->lock ); return 0; /* the user wants to close the window */ case WM_CLOSE: vout_display_SendEventClose(vd); return 0; /* the window has been closed so shut down everything now */ case WM_DESTROY: msg_Dbg( vd, "WinProc WM_DESTROY" ); /* just destroy the window */ PostQuitMessage( 0 ); return 0; case WM_SYSCOMMAND: switch (wParam) { case IDM_TOGGLE_ON_TOP: /* toggle the "on top" status */ { msg_Dbg(vd, "WinProc WM_SYSCOMMAND: IDM_TOGGLE_ON_TOP"); HMENU hMenu = GetSystemMenu(vd->sys->hwnd, FALSE); vout_display_SendWindowState(vd, (GetMenuState(hMenu, IDM_TOGGLE_ON_TOP, MF_BYCOMMAND) & MF_CHECKED) ? VOUT_WINDOW_STATE_NORMAL : VOUT_WINDOW_STATE_ABOVE); return 0; } default: break; } break; case WM_PAINT: case WM_NCPAINT: case WM_ERASEBKGND: return DefWindowProc(hwnd, message, wParam, lParam); case WM_KILLFOCUS: return 0; case WM_SETFOCUS: return 0; case WM_GESTURE: return DecodeGesture( VLC_OBJECT(vd), p_event->p_gesture, hwnd, message, wParam, lParam ); default: //msg_Dbg( vd, "WinProc WM Default %i", message ); break; } /* Let windows handle the message */ return DefWindowProc(hwnd, message, wParam, lParam); }
// Handles all the windows messages we might receive LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { static bool gDragging = false; static uint8_t mouse_down = 0; // Messages we registered for manually (no const value) if (message == s_WmTaskbarList) { // Grab the Windows 7 taskbar list stuff if (gTaskbarList) gTaskbarList->Release(); HRESULT result = CoCreateInstance(CLSID_TaskbarList, NULL, CLSCTX_ALL, IID_ITaskbarList3, (void**)&gTaskbarList); if (FAILED(result)) gTaskbarList = nil; return 0; } // Handle messages switch (message) { case WM_TIMECHANGE: // To prevent cheating and keep things better synchronized, // we will completely re-eval the offsets on the next NetMsg we // get from the server if (plNetClientMgr* nc = plNetClientMgr::GetInstance()) nc->ResetServerTimeOffset(true); break; case WM_LBUTTONDOWN: case WM_RBUTTONDOWN: case WM_LBUTTONDBLCLK: case WM_MBUTTONDBLCLK: case WM_MBUTTONDOWN: case WM_RBUTTONDBLCLK: // Ensure we don't leave the client area during clicks if (!(mouse_down++)) SetCapture(hWnd); // fall through to old case case WM_KEYDOWN: case WM_CHAR: // If they did anything but move the mouse, quit any intro movie playing. if (gClient) { gClient->SetQuitIntro(true); // normal input processing if (gClient->WindowActive() && gClient->GetInputManager()) gClient->GetInputManager()->HandleWin32ControlEvent(message, wParam, lParam, hWnd); } break; case WM_LBUTTONUP: case WM_RBUTTONUP: case WM_MBUTTONUP: // Stop hogging the cursor if (!(--mouse_down)) ReleaseCapture(); // fall through to input processing case WM_MOUSEWHEEL: case WM_KEYUP: if (gClient && gClient->WindowActive() && gClient->GetInputManager()) gClient->GetInputManager()->HandleWin32ControlEvent(message, wParam, lParam, hWnd); break; case WM_MOUSEMOVE: { if (gClient && gClient->GetInputManager()) gClient->GetInputManager()->HandleWin32ControlEvent(message, wParam, lParam, hWnd); } break; case WM_SYSKEYUP: case WM_SYSKEYDOWN: { if (gClient && gClient->WindowActive() && gClient->GetInputManager()) { gClient->GetInputManager()->HandleWin32ControlEvent(message, wParam, lParam, hWnd); } //DefWindowProc(hWnd, message, wParam, lParam); } break; case WM_SYSCOMMAND: switch (wParam) { // Trap ALT so it doesn't pause the app case SC_KEYMENU : //// disable screensavers and monitor power downs too. case SC_SCREENSAVE: case SC_MONITORPOWER: return 0; case SC_CLOSE : // kill game if window is closed gClient->SetDone(TRUE); if (plNetClientMgr * mgr = plNetClientMgr::GetInstance()) mgr->QueueDisableNet(false, nil); DestroyWindow(gClient->GetWindowHandle()); break; } break; case WM_SETCURSOR: { static bool winCursor = true; bool enterWnd = LOWORD(lParam) == HTCLIENT; if (enterWnd && winCursor) { winCursor = !winCursor; ShowCursor(winCursor != 0); plMouseDevice::ShowCursor(); } else if (!enterWnd && !winCursor) { winCursor = !winCursor; ShowCursor(winCursor != 0); plMouseDevice::HideCursor(); } return TRUE; } break; case WM_ACTIVATE: { bool active = (LOWORD(wParam) == WA_ACTIVE || LOWORD(wParam) == WA_CLICKACTIVE); bool minimized = (HIWORD(wParam) != 0); if (gClient && !minimized && !gClient->GetDone()) { gClient->WindowActivate(active); } else { gPendingActivate = true; gPendingActivateFlag = active; } } break; // Let go of the mouse if the window is being moved. case WM_ENTERSIZEMOVE: gDragging = true; if( gClient ) gClient->WindowActivate(false); break; // Redo the mouse capture if the window gets moved case WM_EXITSIZEMOVE: gDragging = false; if( gClient ) gClient->WindowActivate(true); break; // Redo the mouse capture if the window gets moved (special case for Colin // and his cool program that bumps windows out from under the taskbar) case WM_MOVE: if (!gDragging && gClient && gClient->GetInputManager()) gClient->GetInputManager()->Activate(true); break; /// Resize the window // (we do WM_SIZING here instead of WM_SIZE because, for some reason, WM_SIZE is // sent to the window when we do fullscreen, and what's more, it gets sent BEFORE // the fullscreen flag is sent. How does *that* happen? Anyway, WM_SIZING acts // just like WM_SIZE, except that it ONLY gets sent when the user changes the window // size, not when the window is minimized or restored) case WM_SIZING: { RECT r; ::GetClientRect(hWnd, &r); gClient->GetPipeline()->Resize(r.right - r.left, r.bottom - r.top); } break; case WM_SIZE: // Let go of the mouse if the window is being minimized if (wParam == SIZE_MINIMIZED) { if (gClient) gClient->WindowActivate(false); } // Redo the mouse capture if the window gets restored else if (wParam == SIZE_RESTORED) { if (gClient) gClient->WindowActivate(true); } break; case WM_CLOSE: gClient->SetDone(TRUE); if (plNetClientMgr * mgr = plNetClientMgr::GetInstance()) mgr->QueueDisableNet(false, nil); DestroyWindow(gClient->GetWindowHandle()); break; case WM_DESTROY: gClient->SetDone(TRUE); if (plNetClientMgr * mgr = plNetClientMgr::GetInstance()) mgr->QueueDisableNet(false, nil); PostQuitMessage(0); break; } return DefWindowProc(hWnd, message, wParam, lParam); }
LRESULT CALLBACK WinProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam) { PAINTSTRUCT Ps; switch(msg) { case WM_CREATE: { /** * Create AddFood Button */ HFONT hFont = CreateFont(30,0,0,0,FW_DONTCARE,FALSE,TRUE,FALSE,DEFAULT_CHARSET,OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS,NULL, VARIABLE_PITCH,TEXT("Impact")); HWND hButtonAddFood = CreateWindowEx(NULL, "BUTTON", "ADD FOOD", WS_TABSTOP|WS_VISIBLE| WS_CHILD|BS_DEFPUSHBUTTON|BS_TOP, 10, 150, 100, 25, hWnd, (HMENU)BUTTON_ADD_FOOD, GetModuleHandle(NULL), NULL); /** * Create button ShowFoodNumber */ HWND hShowFoodNumber = CreateWindowEx(NULL, "BUTTON", "Funny", WS_TABSTOP|WS_VISIBLE| WS_CHILD|BS_DEFPUSHBUTTON|BS_TOP, 10, 180, 300, 40, hWnd, (HMENU)BUTTON_DISPLAY_FOOD_NR, GetModuleHandle(NULL), NULL); SendMessage (hShowFoodNumber, WM_SETFONT, WPARAM (hFont), TRUE); /** * Draw Food List (In a input box) */ hFoodList = CreateWindowEx(WS_EX_CLIENTEDGE, "EDIT", "", WS_CHILD|WS_VISIBLE|WS_VSCROLL|ES_READONLY| ES_MULTILINE, 10, 40, 300, 100, hWnd, (HMENU)INPUT_TEXT_SHOW_FOOD, GetModuleHandle(NULL), NULL); /** * Draw main Input food field */ hInputFood = CreateWindowEx( (DWORD)NULL, TEXT("edit"), "", WS_VISIBLE | WS_CHILD | WS_BORDER, 120, 150, 190, 25, hWnd, (HMENU)INPUT_TEXT_ADD_FOOD, GetModuleHandle(NULL), NULL); } break; case WM_PAINT: { HDC hdc = BeginPaint(hWnd, &Ps); RECT rect; /** * Draw Text */ // Second Text char foodNrMessage[256] = "Number : "; char nr[50]; strcat(foodNrMessage, itoa(foodNumber, nr, 10)); SetBkMode(hdc, TRANSPARENT); SetRect(&updateRect, 210, 10, 300, 30); DrawText( hdc, foodNrMessage, -1, &updateRect, DT_SINGLELINE | DT_NOCLIP ) ; // First Text HFONT hFont = CreateFont(25,0,0,0,FW_DONTCARE,FALSE,TRUE,FALSE,DEFAULT_CHARSET,OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS,NULL, VARIABLE_PITCH,TEXT("Impact")); SetRect(&rect, 10, 10, 50, 50); SelectObject(hdc, hFont); SetBkMode(hdc, OPAQUE); SetBkColor(hdc, RGB(0,255,255)); SetTextColor(hdc, RGB(255,0,0)); DrawText(hdc, TEXT(firstText), -1,&rect, DT_NOCLIP); EndPaint(hWnd, &Ps); } break; case WM_CTLCOLOREDIT: { HDC hdc = (HDC)wParam; HWND hwnd = (HWND)lParam; HBRUSH color; if (GetDlgCtrlID(hwnd) == INPUT_TEXT_ADD_FOOD) { color = CreateSolidBrush(RGB(225, 225, 225)); SetTextColor(hdc, RGB(0, 0, 255)); SetBkMode(hdc, TRANSPARENT); SetBkColor(hdc,(LONG)color); } return (LONG) color; } break; case WM_COMMAND: { switch(LOWORD(wParam)) { case BUTTON_ADD_FOOD: { char buffer[256]; SendMessage(hInputFood, WM_GETTEXT, sizeof(buffer)/sizeof(buffer[0]), reinterpret_cast<LPARAM>(buffer)); if(strlen(buffer) > 0){ char newInput[255] = ""; char stat[30]; strcat(newInput, itoa((foodNumber+1), stat, 10) ); strcat(newInput, " ) "); strcat(newInput, buffer); strcat(newInput, "\r\n"); SendMessage(hFoodList, EM_REPLACESEL, FALSE, (LPARAM)newInput); SendMessage(hInputFood, WM_SETTEXT, NULL, (LPARAM)""); foodNumber++; InvalidateRect(hWnd, &updateRect, TRUE); } } break; case BUTTON_DISPLAY_FOOD_NR: { char buffer[255] = ""; switch(foodNumber){ case 0:http://pastebin.com/62fGU90U case 1: case 2: case 3: strcat(buffer, "You are not hungry at all"); break; case 4: case 5: case 6: strcat(buffer, "I see you are hungry now"); break; default: strcat(buffer, "You are starvin... go get something to eat"); break; } MessageBox(NULL, buffer, "Funny", MB_ICONINFORMATION); } break; } } break; case WM_SIZE: { INT nWidth = LOWORD(lParam); HWND hFunnyButton = GetDlgItem(hWnd, BUTTON_DISPLAY_FOOD_NR); MoveWindow(hFunnyButton, 10, 180, nWidth - 17, 40, TRUE); HWND hShowFoodInput = GetDlgItem(hWnd, INPUT_TEXT_SHOW_FOOD); HWND hAddFood = GetDlgItem(hWnd, INPUT_TEXT_ADD_FOOD); MoveWindow(hShowFoodInput, 10, 40, nWidth - 18, 100, TRUE); MoveWindow(hAddFood, 120, 150, nWidth - 128, 25, TRUE); } break; case WM_GETMINMAXINFO: { MINMAXINFO * mmiStruct; mmiStruct = (MINMAXINFO*)lParam; POINT ptPoint; ptPoint.x = 335; //Minimum width of the window. ptPoint.y = 260; //Minimum height of the window. mmiStruct->ptMinTrackSize = ptPoint; ptPoint.x = GetSystemMetrics(SM_CXMAXIMIZED); //Maximum width of the window. ptPoint.y = GetSystemMetrics(SM_CYMAXIMIZED); //Maximum height of the window. mmiStruct->ptMaxTrackSize = ptPoint; } break; case WM_DESTROY: { PostQuitMessage(0); return 0; } break; } return DefWindowProc(hWnd,msg,wParam,lParam); }
VOID jcwin32::jcwin32_exit(INT exitCode) { PostQuitMessage(exitCode); }
void OnDestroy() { PostQuitMessage(0); }
// // FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM) // // PURPOSE: Processes messages for the main window. // // WM_COMMAND - process the application menu // WM_PAINT - Paint the main window // WM_DESTROY - post a quit message and return // // LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { int wmId, wmEvent; int mX, mY; PAINTSTRUCT ps; HDC hdc; ::GetClientRect(hWnd, &winRect); WorldRenderer worldHandle(hWnd, hdc, winRect, player); /* */ switch (message) { case WM_COMMAND: wmId = LOWORD(wParam); wmEvent = HIWORD(wParam); // Parse the menu selections: switch (wmId) { case IDM_ABOUT: DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About); break; case IDM_EXIT: DestroyWindow(hWnd); break; default: return DefWindowProc(hWnd, message, wParam, lParam); } break; case WM_PAINT: hdc = BeginPaint(hWnd, &ps); worldHandle.update(playerAct); EndPaint(hWnd, &ps); break; case WM_MOUSEMOVE: // 부드럽게 보이기 위해서는 잔상처리를 그대로 하는 게 더 부드럽게 보임 // 잔상처리를 안할경우 화면이 번쩍거리는 현상이 보이게 됨 mX = LOWORD(lParam); // x coordinate mY = HIWORD(lParam); // y coordinate /* */ switch (wParam){ case MK_LBUTTON: if (player.moveFlag == true){ player.pos = worldHandle.getPlayerCoordinate(mX, mY); player.curpos = { mX, mY }; if (worldHandle.isCurInside(player)){ player.obj = worldHandle.getTileCoordnate(mX, mY); hdc = ::GetDC(hWnd); ::Ellipse(hdc, player.obj.left, player.obj.top, player.obj.right, player.obj.bottom); ::ReleaseDC(hWnd, hdc); playerAct = true; } else if (playerAct){ hdc = ::GetDC(hWnd); ::Ellipse(hdc, player.obj.left, player.obj.top, player.obj.right, player.obj.bottom); ::ReleaseDC(hWnd, hdc); } else{ // } } break; } /* */ break; case WM_LBUTTONUP: InvalidateRect(hWnd, NULL, true); break; case WM_LBUTTONDOWN: mX = LOWORD(lParam); // x coordinate mY = HIWORD(lParam); // y coordinate //test if (player.pos.x == worldHandle.getPlayerCoordinate(mX, mY).x && player.pos.y == worldHandle.getPlayerCoordinate(mX, mY).y){ player.moveFlag = true; } else { player.moveFlag = false; } // player.pos = worldHandle.getPlayerCoordinate(mX, mY); player.curpos = { mX, mY }; if ( worldHandle.isCurInside(player) ){ player.obj = worldHandle.getTileCoordnate(mX, mY); InvalidateRect(hWnd, NULL, true); playerAct = true; } else if(playerAct){ InvalidateRect(hWnd, NULL, true); } else{ playerAct = false; } break; case WM_DESTROY: PostQuitMessage(0); break; default: return DefWindowProc(hWnd, message, wParam, lParam); } return 0; }
LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { static HWND hwndList, hwndText ; int iIndex, iLength, cxChar, cyChar ; TCHAR * pVarName, * pVarValue ; switch (message) { case WM_CREATE : cxChar = LOWORD (GetDialogBaseUnits ()) ; cyChar = HIWORD (GetDialogBaseUnits ()) ; // Create listbox and static text windows. hwndList = CreateWindow (TEXT ("listbox"), NULL, WS_CHILD | WS_VISIBLE | LBS_STANDARD, cxChar, cyChar * 3, cxChar * 16 + GetSystemMetrics (SM_CXVSCROLL), cyChar * 5, hwnd, (HMENU) ID_LIST, (HINSTANCE) GetWindowLong (hwnd, GWL_HINSTANCE), NULL) ; hwndText = CreateWindow (TEXT ("static"), NULL, WS_CHILD | WS_VISIBLE | SS_LEFT, cxChar, cyChar, GetSystemMetrics (SM_CXSCREEN), cyChar, hwnd, (HMENU) ID_TEXT, (HINSTANCE) GetWindowLong (hwnd, GWL_HINSTANCE), NULL) ; FillListBox (hwndList) ; return 0 ; case WM_SETFOCUS : SetFocus (hwndList) ; return 0 ; case WM_COMMAND : if (LOWORD (wParam) == ID_LIST && HIWORD (wParam) == LBN_SELCHANGE) { // Get current selection. iIndex = SendMessage (hwndList, LB_GETCURSEL, 0, 0) ; iLength = SendMessage (hwndList, LB_GETTEXTLEN, iIndex, 0) + 1 ; pVarName = calloc (iLength, sizeof (TCHAR)) ; SendMessage (hwndList, LB_GETTEXT, iIndex, (LPARAM) pVarName) ; // Get environment string. iLength = GetEnvironmentVariable (pVarName, NULL, 0) ; pVarValue = calloc (iLength, sizeof (TCHAR)) ; GetEnvironmentVariable (pVarName, pVarValue, iLength) ; // Show it in window. SetWindowText (hwndText, pVarValue) ; free (pVarName) ; free (pVarValue) ; } return 0 ; case WM_DESTROY : PostQuitMessage (0) ; return 0 ; } return DefWindowProc (hwnd, message, wParam, lParam) ; }
LRESULT CALLBACK window_procedure(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { switch(msg) { case WM_CREATE: { game.create_dc(GetDC(hWnd)); int resolution_x = GetSystemMetrics(SM_CXSCREEN), resolution_y = GetSystemMetrics(SM_CYSCREEN); RECT window_rectangle; GetWindowRect(hWnd, &window_rectangle); int width = window_rectangle.right - window_rectangle.left, height = window_rectangle.bottom - window_rectangle.top; SetWindowPos(hWnd, HWND_TOP, (resolution_x - width) / 2, (resolution_y - height) / 2, 0, 0, SWP_NOSIZE); break; } case WM_ERASEBKGND: return 1; case WM_PAINT: game.process_frame(hWnd); break; /* case WM_TIMER: game.invalidate(hWnd); break; case WM_ERASEBKGND: return 1; case WM_PAINT: try { game_mutex.lock(); game.process_frame(hWnd); game_mutex.unlock(); } catch(std::exception const & exception) { MessageBox(hWnd, (std::string("The following exception has occured:\n\n\t") + exception.what() + "\n\nTerminating program.").c_str(), "Exception", MB_OK | MB_ICONERROR); run_timer = false; PostQuitMessage(WM_QUIT); } break; */ case WM_CLOSE: case WM_DESTROY: run = false; PostQuitMessage(WM_QUIT); break; case WM_LBUTTONDOWN: return DefWindowProc(hWnd, WM_NCLBUTTONDOWN, HTCAPTION, 0); case WM_KEYDOWN: game.process_key_down(wParam); break; case WM_KEYUP: game.process_key_up(wParam); break; } return DefWindowProc(hWnd, msg, wParam, lParam); }
void OnCommand(HWND hWnd, WPARAM wParam, LPARAM lParam) { if (wParam == IDM_LOCK_NOW) { Lock(hWnd); } else if (wParam == IDM_BLACK_SCREEN) { CheckMenuRadioItem(g_hTrayMenu, IDM_BLACK_SCREEN, IDM_SCREENSHOT, IDM_BLACK_SCREEN, MF_BYCOMMAND); g_enumMode = Black; } else if (wParam == IDM_TRANSPARENT) { CheckMenuRadioItem(g_hTrayMenu, IDM_BLACK_SCREEN, IDM_SCREENSHOT, IDM_TRANSPARENT, MF_BYCOMMAND); g_enumMode = Transparent; } else if (wParam == IDM_TRANSPARENT_50) { CheckMenuRadioItem(g_hTrayMenu, IDM_BLACK_SCREEN, IDM_SCREENSHOT, IDM_TRANSPARENT_50, MF_BYCOMMAND); g_enumMode = Transparent50; } if (wParam == IDM_SCREENSHOT) { CheckMenuRadioItem(g_hTrayMenu, IDM_BLACK_SCREEN, IDM_SCREENSHOT, IDM_SCREENSHOT, MF_BYCOMMAND); g_enumMode = Screenshot; } if (wParam == IDM_AUTO_LOCK) { CheckMenuItem(g_hTrayMenu, IDM_AUTO_LOCK, MF_BYCOMMAND | (!g_bAutoLock ? MF_CHECKED : MF_UNCHECKED)); g_bAutoLock = !g_bAutoLock; } else if (wParam == IDM_SET_PASSWORD) { // 1. If HKCU\Software\ScreenLock does not exist, display the set password window // 2. If HKCU\Software\ScreenLock\Password does not exist, display the set password window // 3. Otherwise, display the modify password window HKEY hScreenLockKey; if (RegOpenKeyEx(HKEY_CURRENT_USER, "Software\\ScreenLock", 0, KEY_QUERY_VALUE, &hScreenLockKey) != 0) // Key not exist { RegCloseKey(hScreenLockKey); DialogBoxParam(g_hInstance, "DLG_SET_PASSWORD", hWnd, ProcDlgSetPassword, 0); } else if (RegGetValue(hScreenLockKey, 0, "Password", RRF_RT_REG_SZ, 0, 0, 0) != 0) // Value not exist { RegCloseKey(hScreenLockKey); DialogBoxParam(g_hInstance, "DLG_SET_PASSWORD", hWnd, ProcDlgSetPassword, 0); } else { DialogBoxParam(g_hInstance, "DLG_MODIFY_PASSWORD", hWnd, ProcDlgModifyPassword, 0); } } else if (wParam == IDM_SET_TIMEOUT) { DialogBoxParam(g_hInstance, "DLG_SET_TIMEOUT", hWnd, ProcDlgSetTimeout, 0); } else if (wParam == IDM_EXIT) { // Delete Tray Icon NOTIFYICONDATA nti; nti.hIcon = LoadIcon(g_hInstance, MAKEINTRESOURCE(ICO_MAIN)); nti.uFlags = NIF_ICON | NIF_TIP | NIF_MESSAGE; nti.hWnd = hWnd; nti.uID = 0; nti.uCallbackMessage = WM_USER_TRAY; strcpy_s(nti.szTip, sizeof(nti.szTip), "Screen Locker"); Shell_NotifyIcon(NIM_DELETE, &nti); // Exit PostQuitMessage(0); } }
LRESULT WINAPI WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam){ LRESULT lRet = 1; int wmId, wmEvent; PAINTSTRUCT ps; HDC hdc; switch (uMsg){ case WM_CREATE: break; case WM_PAINT: ValidateRect(g_wnd, NULL); break; case WM_DESTROY: PostQuitMessage(0); break; case WM_CHAR: break; case WM_LBUTTONDOWN: { POINT ptMouse; GetCursorPos(&ptMouse); ScreenToClient(g_wnd, &ptMouse); g_ptLastPoint = ptMouse; } break; case WM_RBUTTONDOWN: { GetCursorPos(&g_ptLastPoint); ScreenToClient(g_wnd, &g_ptLastPoint); break; } case WM_MOUSEMOVE: { switch (wParam) { case MK_LBUTTON: { } break; case MK_RBUTTON: { POINT pt; pt.x = LOWORD(lParam); pt.y = HIWORD(lParam); g_camera->SetRotAngleDelta((pt.y - g_ptLastPoint.y) / 150.0f, (pt.x - g_ptLastPoint.x) / 150.0f, 0.0f); g_ptLastPoint = pt; } default: break; } break; } case WM_KEYDOWN: { Vector *vcDirc = new Vector(); Vector *vcUp = new Vector(); Vector *vcRight = new Vector(); g_camera->GetDirection(vcDirc, vcUp, vcRight); switch (wParam) { case VK_A: { g_camera->SetMoveDirection(*vcRight); g_camera->SetMoveDelta(-20.0f); g_camera->Update(); Matrix matView; g_camera->GetViewMatrix(&matView); break; } case VK_D: { Vector vcPosCamera; g_camera->SetMoveDirection(*vcRight); g_camera->SetMoveDelta(20.0f); g_camera->Update(); Matrix matView; g_camera->GetViewMatrix(&matView); break; } case VK_W: { g_camera->SetMoveDirection(*vcDirc); g_camera->SetMoveDelta(20.0f); g_camera->Update(); Matrix matView; g_camera->GetViewMatrix(&matView); break; } case VK_S: { g_camera->SetMoveDirection(*vcDirc); g_camera->SetMoveDelta(-20.0f); g_camera->Update(); Matrix matView; g_camera->GetViewMatrix(&matView); break; } case VK_Q: { g_camera->SetMoveDirection(*vcUp); g_camera->SetMoveDelta(20.0f); g_camera->Update(); Matrix matView; g_camera->GetViewMatrix(&matView); break; } case VK_E: { g_camera->SetMoveDirection(*vcUp); g_camera->SetMoveDelta(-20.0f); g_camera->Update(); Matrix matView; g_camera->GetViewMatrix(&matView); break; } default: break; } g_camera->Update(); Matrix viewMat; viewMat.Identity(); g_camera->GetViewMatrix(&viewMat); } break; default: lRet = DefWindowProc(hWnd, uMsg, wParam, lParam); break; } return lRet; }
LRESULT CALLBACK WndProc( HWND hWnd, // Handle For This Window UINT uMsg, // Message For This Window WPARAM wParam, // Additional Message Information LPARAM lParam) // Additional Message Information { switch (uMsg) // Check For Windows Messages { case WM_ACTIVATE: // Watch For Window Activate Message { if (!HIWORD(wParam)) // Check Minimization State { active=TRUE; // Program Is Active } else { active=FALSE; // Program Is No Longer Active } return 0; // Return To The Message Loop } case WM_SYSCOMMAND: // Intercept System Commands { switch (wParam) // Check System Calls { case SC_SCREENSAVE: // Screensaver Trying To Start? case SC_MONITORPOWER: // Monitor Trying To Enter Powersave? return 0; // Prevent From Happening } break; // Exit } case WM_CLOSE: // Did We Receive A Close Message? { PostQuitMessage(0); // Send A Quit Message return 0; // Jump Back } case WM_LBUTTONDOWN: { gleft=TRUE; return 0; } case WM_LBUTTONUP: { gleft=FALSE; return 0; } case WM_RBUTTONDOWN: { gright=TRUE; return 0; } case WM_RBUTTONUP: { gright=FALSE; return 0; } case WM_KEYDOWN: // Is A Key Being Held Down? { keys[wParam] = TRUE; // If So, Mark It As TRUE return 0; // Jump Back } case WM_KEYUP: // Has A Key Been Released? { keys[wParam] = FALSE; // If So, Mark It As FALSE return 0; // Jump Back } case WM_SIZE: // Resize The OpenGL Window { b1.ReSizeGLScene(LOWORD(lParam),HIWORD(lParam)); // LoWord=Width, HiWord=Height return 0; // Jump Back } case WM_MOUSEMOVE: { mousex=LOWORD(lParam); mousey=HIWORD(lParam); return 0; } } // Pass All Unhandled Messages To DefWindowProc return DefWindowProc(hWnd,uMsg,wParam,lParam); }
static LRESULT CALLBACK WndProc(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam) { switch (uMessage) { case WM_PAINT: { PAINTSTRUCT ps; BeginPaint(hwnd, &ps); SetMapMode(ps.hdc, MM_ANISOTROPIC); /* Set the window extent to a sane value in case the metafile doesn't */ SetWindowExtEx(ps.hdc, width, height, NULL); SetViewportExtEx(ps.hdc, width, height, NULL); SetViewportOrgEx(ps.hdc, deltax, deltay, NULL); if (isEnhanced && enhmf) { RECT r; GetClientRect(hwnd, &r); PlayEnhMetaFile(ps.hdc, enhmf, &r); } else if (hmf) PlayMetaFile(ps.hdc, hmf); EndPaint(hwnd, &ps); } break; case WM_COMMAND: /* message: command from application menu */ switch (LOWORD(wparam)) { case IDM_OPEN: { WCHAR filename[MAX_PATH]; if (FileOpen(hwnd, filename, sizeof(filename)/sizeof(WCHAR))) { szFileTitle[0] = 0; GetFileTitleW(filename, szFileTitle, sizeof(szFileTitle)/sizeof(WCHAR)); DoOpenFile(filename); UpdateWindowCaption(); } } break; case IDM_SET_EXT_TO_WIN: { RECT r; GetClientRect(hwnd, &r); width = r.right - r.left; height = r.bottom - r.top; deltax = deltay = 0; InvalidateRect( hwnd, NULL, TRUE ); } break; case IDM_LEFT: deltax += 100; InvalidateRect( hwnd, NULL, TRUE ); break; case IDM_RIGHT: deltax -= 100; InvalidateRect( hwnd, NULL, TRUE ); break; case IDM_UP: deltay += 100; InvalidateRect( hwnd, NULL, TRUE ); break; case IDM_DOWN: deltay -= 100; InvalidateRect( hwnd, NULL, TRUE ); break; case IDM_EXIT: DestroyWindow(hwnd); break; default: return DefWindowProcW(hwnd, uMessage, wparam, lparam); } break; case WM_DESTROY: /* message: window being destroyed */ PostQuitMessage(0); break; default: /* Passes it on if unprocessed */ return DefWindowProcW(hwnd, uMessage, wparam, lparam); } return 0; }
LRESULT CALLBACK MainWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { // Window dimensions RECT rWnd; RECT rClt; switch (uMsg) { case WM_CREATE: // Get the window and client dimensions GetWindowRect(hWnd, &rWnd); GetClientRect(hWnd, &rClt); // Calculate desired window width and height int border = (rWnd.right - rWnd.left) - rClt.right; int width = WIDTH + border; int height = HEIGHT; // Set new dimensions SetWindowPos(hWnd, NULL, 0, 0, width, height, SWP_NOMOVE | SWP_NOZORDER); // Get client dimensions GetWindowRect(hWnd, &rWnd); GetClientRect(hWnd, &rClt); width = rClt.right - rClt.left; height = rClt.bottom - rClt.top; // Create scale scale.hwnd = CreateWindow(WC_STATIC, NULL, WS_VISIBLE | WS_CHILD | SS_NOTIFY | SS_OWNERDRAW, 8, 8, 160, 40, hWnd, (HMENU)SCALE_ID, hInst, NULL); // Create tooltip tooltip.hwnd = CreateWindow(TOOLTIPS_CLASS, NULL, WS_POPUP | TTS_ALWAYSTIP, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, hWnd, NULL, hInst, NULL); SetWindowPos(tooltip.hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE); // Add scale to tooltip tooltip.info.cbSize = sizeof(tooltip.info); tooltip.info.hwnd = hWnd; tooltip.info.uFlags = TTF_IDISHWND | TTF_SUBCLASS; tooltip.info.uId = (UINT_PTR)scale.hwnd; tooltip.info.lpszText = "Frequency scale"; SendMessage(tooltip.hwnd, TTM_ADDTOOL, 0, (LPARAM) &tooltip.info); // Create display display.hwnd = CreateWindow(WC_STATIC, NULL, WS_VISIBLE | WS_CHILD | SS_NOTIFY | SS_OWNERDRAW, 176, 8, 136, 60, hWnd, (HMENU)DISPLAY_ID, hInst, NULL); // Add display to tooltip tooltip.info.uId = (UINT_PTR)display.hwnd; tooltip.info.lpszText = "Frequency and level display"; SendMessage(tooltip.hwnd, TTM_ADDTOOL, 0, (LPARAM) &tooltip.info); // Create knob knob.hwnd = CreateWindow(KNOBCLASS, NULL, WS_VISIBLE | WS_CHILD, 4, 52, 168, 168, hWnd, (HMENU)KNOB_ID, hInst, NULL); // Add knob to tooltip tooltip.info.uId = (UINT_PTR)knob.hwnd; tooltip.info.lpszText = "Frequency adjustment knob"; SendMessage(tooltip.hwnd, TTM_ADDTOOL, 0, (LPARAM) &tooltip.info); // Create frequency slider fine.hwnd = CreateWindow(TRACKBAR_CLASS, NULL, WS_VISIBLE | WS_CHILD | TBS_VERT | TBS_NOTICKS, 176, 76, 24, 140, hWnd, (HMENU)FINE_ID, hInst, NULL); SendMessage(fine.hwnd, TBM_SETRANGE, TRUE, MAKELONG(FINE_MIN, FINE_MAX)); SendMessage(fine.hwnd, TBM_SETPAGESIZE, 0, FINE_STEP); SendMessage(fine.hwnd, TBM_SETPOS, TRUE, FINE_REF); // Add slider to tooltip tooltip.info.uId = (UINT_PTR)fine.hwnd; tooltip.info.lpszText = "Fine frequency adjustment"; SendMessage(tooltip.hwnd, TTM_ADDTOOL, 0, (LPARAM) &tooltip.info); // Create level slider level.hwnd = CreateWindow(TRACKBAR_CLASS, NULL, WS_VISIBLE | WS_CHILD | TBS_VERT | TBS_NOTICKS | TBS_LEFT, 208, 76, 24, 140, hWnd, (HMENU)LEVEL_ID, hInst, NULL); SendMessage(level.hwnd, TBM_SETRANGE, TRUE, MAKELONG(LEVEL_MIN, LEVEL_MAX)); SendMessage(level.hwnd, TBM_SETPAGESIZE, 0, LEVEL_STEP); SendMessage(level.hwnd, TBM_SETPOS, TRUE, LEVEL_REF); // Add slider to tooltip tooltip.info.uId = (UINT_PTR)level.hwnd; tooltip.info.lpszText = "Level adjustment"; SendMessage(tooltip.hwnd, TTM_ADDTOOL, 0, (LPARAM) &tooltip.info); // Create sine button buttons.sine.hwnd = CreateWindow(WC_BUTTON, "Sine", WS_VISIBLE | WS_CHILD | WS_GROUP | BS_AUTORADIOBUTTON | BS_PUSHLIKE, 240, 76, 72, 24, hWnd, (HMENU)SINE_ID, hInst, NULL); SendMessage(buttons.sine.hwnd, BM_SETCHECK, BST_CHECKED, 0); // Create square button buttons.square.hwnd = CreateWindow(WC_BUTTON, "Square", WS_VISIBLE | WS_CHILD | BS_AUTORADIOBUTTON | BS_PUSHLIKE, 240, 105, 72, 24, hWnd, (HMENU)SQUARE_ID, hInst, NULL); // Create sawtooth button buttons.sawtooth.hwnd = CreateWindow(WC_BUTTON, "Sawtooth", WS_VISIBLE | WS_CHILD | BS_AUTORADIOBUTTON | BS_PUSHLIKE, 240, 134, 72, 24, hWnd, (HMENU)SAWTOOTH_ID, hInst, NULL); // Create mute button buttons.mute.hwnd = CreateWindow(WC_BUTTON, "Mute", WS_VISIBLE | WS_CHILD | BS_AUTOCHECKBOX | BS_PUSHLIKE, 240, 161, 72, 24, hWnd, (HMENU)MUTE_ID, hInst, NULL); // Create quit button buttons.quit.hwnd = CreateWindow(WC_BUTTON, "Quit", WS_VISIBLE | WS_CHILD, 240, 192, 72, 24, hWnd, (HMENU)QUIT_ID, hInst, NULL); // Create status bar status.hwnd = CreateWindow(STATUSCLASSNAME, " Turn knob to adjust frequency," " fine left, level right slider", WS_VISIBLE | WS_CHILD, 0, 0, 0, 0, hWnd, (HMENU)STATUS_ID, hInst, NULL); // Start audio thread audio.thread = CreateThread(NULL, 0, AudioThread, hWnd, 0, &audio.id); break; // Colour static text case WM_CTLCOLORSTATIC: return (LRESULT)GetSysColorBrush(COLOR_WINDOW); break; // Draw item case WM_DRAWITEM: return DrawItem(wParam, lParam); break; // Disable menus by capturing this message case WM_INITMENU: break; // Capture system character key to stop pop up menus and other // nonsense case WM_SYSCHAR: break; // Char pressed case WM_CHAR: CharPressed(wParam, lParam); break; // Key pressed case WM_KEYDOWN: KeyDown(wParam, lParam); break; // Buttons case WM_COMMAND: switch (LOWORD(wParam)) { // Sine case SINE_ID: audio.waveform = SINE; break; // Square case SQUARE_ID: audio.waveform = SQUARE; break; // Sawtooth case SAWTOOTH_ID: audio.waveform = SAWTOOTH; break; // Mute case MUTE_ID: audio.mute = SendMessage((HWND)lParam, BM_GETCHECK, 0, 0); break; // Quit case QUIT_ID: waveOutReset(audio.hwo); waveOutClose(audio.hwo); PostQuitMessage(0); break; } // Set the focus back to the window SetFocus(hWnd); break; // Slider change case WM_VSCROLL: SliderChange(wParam, lParam); // Set the focus back to the window SetFocus(hWnd); break; // Set the focus back to the window by clicking case WM_LBUTTONDOWN: case WM_MBUTTONDOWN: SetFocus(hWnd); break; case WM_RBUTTONDOWN: // Not used break; // Notify case WM_NOTIFY: switch (((LPNMHDR)lParam)->code) { // Tooltip case TTN_SHOW: TooltipShow(wParam, lParam); break; case TTN_POP: TooltipPop(wParam, lParam); break; } break; // Process other messages. case WM_DESTROY: PostQuitMessage(0); waveOutReset(audio.hwo); waveOutClose(audio.hwo); break; // Everything else default: return DefWindowProc(hWnd, uMsg, wParam, lParam); } return 0; }
LRESULT CALLBACK WndProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam) { struct WindowData *data=window_data(); // WindowHandle handle = (WindowHandle)GetWindowLong(hWnd,GWL_USERDATA); if(!data->created) { return DefWindowProc(hWnd,message,wParam,lParam); } else if(message==WM_INPUT) { // UINT dwSize = 40; // static BYTE lpb[40]; // GetRawInputData((HRAWINPUT)lParam,RID_INPUT,lpb,&dwSize,sizeof(RAWINPUTHEADER)); // RAWINPUT* raw = (RAWINPUT*)lpb; RAWINPUT raw; UINT DataSize = sizeof(RAWINPUT); GetRawInputData((HRAWINPUT)lParam, RID_INPUT, &raw, &DataSize, sizeof(RAWINPUTHEADER)); if(raw.header.dwType == RIM_TYPEMOUSE) { if(raw.data.mouse.usButtonFlags & RI_MOUSE_WHEEL) { data->mouseZ=(int)raw.data.mouse.usButtonData; } else if(raw.data.mouse.usButtonFlags & RI_MOUSE_LEFT_BUTTON_DOWN) { data->inputs[WINDOW_MOUSE_LEFT]=WINDOW_INPUT_PRESS; } else if(raw.data.mouse.usButtonFlags & RI_MOUSE_LEFT_BUTTON_UP && data->inputs[WINDOW_MOUSE_LEFT]!=WINDOW_INPUT_UP) { data->inputs[WINDOW_MOUSE_LEFT]=WINDOW_INPUT_RELEASE; } else if(raw.data.mouse.usButtonFlags & RI_MOUSE_RIGHT_BUTTON_DOWN) { data->inputs[WINDOW_MOUSE_RIGHT]=WINDOW_INPUT_PRESS; } else if(raw.data.mouse.usButtonFlags & RI_MOUSE_RIGHT_BUTTON_UP && data->inputs[WINDOW_MOUSE_RIGHT]!=WINDOW_INPUT_UP) { data->inputs[WINDOW_MOUSE_RIGHT]=WINDOW_INPUT_RELEASE; } else if(raw.data.mouse.usButtonFlags & RI_MOUSE_MIDDLE_BUTTON_DOWN) { data->inputs[WINDOW_MOUSE_MIDDLE]=WINDOW_INPUT_PRESS; } else if(raw.data.mouse.usButtonFlags & RI_MOUSE_MIDDLE_BUTTON_UP && data->inputs[WINDOW_MOUSE_MIDDLE]!=WINDOW_INPUT_UP) { data->inputs[WINDOW_MOUSE_MIDDLE]=WINDOW_INPUT_RELEASE; } data->mouseX=(int)raw.data.mouse.lLastX; data->mouseY=(int)raw.data.mouse.lLastY; } else if(raw.header.dwType == RIM_TYPEKEYBOARD) { USHORT vk=raw.data.keyboard.VKey; USHORT up=raw.data.keyboard.Flags & RI_KEY_BREAK; USHORT right=raw.data.keyboard.Flags & RI_KEY_E0; if(up && data->inputs[window_key_convert(vk)]!=WINDOW_INPUT_UP) { data->inputs[window_key_convert(vk)]=WINDOW_INPUT_RELEASE; }else if(!up) { data->inputs[window_key_convert(vk)]=WINDOW_INPUT_PRESS; } } } else if(message==WM_DESTROY) { PostQuitMessage(0); return 0; } else if(message==WM_SIZE) { //data->clientWidth=(int)LOWORD(lParam); //data->clientHeight=(int)HIWORD(lParam); data->sized=true; data->iconified=(wParam==SIZE_MINIMIZED); } else if(message==WM_KILLFOCUS) { data->focused=false; } else if(message==WM_SETFOCUS) { data->focused=true; } else { return DefWindowProc(hWnd,message,wParam,lParam); } return 0; }
LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { static int cxChar, cxCaps, cyChar, cyClient, iVscrollPos ; HDC hdc ; int i, y ; PAINTSTRUCT ps ; // TCHAR szBuffer[10] ; TEXTMETRIC tm ; static int LoadDLLTag=0; static int poehackTag=0; static BOOL show_flag=TRUE; switch (message) { case WM_LBUTTONDOWN: if(LoadDLLTag==1) { show_flag=!show_flag; InvalidateRect (hwnd, NULL, TRUE) ; return 0; } LoadDLLTag=1; PoeIntercept(hwnd); /* typedef void(*pExecute)(DWORD); pExecute p; p=(pExecute)GetProcAddress(poehackModule,"Execute"); if(p) p((DWORD)hwnd); */ return 0; case WM_RBUTTONDOWN: if(poehackTag==1){ return 0; } char dllFullName[10240]; GetCurrentDirectory(255, dllFullName); strcpy(dllFullName, "c:\\bot\\d3\\poehack.dll"); poehackModule = LoadLibrary(dllFullName); if(!poehackModule) _showinfo("poehack load failed: %s",dllFullName); else { _showinfo("poehack loaded"); poehackTag=1; } if(!_PassValueAddr) _PassValueAddr=(pPassValue)GetProcAddress(poehackModule,"PassValue"); _showinfo("_PassValueAddr %x",_PassValueAddr); return 0; case WM_MBUTTONDOWN: if(poehackTag==0) return 0; _value.id = DO_UNLOAD; if(_PassValueAddr) _PassValueAddr(&_value); /* typedef void(*pUnload)(); pUnload p; p=(pUnload)GetProcAddress(poehackModule,"Unload"); if(p) p(); */ FreeLibrary(poehackModule); poehackModule=NULL; _PassValueAddr=NULL; _showinfo("poehack unloaded"); poehackTag=0; return 0; case WM_CREATE: hdc = GetDC (hwnd) ; GetTextMetrics (hdc, &tm) ; cxChar = tm.tmAveCharWidth ; cxCaps = (tm.tmPitchAndFamily & 1 ? 3 : 2) * cxChar / 2 ; cyChar = tm.tmHeight + tm.tmExternalLeading ; ReleaseDC (hwnd, hdc) ; SetScrollRange (hwnd, SB_VERT, 0, NUMLINES - 1, FALSE) ; SetScrollPos (hwnd, SB_VERT, iVscrollPos, TRUE) ; _window_up=TRUE; return 0 ; case WM_SIZE: cyClient = HIWORD (lParam) ; return 0 ; case WM_VSCROLL: switch (LOWORD (wParam)) { case SB_LINEUP: iVscrollPos -= 1 ; break ; case SB_LINEDOWN: iVscrollPos += 1 ; break ; case SB_PAGEUP: iVscrollPos -= cyClient / cyChar ; break ; case SB_PAGEDOWN: iVscrollPos += cyClient / cyChar ; break ; case SB_THUMBPOSITION: iVscrollPos = HIWORD (wParam) ; break ; default : break ; } iVscrollPos = max (0, min (iVscrollPos, NUMLINES - 1)) ; if (iVscrollPos != GetScrollPos (hwnd, SB_VERT)) { SetScrollPos (hwnd, SB_VERT, iVscrollPos, TRUE) ; InvalidateRect (hwnd, NULL, TRUE) ; } return 0 ; case WM_PAINT: if(show_flag) { hdc = BeginPaint (hwnd, &ps) ; for (i = 0 ; i < NUMLINES ; i++) { int len= strlen (display_buf[i].text) ; if(len==0) continue; y = cyChar * (i - iVscrollPos) ; TextOut (hdc, 0, y, display_buf[i].text, strlen (display_buf[i].text)) ; } EndPaint (hwnd, &ps) ; } else { typedef void(*pDrawMap)(HWND); pDrawMap p; p=(pDrawMap)GetProcAddress(poehackModule,"DrawMap"); if(p) p(hwnd); } return 0 ; case WM_DESTROY: _window_up=FALSE; PostQuitMessage (0) ; return 0 ; } return DefWindowProc (hwnd, message, wParam, lParam) ; }
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { PAINTSTRUCT ps; HDC hdc; RECT rect; COLORREF colorText = RGB(0, 0, 255); // задаём цвет текста switch (message) { case WM_COMMAND: case BN_CLICKED: if (LOWORD(wParam) == ID_BUTTON1) { GetClientRect(hWnd, &rect); edit1 = CreateWindowEx( WS_EX_CLIENTEDGE, L"edit", L"Нажмите правую клавишу мыши", WS_CHILD | WS_VISIBLE | EM_FMTLINES, rect.right / 4, /*координаты по X*/ rect.bottom / 4, /*координаты по Y*/ rect.right / 2, /*Ширина окошка*/ rect.bottom / 2, hWnd, (HMENU)ID_EDIT1, hinst, NULL); } break; case WM_RBUTTONDOWN: ShowWindow(edit1, SW_HIDE); break; case WM_CREATE: GetClientRect(hWnd, &rect); button1 = CreateWindowEx( WS_EX_CLIENTEDGE, L"button", L"Показать", WS_CHILD | WS_VISIBLE, rect.right / 2 - ARRAYSIZE(L"Показать") * 4 - 10, /*координаты по X*/ rect.bottom - 30, /*координаты по Y*/ ARRAYSIZE(L"Показать") * 10, /*Ширина окошка*/ 25, hWnd, (HMENU)ID_BUTTON1, hinst, NULL); break; case WM_PAINT: hdc = BeginPaint(hWnd, &ps); // инициализируем контекст устройства GetClientRect(hWnd, &rect); // получаем ширину и высоту области для рисования SetTextColor(hdc, colorText); // устанавливаем цвет контекстного устройства DrawText(hdc, L"В в е д и т е т е к с т", -1, &rect, DT_SINGLELINE | DT_CENTER); // рисуем текст break; case WM_DESTROY: PostQuitMessage(0); break; default: return DefWindowProc(hWnd, message, wParam, lParam); break; } return 0; }
// // FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM) // // PURPOSE: Processes messages for the main window. // LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { static HWND backWnd = NULL, forwardWnd = NULL, reloadWnd = NULL, stopWnd = NULL, editWnd = NULL; static WNDPROC editWndOldProc = NULL; // Static members used for the find dialog. static FINDREPLACE fr; static WCHAR szFindWhat[80] = {0}; static WCHAR szLastFindWhat[80] = {0}; static bool findNext = false; static bool lastMatchCase = false; int wmId, wmEvent; PAINTSTRUCT ps; HDC hdc; #ifdef SHOW_TOOLBAR_UI if (hWnd == editWnd) { // Callback for the edit window switch (message) { case WM_CHAR: if (wParam == VK_RETURN && g_handler.get()) { // When the user hits the enter key load the URL CefRefPtr<CefBrowser> browser = g_handler->GetBrowser(); wchar_t strPtr[MAX_URL_LENGTH+1] = {0}; *((LPWORD)strPtr) = MAX_URL_LENGTH; LRESULT strLen = SendMessage(hWnd, EM_GETLINE, 0, (LPARAM)strPtr); if (strLen > 0) { strPtr[strLen] = 0; browser->GetMainFrame()->LoadURL(strPtr); } return 0; } } return (LRESULT)CallWindowProc(editWndOldProc, hWnd, message, wParam, lParam); } else #endif // SHOW_TOOLBAR_UI { // Callback for the main window switch (message) { case WM_CREATE: { // Create the single static handler class instance g_handler = new ClientHandler(); g_handler->SetMainHwnd(hWnd); // Create the child windows used for navigation RECT rect; int x = 0; GetClientRect(hWnd, &rect); #ifdef SHOW_TOOLBAR_UI backWnd = CreateWindow(L"BUTTON", L"Back", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_DISABLED, x, 0, BUTTON_WIDTH, URLBAR_HEIGHT, hWnd, (HMENU) IDC_NAV_BACK, hInst, 0); x += BUTTON_WIDTH; forwardWnd = CreateWindow(L"BUTTON", L"Forward", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_DISABLED, x, 0, BUTTON_WIDTH, URLBAR_HEIGHT, hWnd, (HMENU) IDC_NAV_FORWARD, hInst, 0); x += BUTTON_WIDTH; reloadWnd = CreateWindow(L"BUTTON", L"Reload", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_DISABLED, x, 0, BUTTON_WIDTH, URLBAR_HEIGHT, hWnd, (HMENU) IDC_NAV_RELOAD, hInst, 0); x += BUTTON_WIDTH; stopWnd = CreateWindow(L"BUTTON", L"Stop", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_DISABLED, x, 0, BUTTON_WIDTH, URLBAR_HEIGHT, hWnd, (HMENU) IDC_NAV_STOP, hInst, 0); x += BUTTON_WIDTH; editWnd = CreateWindow(L"EDIT", 0, WS_CHILD | WS_VISIBLE | WS_BORDER | ES_LEFT | ES_AUTOVSCROLL | ES_AUTOHSCROLL| WS_DISABLED, x, 0, rect.right - BUTTON_WIDTH * 4, URLBAR_HEIGHT, hWnd, 0, hInst, 0); // Assign the edit window's WNDPROC to this function so that we can // capture the enter key editWndOldProc = reinterpret_cast<WNDPROC>(GetWindowLongPtr(editWnd, GWLP_WNDPROC)); SetWindowLongPtr(editWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(WndProc)); g_handler->SetEditHwnd(editWnd); g_handler->SetButtonHwnds(backWnd, forwardWnd, reloadWnd, stopWnd); rect.top += URLBAR_HEIGHT; #endif // SHOW_TOOLBAR_UI CefWindowInfo info; CefBrowserSettings settings; // Populate the settings based on command line arguments. AppGetBrowserSettings(settings); settings.file_access_from_file_urls_allowed = true; settings.universal_access_from_file_urls_allowed = true; // Initialize window info to the defaults for a child window info.SetAsChild(hWnd, rect); // Creat the new child browser window CefBrowserHost::CreateBrowser(info, static_cast<CefRefPtr<CefClient> >(g_handler), szInitialUrl, settings); return 0; } case WM_COMMAND: { CefRefPtr<CefBrowser> browser; if (g_handler.get()) browser = g_handler->GetBrowser(); wmId = LOWORD(wParam); wmEvent = HIWORD(wParam); // Parse the menu selections: switch (wmId) { case IDM_EXIT: if (g_handler.get()) { g_handler->QuittingApp(true); g_handler->DispatchCloseToNextBrowser(); } else { DestroyWindow(hWnd); } return 0; case ID_WARN_CONSOLEMESSAGE: if (g_handler.get()) { std::wstringstream ss; ss << L"Console messages will be written to " << std::wstring(CefString(g_handler->GetLogFile())); MessageBox(hWnd, ss.str().c_str(), L"Console Messages", MB_OK | MB_ICONINFORMATION); } return 0; case ID_WARN_DOWNLOADCOMPLETE: case ID_WARN_DOWNLOADERROR: if (g_handler.get()) { std::wstringstream ss; ss << L"File \"" << std::wstring(CefString(g_handler->GetLastDownloadFile())) << L"\" "; if (wmId == ID_WARN_DOWNLOADCOMPLETE) ss << L"downloaded successfully."; else ss << L"failed to download."; MessageBox(hWnd, ss.str().c_str(), L"File Download", MB_OK | MB_ICONINFORMATION); } return 0; #ifdef SHOW_TOOLBAR_UI case IDC_NAV_BACK: // Back button if (browser.get()) browser->GoBack(); return 0; case IDC_NAV_FORWARD: // Forward button if (browser.get()) browser->GoForward(); return 0; case IDC_NAV_RELOAD: // Reload button if (browser.get()) browser->Reload(); return 0; case IDC_NAV_STOP: // Stop button if (browser.get()) browser->StopLoad(); return 0; #endif // SHOW_TOOLBAR_UI } break; } case WM_PAINT: hdc = BeginPaint(hWnd, &ps); EndPaint(hWnd, &ps); return 0; case WM_SETFOCUS: if (g_handler.get() && g_handler->GetBrowser()) { // Pass focus to the browser window CefWindowHandle hwnd = g_handler->GetBrowser()->GetHost()->GetWindowHandle(); if (hwnd) PostMessage(hwnd, WM_SETFOCUS, wParam, NULL); } return 0; case WM_SIZE: // Minimizing resizes the window to 0x0 which causes our layout to go all // screwy, so we just ignore it. if (wParam != SIZE_MINIMIZED && g_handler.get() && g_handler->GetBrowser()) { CefWindowHandle hwnd = g_handler->GetBrowser()->GetHost()->GetWindowHandle(); if (hwnd) { // Resize the browser window and address bar to match the new frame // window size RECT rect; GetClientRect(hWnd, &rect); #ifdef SHOW_TOOLBAR_UI rect.top += URLBAR_HEIGHT; int urloffset = rect.left + BUTTON_WIDTH * 4; #endif // SHOW_TOOLBAR_UI HDWP hdwp = BeginDeferWindowPos(1); #ifdef SHOW_TOOLBAR_UI hdwp = DeferWindowPos(hdwp, editWnd, NULL, urloffset, 0, rect.right - urloffset, URLBAR_HEIGHT, SWP_NOZORDER); #endif // SHOW_TOOLBAR_UI hdwp = DeferWindowPos(hdwp, hwnd, NULL, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_NOZORDER); EndDeferWindowPos(hdwp); } } break; case WM_ERASEBKGND: if (g_handler.get() && g_handler->GetBrowser()) { CefWindowHandle hwnd = g_handler->GetBrowser()->GetHost()->GetWindowHandle(); if (hwnd) { // Dont erase the background if the browser window has been loaded // (this avoids flashing) return 0; } } break; case WM_CLOSE: if (g_handler.get()) { // If we already initiated the browser closing, then let default window proc handle it. HWND browserHwnd = g_handler->GetBrowser()->GetHost()->GetWindowHandle(); HANDLE closing = GetProp(browserHwnd, CLOSING_PROP); if (closing) { RemoveProp(browserHwnd, CLOSING_PROP); break; } g_handler->QuittingApp(true); g_handler->DispatchCloseToNextBrowser(); return 0; } break; case WM_DESTROY: // The frame window has exited PostQuitMessage(0); return 0; } return DefWindowProc(hWnd, message, wParam, lParam); } }
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam) { PAINTSTRUCT ps; switch (uMsg) { case WM_SIZE: // If the window is resized if(!g_bFullScreen) // Do this only if we are NOT in full screen { SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height GetClientRect(hWnd, &g_rRect); // Get the window rectangle } break; case WM_PAINT: // If we need to repaint the scene BeginPaint(hWnd, &ps); // Init the paint struct EndPaint(hWnd, &ps); // EndPaint, Clean up break; //////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** //////////////////// // Below we define our controls for this simple tutorial. // The controls are: // Left Mouse Button - Changes the Render mode from normal to wireframe. // Right Mouse Button - Turns lighting On/Off // Left Arrow Key - Spins the model to the left // Right Arrow Key - Spins the model to the right // Escape - Quits case WM_LBUTTONDOWN: // If the left mouse button was clicked if(g_ViewMode == GL_TRIANGLES) { // We our drawing mode is at triangles g_ViewMode = GL_LINE_STRIP; // Go to line strips } else { g_ViewMode = GL_TRIANGLES; // Go to triangles } break; case WM_RBUTTONDOWN: // If the right mouse button was clicked. g_bLighting = !g_bLighting; // Turn lighting ON/OFF if(g_bLighting) { // If lighting is ON glEnable(GL_LIGHTING); // Enable OpenGL lighting } else { glDisable(GL_LIGHTING); // Disable OpenGL lighting } break; case WM_KEYDOWN: // If we pressed a key switch(wParam) { // Check if we hit a key case VK_ESCAPE: // If we hit the escape key PostQuitMessage(0); // Send a QUIT message to the window break; case VK_LEFT: // If the LEFT arrow key was pressed g_RotationSpeed -= 0.05f; // Decrease the rotation speed (eventually rotates left) break; case VK_RIGHT: // If the RIGHT arrow key is pressed g_RotationSpeed += 0.05f; // Increase the rotation speed (rotates right) break; } break; //////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** //////////////////// case WM_CLOSE: // If the window is being closed PostQuitMessage(0); // Send a QUIT Message to the window break; default: // Return by default return DefWindowProc (hWnd, uMsg, wParam, lParam); } return 0; // If we handled the messge return 0 }
//------------------------------------------------------------------------ void OnDestroy(HWND hwnd) { PostQuitMessage(0); }
internal LRESULT CALLBACK Win32MainWindowCallback(HWND window, UINT msg, WPARAM w_param, LPARAM l_param) { if (EasyTab_HandleEvent(window, msg, l_param, w_param) == EASYTAB_OK) { return true; // Tablet input } LRESULT result = 0; ImGuiIO& io = ImGui::GetIO(); switch (msg) { // Mouse case WM_LBUTTONDOWN: { io.MouseDown[0] = true; return true; } break; case WM_LBUTTONUP: { io.MouseDown[0] = false; return true; } break; case WM_RBUTTONDOWN: { io.MouseDown[1] = true; return true; } break; case WM_RBUTTONUP: { io.MouseDown[1] = false; return true; } break; case WM_MBUTTONDOWN: { io.MouseDown[2] = true; return true; } break; case WM_MBUTTONUP: { io.MouseDown[2] = false; return true; } break; case WM_MOUSEWHEEL: { io.MouseWheel += GET_WHEEL_DELTA_WPARAM(w_param) > 0 ? +1.0f : -1.0f; return true; } break; case WM_MOUSEMOVE: { TRACKMOUSEEVENT track_param = {}; track_param.dwFlags |= TME_LEAVE; track_param.hwndTrack = window; track_param.cbSize = sizeof(track_param); TrackMouseEvent(&track_param); io.MousePos.x = (signed short)(l_param); io.MousePos.y = (signed short)(l_param >> 16); return true; } break; case WM_MOUSELEAVE: { ImGui::GetIO().MouseDown[0] = false; ImGui::GetIO().MouseDown[1] = false; ImGui::GetIO().MouseDown[2] = false; return true; } break; // Keyboard case WM_KEYDOWN: { if (w_param < 256) io.KeysDown[w_param] = 1; return true; } break; case WM_KEYUP: { if (w_param < 256) io.KeysDown[w_param] = 0; return true; } break; case WM_CHAR: { // You can also use ToAscii()+GetKeyboardState() to retrieve characters. if (w_param > 0 && w_param < 0x10000) io.AddInputCharacter((unsigned short)w_param); return true; } break; // window handling case WM_DESTROY: { mem.is_running = false; if (rendering_context) { wglMakeCurrent(NULL, NULL); wglDeleteContext(rendering_context); } ReleaseDC(window, device_context); PostQuitMessage(0); } break; case WM_PAINT: { PAINTSTRUCT paint; BeginPaint(window, &paint); // TODO: Redraw here EndPaint(window, &paint); } break; case WM_CLOSE: { // TODO: Handle this with a message to the user? mem.is_running = false; } break; case WM_SIZE: { int32 width, height; if (w_param == SIZE_MAXIMIZED) { int32 work_area_width = windows_work_area.right - windows_work_area.left; int32 work_area_height = windows_work_area.bottom - windows_work_area.top; SetWindowPos(window, HWND_TOP, windows_work_area.left, windows_work_area.top, work_area_width, work_area_height, NULL); width = work_area_width; height = work_area_height; } else { width = (int32) LOWORD(l_param); height = (int32) HIWORD(l_param); } core::resize(&mem, width, height); // Clear and swap buffers { if (mem.colors[PapayaCol_Clear]) { glClearBufferfv(GL_COLOR, 0, (GLfloat*)&mem.colors[PapayaCol_Clear]); } SwapBuffers(device_context); } } break; // WM_NCHITTEST case WM_NCHITTEST: { const LONG border_width = 8; //in pixels RECT window_rect; GetWindowRect(window, &window_rect); long X = GET_X_LPARAM(l_param); long Y = GET_Y_LPARAM(l_param); if (!IsMaximized(window)) { //bottom left corner if (X >= window_rect.left && X < window_rect.left + border_width && Y < window_rect.bottom && Y >= window_rect.bottom - border_width) { return HTBOTTOMLEFT; } //bottom right corner if (X < window_rect.right && X >= window_rect.right - border_width && Y < window_rect.bottom && Y >= window_rect.bottom - border_width) { return HTBOTTOMRIGHT; } //top left corner if (X >= window_rect.left && X < window_rect.left + border_width && Y >= window_rect.top && Y < window_rect.top + border_width) { return HTTOPLEFT; } //top right corner if (X < window_rect.right && X >= window_rect.right - border_width && Y >= window_rect.top && Y < window_rect.top + border_width) { return HTTOPRIGHT; } //left border if (X >= window_rect.left && X < window_rect.left + border_width) { return HTLEFT; } //right border if (X < window_rect.right && X >= window_rect.right - border_width) { return HTRIGHT; } //bottom border if (Y < window_rect.bottom && Y >= window_rect.bottom - border_width) { return HTBOTTOM; } //top border if (Y >= window_rect.top && Y < window_rect.top + border_width) { return HTTOP; } } if (Y - window_rect.top <= (float)mem.window.title_bar_height && X > window_rect.left + 200.0f && X < window_rect.right - (float)(mem.window.title_bar_buttons_width + 10)) { return HTCAPTION; } SetCursor(LoadCursor(NULL, IDC_ARROW)); return HTCLIENT; } break; default: { result = DefWindowProcA(window, msg, w_param, l_param); } break; } return(result); }
INT_PTR CALLBACK MainDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch(uMsg) { case WM_COMMAND: { switch(LOWORD(wParam)) { case IDCANCEL: if(g_bSuccess) RunLaunch(); PostQuitMessage(0); break; case IDOK: HMENU hMenu = ::GetSystemMenu(hwndDlg, FALSE); ::EnableMenuItem(hMenu, SC_CLOSE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED); ::EnableWindow(::GetDlgItem(hwndDlg, IDOK), FALSE); ::EnableWindow(::GetDlgItem(hwndDlg, IDCANCEL), FALSE); if(g_hBeginHandle) SetEvent(g_hBeginHandle); break; } } break; case WM_MSG_ENTERFAULT: _enterFaultMode(); break; case WM_MSG_SETPROGRESS: { UINT nPosOld = (UINT)::SendDlgItemMessage(hwndDlg, IDC_PROGRESS_MAIN, PBM_GETPOS, 0, 0); UINT nPosNow = (UINT)wParam; if(nPosNow != nPosOld) { ::SendDlgItemMessage(hwndDlg, IDC_PROGRESS_MAIN, PBM_SETPOS, nPosNow, 0); } } break; case WM_MSG_SUCCESS: { HMENU hMenu = ::GetSystemMenu(hwndDlg, FALSE); ::EnableMenuItem(hMenu, SC_CLOSE, MF_BYCOMMAND|MF_ENABLED); ::EnableWindow(::GetDlgItem(hwndDlg, IDOK), FALSE); ::EnableWindow(::GetDlgItem(hwndDlg, IDCANCEL), TRUE); ::SetDlgItemText(hwndDlg, IDCANCEL, "确定"); ::CloseHandle(g_hBeginHandle); g_hBeginHandle=0; ::SendDlgItemMessage(hwndDlg, IDC_PROGRESS_MAIN, PBM_SETPOS, 100, 0); char szTemp[MAX_PATH] = {0}; _snprintf(szTemp, MAX_PATH, "《天龙八部》成功更新到%s!", g_szVersionTo); MessageBox(g_hMainWnd, szTemp, "《天龙八部》", MB_OK|MB_ICONINFORMATION); g_bSuccess = TRUE; } break; case WM_INITDIALOG: { g_hMainWnd = hwndDlg; //Center main window CenterDlg(hwndDlg); //设置图标 HICON hMainIcon = LoadIcon(g_hInst, (LPCTSTR)IDD_DIALOG_MAIN); ::SendMessage(hwndDlg, WM_SETICON, ICON_BIG, (LPARAM)hMainIcon); ::SendMessage(hwndDlg, WM_SETICON, ICON_SMALL, (LPARAM)hMainIcon); //set status ::SetDlgItemText(hwndDlg, IDC_STATIC_STATUS, "读取版本信息..."); ::SendDlgItemMessage(hwndDlg, IDC_PROGRESS_MAIN, PBM_SETRANGE, 0, MAKELPARAM(0, 100)); g_hBeginHandle = ::CreateEvent(0, TRUE, FALSE, 0); ::ResetEvent(g_hBeginHandle); //create work thread UINT nThreadID; g_hWorkThread = (HANDLE)::_beginthreadex(NULL, 0, _WorkThread, 0, CREATE_SUSPENDED|THREAD_QUERY_INFORMATION, &nThreadID ); if(g_hWorkThread == NULL) { ::SetDlgItemText(hwndDlg, IDC_STATIC_STATUS, "创建线程失败"); _enterFaultMode(); break; } //go! ::ResumeThread(g_hWorkThread); //not care ::CloseHandle(g_hWorkThread); g_hWorkThread=0; } break; case WM_CTLCOLORSTATIC: { HWND hStatic = (HWND)lParam; if(g_bFaultMode && hStatic == GetDlgItem(hwndDlg, IDC_STATIC_STATUS)) { HBRUSH hBrush = (HBRUSH)(INT_PTR)::DefWindowProc(hwndDlg, WM_CTLCOLORSTATIC, wParam, lParam); SetTextColor((HDC)wParam, RGB(255, 0, 0)); return (BOOL)(INT)(INT_PTR)hBrush; } else return FALSE; } break; case WM_CLOSE: PostQuitMessage(0); break; default: break; } return FALSE; }
void sysStop(system_t* system) { PostQuitMessage(0); UNUSED_PARAMETER(system); }
LRESULT CALLBACK WndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam ) { PAINTSTRUCT ps; HDC hdc; int wmId, wmEvent; RotateImage *rotate = new RotateImage(); switch( message ) { case WM_PAINT: hdc = BeginPaint( hWnd, &ps ); EndPaint( hWnd, &ps ); break; case WM_LBUTTONDOWN: { // Сохраняем координаты курсора мыши xPosDown = LOWORD(lParam); yPosDown = HIWORD(lParam); mMouseMove = true; } case WM_MOUSEMOVE: { xPosMove = LOWORD(lParam); yPosMove = HIWORD(lParam); if(mMouseMove) rotate->mouseMove(xPosMove -xPosDown , yPosMove - yPosDown ); xPosDown = xPosMove; yPosDown = yPosMove; break; } case WM_LBUTTONUP: mMouseMove = FALSE; break; case WM_DESTROY: PostQuitMessage( 0 ); break; case WM_COMMAND: wmId = LOWORD(wParam); wmEvent = HIWORD(wParam); switch (wmId) { case IDM_FILE_OP: flag =true; InitContext(); CreateGeometryScene *scene = new CreateGeometryScene(g_hWnd); scene->InitGeometryScene(); //InitGeometry() ; break; } break; default: return DefWindowProc( hWnd, message, wParam, lParam ); } return 0; }
// // FUNCTION: WndProc(HWND, unsigned, WORD, LONG) // // PURPOSE: Processes messages for the main window. // // WM_COMMAND - process the application menu // WM_PAINT - Paint the main window // WM_DESTROY - post a quit message and return // // LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { int wmId, wmEvent; PAINTSTRUCT ps; HDC hdc; TCHAR szHello[MAX_LOADSTRING]; LoadString(hInst, IDS_HELLO, szHello, MAX_LOADSTRING); SOCKET s,newsock; char recvbuf[128]; struct sockaddr remote; int len; int retval; switch (message) { case WM_COMMAND: wmId = LOWORD(wParam); wmEvent = HIWORD(wParam); // Parse the menu selections: switch (wmId) { case IDM_ABOUT: DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About); break; case IDM_EXIT: Stop_server(hWnd); DestroyWindow(hWnd); break; case IDM_START: Start_server(hWnd); break; default: return DefWindowProc(hWnd, message, wParam, lParam); } break; case WM_PAINT: hdc = BeginPaint(hWnd, &ps); // TODO: Add any drawing code here... RECT rt; GetClientRect(hWnd, &rt); DrawText(hdc, szHello, strlen(szHello), &rt, DT_CENTER); EndPaint(hWnd, &ps); break; case WM_DESTROY: PostQuitMessage(0); break; case UM_SOCK: s = (SOCKET)wParam; wmEvent = LOWORD(lParam); switch(wmEvent){ case FD_ACCEPT: len = sizeof(remote); newsock = accept(s,&remote,&len); WSAAsyncSelect(newsock,hWnd,UM_SOCK,FD_READ|FD_CLOSE);//|FD_WRITE); break; case FD_READ: retval = recv(s,recvbuf,sizeof(recvbuf),0); if(retval <= 0){ closesocket(s); break; } recvbuf[retval] = 0; hdc = BeginPaint(hWnd, &ps); // TODO: Add any drawing code here... hdc = GetDC(hWnd); TextOut(hdc,0,row,recvbuf,strlen(recvbuf)); row += 16; ReleaseDC(hWnd,hdc); //»ØËÍÐÅÏ¢ send(s,"ACK",3,0); break; case FD_CLOSE: MessageBox(hWnd,"closesocket\n","server",MB_OK); closesocket(s); break; case FD_WRITE: MessageBox(hWnd,"write event\n","server",MB_OK); break; default: if(WSAGETSELECTERROR(lParam) != 0){ MessageBox(hWnd,"select report error\n","server",MB_OK); closesocket(s); WSACleanup(); } } break; default: return DefWindowProc(hWnd, message, wParam, lParam); } return 0; }
// Process window messages LRESULT CALLBACK Daemon::WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam) { // This is a static method, so we don't know which instantiation we're // dealing with. We have stored a pseudo-this in the window user data, // though. Daemon *_this = (Daemon *) GetWindowLong(hwnd, GWL_USERDATA); switch (iMsg) { case WM_CREATE: { return 0; } case WM_SOCKEVENT: { assert(HIWORD(lParam) == 0); // A new socket created by accept might send messages to // this procedure. We can ignore them. if(wParam != _this->m_sock) { return 0; } switch(lParam) { case FD_ACCEPT: { SOCKET hNewSock; hNewSock = accept(_this->m_sock, NULL, NULL); WSAAsyncSelect(hNewSock, hwnd, 0, 0); unsigned long nbarg = 0; ioctlsocket(hNewSock, FIONBIO, &nbarg); pApp->NewConnection(hNewSock); break; } case FD_READ: { unsigned long numbytes; ioctlsocket(_this->m_sock, FIONREAD, &numbytes); recv(_this->m_sock, _this->netbuf, numbytes, 0); break; } case FD_CLOSE: Log::info(_T("Daemon connection closed\n")); DestroyWindow(hwnd); break; } return 0; } case WM_COMMAND: switch (LOWORD(wParam)) { case ID_NEWCONN: pApp->NewConnection(); break; case IDC_OPTIONBUTTON: { Control ctrlThis; ctrlThis.setWindow(_this->m_hwnd); ConnectionConfigDialog conConfDialog; conConfDialog.setParent(&ctrlThis); conConfDialog.setConnectionConfig(&_this->m_conConf); if (conConfDialog.showModal() == IDOK) { ConnectionConfigSM ccsm(_T(".listen")); _this->m_conConf.saveToStorage(&ccsm); } } break; case ID_CLOSEDAEMON: PostQuitMessage(0); break; case IDD_APP_ABOUT: ShowAboutBox(); break; case IDD_CONFIGURATION: g_vncViewerConfigDialog.showModal(); break; } return 0; case WM_TRAYNOTIFY: { HMENU hSubMenu = GetSubMenu(_this->m_hmenu, 0); if (lParam==WM_LBUTTONDBLCLK) { // double click: execute first menu item ::SendMessage(_this->m_nid.hWnd, WM_COMMAND, GetMenuItemID(hSubMenu, 0), 0); } else if (lParam==WM_RBUTTONUP) { if (hSubMenu == NULL) { Log::warning(_T("No systray submenu\n")); return 0; } // Make first menu item the default (bold font) ::SetMenuDefaultItem(hSubMenu, 0, TRUE); // Display the menu at the current mouse location. There's a "bug" // (Microsoft calls it a feature) in Windows 95 that requires calling // SetForegroundWindow. To find out more, search for Q135788 in MSDN. // POINT mouse; GetCursorPos(&mouse); ::SetForegroundWindow(_this->m_nid.hWnd); ::TrackPopupMenu(hSubMenu, 0, mouse.x, mouse.y, 0, _this->m_nid.hWnd, NULL); } return 0; } case WM_TIMER: _this->CheckTrayIcon(); return 0; case WM_DESTROY: PostQuitMessage(0); return 0; } return DefWindowProc(hwnd, iMsg, wParam, lParam); }
LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { static int cxClient, cyClient; static int cxGrid, cyGrid; static int CheckedGrid[5][5]; PAINTSTRUCT ps; HDC hdc; int i, j; int cxCursor, cyCursor; RECT rectGrid; POINT ptCursor; switch(uMsg) { case WM_KEYDOWN: { //Get Cursor current position GetCursorPos(&ptCursor); ScreenToClient(hwnd, &ptCursor); i = ptCursor.x / cxGrid; j = ptCursor.y / cyGrid; switch(wParam) { case VK_LEFT: i--; break; case VK_RIGHT: i++; break; case VK_UP: j--; break; case VK_DOWN: j++; break; case VK_HOME: i = 0; j = 0; break; case VK_END: i = ROWCOUNT - 1; j = COLUMNCOUNT - 1; break; default: break; } if (i > COLUMNCOUNT - 1) { i = 0; } else if (i < 0) { i = COLUMNCOUNT - 1; } if (j > ROWCOUNT - 1) { j = 0; } else if (j < 0) { j = ROWCOUNT - 1; } ptCursor.x = i * cxGrid + cxGrid / 2; ptCursor.y = j * cyGrid + cyGrid / 2; ClientToScreen(hwnd, &ptCursor); SetCursorPos(ptCursor.x, ptCursor.y); break; } case WM_CHAR: { switch (wParam) { case ' ': //Space case '\r': //Enter { GetCursorPos(&ptCursor); ScreenToClient(hwnd, &ptCursor); SendMessage(hwnd, WM_LBUTTONDOWN, 0, MAKELONG(ptCursor.x, ptCursor.y)); break; } } break; } case WM_SIZE: { cxClient = LOWORD(lParam); cyClient = HIWORD(lParam); cxGrid = cxClient / COLUMNCOUNT; cyGrid = cyClient / ROWCOUNT; InvalidateRect(hwnd, NULL, TRUE); break; } case WM_LBUTTONDOWN: { cxCursor = LOWORD(lParam); cyCursor = HIWORD(lParam); i = cxCursor / cxGrid; j = cyCursor /cyGrid; CheckedGrid[i][j] = !CheckedGrid[i][j]; rectGrid.left = i * cxGrid; rectGrid.right = (i+1) * cxGrid; rectGrid.top = j * cyGrid; rectGrid.bottom = (j+1) * cyGrid; InvalidateRect(hwnd, &rectGrid, TRUE); break; } case WM_PAINT: { hdc = BeginPaint(hwnd, &ps); // Draw lines for (i = 0; i < ROWCOUNT; ++i) { MoveToEx(hdc, 0, cyGrid * (1 + i), NULL); LineTo(hdc, cxGrid * COLUMNCOUNT, cyGrid * (1 + i)); } for (i = 0; i < COLUMNCOUNT; ++i) { MoveToEx(hdc, cxGrid * (1 + i), 0, NULL); LineTo(hdc, cxGrid * (1 + i), cyGrid * ROWCOUNT); } for (i = 0; i < ROWCOUNT; ++i) { for (j=0; j < COLUMNCOUNT; ++j) { if (CheckedGrid[i][j]) { //Draw Cross line MoveToEx(hdc, i * cxGrid, j * cyGrid, NULL); LineTo(hdc, (i+1) * cxGrid, (j+1) * cyGrid); MoveToEx(hdc, (i+1) * cxGrid, j * cyGrid, NULL); LineTo(hdc, i * cxGrid, (j+1) * cyGrid); } } } // Draw Checkers EndPaint(hwnd, &ps); break; } case WM_DESTROY: { PostQuitMessage(0); return 0; } } return DefWindowProc(hwnd, uMsg, wParam, lParam); }
// Processes messages for main Window LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { PTOUCHINPUT pInputs; TOUCHINPUT tInput; HTOUCHINPUT hInput; int iNumContacts; POINT ptInputs; PAINTSTRUCT ps; // Handle each type of inData and based on which event we handle continue processing // the inData for manipulations by calling the ComTouchDriver switch (msg) { case WM_TOUCH: iNumContacts = LOWORD(wParam); hInput = (HTOUCHINPUT)lParam; pInputs = new (std::nothrow) TOUCHINPUT[iNumContacts]; // Get each touch input info and feed each TOUCHINPUT into the process input handler if(pInputs != NULL) { if(GetTouchInputInfo(hInput, iNumContacts, pInputs, sizeof(TOUCHINPUT))) { for(int i = 0; i < iNumContacts; i++) { // Bring touch input info into client coordinates ptInputs.x = pInputs[i].x/100; ptInputs.y = pInputs[i].y/100; ScreenToClient(g_hWnd, &ptInputs); pInputs[i].x = ptInputs.x; pInputs[i].y = ptInputs.y; g_ctDriver->ProcessInputEvent(&pInputs[i]); } g_ctDriver->ProcessChanges(); } } delete [] pInputs; CloseTouchInputHandle(hInput); break; // For each Mouse event build a TOUCHINPUT struct and feed into the process input handler case WM_LBUTTONDOWN: FillInputData(&tInput, MOUSE_CURSOR_ID, TOUCHEVENTF_DOWN, (DWORD)GetMessageTime(),LOWORD(lParam),HIWORD(lParam)); g_ctDriver->ProcessInputEvent(&tInput); break; case WM_MOUSEMOVE: if(LOWORD(wParam) == MK_LBUTTON) { FillInputData(&tInput, MOUSE_CURSOR_ID, TOUCHEVENTF_MOVE, (DWORD)GetMessageTime(),LOWORD(lParam), HIWORD(lParam)); g_ctDriver->ProcessInputEvent(&tInput); g_ctDriver->ProcessChanges(); } break; case WM_LBUTTONUP: FillInputData(&tInput, MOUSE_CURSOR_ID, TOUCHEVENTF_UP, (DWORD)GetMessageTime(),LOWORD(lParam), HIWORD(lParam)); g_ctDriver->ProcessInputEvent(&tInput); break; case WM_DESTROY: if(g_ctDriver) { delete g_ctDriver; } PostQuitMessage(0); return 1; case WM_SIZE: g_iCWidth = LOWORD(lParam); g_iCHeight = HIWORD(lParam); break; case WM_PAINT: BeginPaint(g_hWnd, &ps); g_ctDriver->RenderInitialState(g_iCWidth, g_iCHeight); EndPaint(g_hWnd, &ps); break; case WM_TIMER: g_ctDriver->ProcessChanges(); break; default: return DefWindowProc(hWnd, msg, wParam, lParam); } return 0; }
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { HWND msgwnd = CreateWindow(L"STATIC", L"Shiftfocus window", 0, 0, 0, 0, 0, HWND_MESSAGE, 0, GetModuleHandle(NULL), 0); # define MAKE(x) (RegisterHotKey(msgwnd, x, MOD_CONTROL | MOD_WIN, x) == 0) if ((msgwnd == NULL) || MAKE(VK_LEFT) || MAKE(VK_RIGHT) || MAKE(VK_UP) || MAKE(VK_DOWN)) { MessageBox(msgwnd, L"Unable to register hotkeys, exiting.", L"Error", MB_ICONERROR | MB_OK); DestroyWindow(msgwnd); return 1; } MSG msg; BOOL ret; while (0 != (ret = GetMessage(&msg, msgwnd, 0, 0))) { if (-1 == ret) return 1; switch (msg.message) { case WM_DESTROY: PostQuitMessage(0); break; case WM_HOTKEY: { RECT loc = {}; HWND fg = GetForegroundWindow(); HWND desktop = getDesktopWindow(); GetWindowRect(fg, &loc); POINT p = {}; for ( int distance = 10; MonitorFromPoint(p, MONITOR_DEFAULTTONULL); distance += 10) { switch (msg.wParam) { # define HALF(x,y) (((y)-(x))/2+(x)) case VK_LEFT: p.x=loc.left-distance; p.y=HALF(loc.top,loc.bottom); break; case VK_RIGHT: p.x=loc.right+distance; p.y=HALF(loc.top,loc.bottom); break; case VK_UP: p.y=loc.top-distance; p.x=HALF(loc.left,loc.right); break; case VK_DOWN: p.y=loc.bottom+distance; p.x=HALF(loc.left,loc.right); break; default: MessageBeep(MB_ICONERROR); } HWND n = ChildWindowFromPoint(GetDesktopWindow(), p); if (NULL == n) MessageBeep(MB_ICONASTERISK); else { if (desktop == n) continue; if (!SetForegroundWindow(n)) MessageBeep(MB_ICONERROR); break; } } } break; } TranslateMessage(&msg); DispatchMessage(&msg); } return msg.wParam; }