/* directx_wnd_proc: * Window procedure for the Allegro window class. */ static LRESULT CALLBACK directx_wnd_proc(HWND wnd, UINT message, WPARAM wparam, LPARAM lparam) { PAINTSTRUCT ps; if (message == msg_call_proc) return ((int (*)(void))wparam) (); if (message == msg_suicide) { DestroyWindow(wnd); return 0; } /* See get_reverse_mapping() in wkeybd.c to see what this is for. */ if (FALSE && (message == WM_KEYDOWN || message == WM_SYSKEYDOWN)) { static char name[256]; TCHAR str[256]; WCHAR wstr[256]; GetKeyNameText(lparam, str, sizeof str); MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, str, -1, wstr, sizeof wstr); uconvert((char *)wstr, U_UNICODE, name, U_CURRENT, sizeof name); _TRACE(PREFIX_I" key[%s] = 0x%08lx;\n", name, lparam & 0x1ff0000); } switch (message) { case WM_CREATE: if (!user_wnd_proc) allegro_wnd = wnd; break; case WM_DESTROY: if (user_wnd_proc) { exit_window_modules(NULL); _win_reset_switch_mode(); } else { PostQuitMessage(0); } allegro_wnd = NULL; break; case WM_SETCURSOR: if (!user_wnd_proc || _mouse_installed) { mouse_set_syscursor(); return 1; /* not TRUE */ } break; case WM_ACTIVATE: if (LOWORD(wparam) == WA_INACTIVE) { _win_switch_out(); } else { /* Ignore the WM_ACTIVATE event if the window is minimized. */ if (HIWORD(wparam)) break; if (gfx_driver && !gfx_driver->windowed) { /* 1.2s delay to let Windows complete the switch in fullscreen mode */ SetTimer(allegro_wnd, SWITCH_TIMER, 1200, NULL); } else { /* no delay in windowed mode */ _win_switch_in(); } } break; case WM_TIMER: if (wparam == SWITCH_TIMER) { KillTimer(allegro_wnd, SWITCH_TIMER); _win_switch_in(); return 0; } break; case WM_ENTERSIZEMOVE: if (win_gfx_driver && win_gfx_driver->enter_sysmode) win_gfx_driver->enter_sysmode(); break; case WM_EXITSIZEMOVE: if (win_gfx_driver && win_gfx_driver->exit_sysmode) win_gfx_driver->exit_sysmode(); break; case WM_MOVE: if (GetActiveWindow() == allegro_wnd) { if (!IsIconic(allegro_wnd)) { wnd_x = (short) LOWORD(lparam); wnd_y = (short) HIWORD(lparam); if (win_gfx_driver && win_gfx_driver->move) win_gfx_driver->move(wnd_x, wnd_y, wnd_width, wnd_height); } else if (win_gfx_driver && win_gfx_driver->iconify) { win_gfx_driver->iconify(); } } break; case WM_SIZE: wnd_width = LOWORD(lparam); wnd_height = HIWORD(lparam); break; case WM_PAINT: if (!user_wnd_proc || win_gfx_driver) { BeginPaint(wnd, &ps); if (win_gfx_driver && win_gfx_driver->paint) win_gfx_driver->paint(&ps.rcPaint); EndPaint(wnd, &ps); return 0; } break; case WM_KEYDOWN: case WM_KEYUP: case WM_SYSKEYDOWN: case WM_SYSKEYUP: /* Disable the default message-based key handler * in order to prevent conflicts on NT kernels. */ if (!user_wnd_proc || _keyboard_installed) return 0; break; case WM_SYSCOMMAND: if (wparam == SC_MONITORPOWER || wparam == SC_SCREENSAVE) { if (_screensaver_policy == ALWAYS_DISABLED || (_screensaver_policy == FULLSCREEN_DISABLED && gfx_driver && !gfx_driver->windowed)) return 0; } break; case WM_INITMENUPOPUP: wnd_sysmenu = TRUE; mouse_set_sysmenu(TRUE); if (win_gfx_driver && win_gfx_driver->enter_sysmode) win_gfx_driver->enter_sysmode(); break; case WM_MENUSELECT: if ((HIWORD(wparam) == 0xFFFF) && (!lparam)) { wnd_sysmenu = FALSE; mouse_set_sysmenu(FALSE); if (win_gfx_driver && win_gfx_driver->exit_sysmode) win_gfx_driver->exit_sysmode(); } break; case WM_MENUCHAR : return (MNC_CLOSE<<16)|(wparam&0xffff); case WM_CLOSE: if (!user_wnd_proc) { if (user_close_proc) (*user_close_proc)(); return 0; } break; } /* pass message to default window proc */ if (user_wnd_proc) return CallWindowProc(user_wnd_proc, wnd, message, wparam, lparam); else return DefWindowProc(wnd, message, wparam, lparam); }
INT_PTR CALLBACK UpdaterWndProc( __in HWND hwndDlg, __in UINT uMsg, __in WPARAM wParam, __in LPARAM lParam ) { switch (uMsg) { case WM_INITDIALOG: { LOGFONT lHeaderFont = { 0 }; // load the PH main icon using the 'magic' resource id. HANDLE hPhIcon = LoadImage( GetModuleHandle(NULL), MAKEINTRESOURCE(PHAPP_IDI_PROCESSHACKER), IMAGE_ICON, GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON), LR_SHARED ); // Set our initial state as download PhUpdaterState = Download; // Set the window icon. SendMessage(hwndDlg, WM_SETICON, ICON_BIG, (LPARAM)hPhIcon); lHeaderFont.lfHeight = -15; lHeaderFont.lfWeight = FW_MEDIUM; lHeaderFont.lfQuality = CLEARTYPE_QUALITY | ANTIALIASED_QUALITY; // We don't check if Segoe exists, CreateFontIndirect does this for us. wcscpy_s( lHeaderFont.lfFaceName, _countof(lHeaderFont.lfFaceName), L"Segoe UI" ); // Create the font handle. FontHandle = CreateFontIndirectW(&lHeaderFont); // Set the header font. SendMessage(GetDlgItem(hwndDlg, IDC_MESSAGE), WM_SETFONT, (WPARAM)FontHandle, FALSE); // Center the update window on PH if visible and not mimimized else center on desktop. PhCenterWindow(hwndDlg, (IsWindowVisible(GetParent(hwndDlg)) && !IsIconic(GetParent(hwndDlg))) ? GetParent(hwndDlg) : NULL); // Create our update check thread. UpdateCheckThreadHandle = PhCreateThread(0, (PUSER_THREAD_START_ROUTINE)CheckUpdateThreadStart, hwndDlg); } break; case WM_SHOWDIALOG: { if (IsIconic(hwndDlg)) ShowWindow(hwndDlg, SW_RESTORE); else ShowWindow(hwndDlg, SW_SHOW); SetForegroundWindow(hwndDlg); } break; case WM_CTLCOLORBTN: case WM_CTLCOLORDLG: case WM_CTLCOLORSTATIC: { HDC hDC = (HDC)wParam; HWND hwndChild = (HWND)lParam; // Check for our static label and change the color. if (GetDlgCtrlID(hwndChild) == IDC_MESSAGE) { SetTextColor(hDC, RGB(19, 112, 171)); } // Set a transparent background for the control backcolor. SetBkMode(hDC, TRANSPARENT); // set window background color. return (INT_PTR)GetSysColorBrush(COLOR_WINDOW); } case WM_COMMAND: { switch (LOWORD(wParam)) { case IDCANCEL: case IDOK: { PostQuitMessage(0); } break; case IDC_DOWNLOAD: { switch (PhUpdaterState) { case Download: { if (PhInstalledUsingSetup()) { // Start our Downloader thread DownloadThreadHandle = PhCreateThread(0, (PUSER_THREAD_START_ROUTINE)DownloadUpdateThreadStart, hwndDlg); } else { // Let the user handle non-setup installation, show the homepage and close this dialog. PhShellExecute(hwndDlg, L"http://processhacker.sourceforge.net/downloads.php", NULL); PostQuitMessage(0); } } break; case Install: { SHELLEXECUTEINFO info = { sizeof(SHELLEXECUTEINFO) }; info.lpFile = SetupFilePath->Buffer; info.lpVerb = L"runas"; info.nShow = SW_SHOW; info.hwnd = hwndDlg; ProcessHacker_PrepareForEarlyShutdown(PhMainWndHandle); if (!ShellExecuteEx(&info)) { // Install failed, cancel the shutdown. ProcessHacker_CancelEarlyShutdown(PhMainWndHandle); // Set button text for next action Button_SetText(GetDlgItem(hwndDlg, IDC_DOWNLOAD), L"Retry"); } else { ProcessHacker_Destroy(PhMainWndHandle); } } break; } } break; } break; } break; case WM_UPDATE: { if (IsUpdating) { DWORD time_taken; DWORD download_speed; //DWORD time_remain = (MulDiv(time_taken, contentLength, bytesDownloaded) - time_taken); int percent; PPH_STRING dlRemaningBytes; PPH_STRING dlLength; PPH_STRING dlSpeed; PPH_STRING statusText; PhAcquireQueuedLockExclusive(&Lock); time_taken = (GetTickCount() - timeTransferred); download_speed = (bytesDownloaded / max(time_taken, 1)); percent = MulDiv(100, bytesDownloaded, contentLength); dlRemaningBytes = PhFormatSize(bytesDownloaded, -1); dlLength = PhFormatSize(contentLength, -1); dlSpeed = PhFormatSize(download_speed * 1024, -1); LastUpdateTime = GetTickCount(); PhReleaseQueuedLockExclusive(&Lock); statusText = PhFormatString( L"%s (%d%%) of %s @ %s/s", dlRemaningBytes->Buffer, percent, dlLength->Buffer, dlSpeed->Buffer ); SetDlgItemText(hwndDlg, IDC_STATUS, statusText->Buffer); SendDlgItemMessage(hwndDlg, IDC_PROGRESS, PBM_SETPOS, percent, 0); PhDereferenceObject(statusText); PhDereferenceObject(dlSpeed); PhDereferenceObject(dlLength); PhDereferenceObject(dlRemaningBytes); IsUpdating = FALSE; } } break; } return FALSE; }
/******************************************************************* * set_active_window */ static BOOL set_active_window( HWND hwnd, HWND *prev, BOOL mouse, BOOL focus ) { HWND previous = GetActiveWindow(); BOOL ret; DWORD old_thread, new_thread; CBTACTIVATESTRUCT cbt; if (previous == hwnd) { if (prev) *prev = hwnd; return TRUE; } /* call CBT hook chain */ cbt.fMouse = mouse; cbt.hWndActive = previous; if (HOOK_CallHooks( WH_CBT, HCBT_ACTIVATE, (WPARAM)hwnd, (LPARAM)&cbt, TRUE )) return FALSE; if (IsWindow(previous)) { SendMessageW( previous, WM_NCACTIVATE, FALSE, (LPARAM)hwnd ); SendMessageW( previous, WM_ACTIVATE, MAKEWPARAM( WA_INACTIVE, IsIconic(previous) ), (LPARAM)hwnd ); } SERVER_START_REQ( set_active_window ) { req->handle = wine_server_user_handle( hwnd ); if ((ret = !wine_server_call_err( req ))) previous = wine_server_ptr_handle( reply->previous ); } SERVER_END_REQ; if (!ret) return FALSE; if (prev) *prev = previous; if (previous == hwnd) return TRUE; if (hwnd) { /* send palette messages */ if (SendMessageW( hwnd, WM_QUERYNEWPALETTE, 0, 0 )) SendMessageTimeoutW( HWND_BROADCAST, WM_PALETTEISCHANGING, (WPARAM)hwnd, 0, SMTO_ABORTIFHUNG, 2000, NULL ); if (!IsWindow(hwnd)) return FALSE; } old_thread = previous ? GetWindowThreadProcessId( previous, NULL ) : 0; new_thread = hwnd ? GetWindowThreadProcessId( hwnd, NULL ) : 0; if (old_thread != new_thread) { HWND *list, *phwnd; if ((list = WIN_ListChildren( GetDesktopWindow() ))) { if (old_thread) { for (phwnd = list; *phwnd; phwnd++) { if (GetWindowThreadProcessId( *phwnd, NULL ) == old_thread) SendMessageW( *phwnd, WM_ACTIVATEAPP, 0, new_thread ); } } if (new_thread) { for (phwnd = list; *phwnd; phwnd++) { if (GetWindowThreadProcessId( *phwnd, NULL ) == new_thread) SendMessageW( *phwnd, WM_ACTIVATEAPP, 1, old_thread ); } } HeapFree( GetProcessHeap(), 0, list ); } } if (IsWindow(hwnd)) { SendMessageW( hwnd, WM_NCACTIVATE, (hwnd == GetForegroundWindow()), (LPARAM)previous ); SendMessageW( hwnd, WM_ACTIVATE, MAKEWPARAM( mouse ? WA_CLICKACTIVE : WA_ACTIVE, IsIconic(hwnd) ), (LPARAM)previous ); if (GetAncestor( hwnd, GA_PARENT ) == GetDesktopWindow()) PostMessageW( GetDesktopWindow(), WM_PARENTNOTIFY, WM_NCACTIVATE, (LPARAM)hwnd ); if (hwnd == GetForegroundWindow() && !IsIconic( hwnd )) USER_Driver->pSetActiveWindow( hwnd ); } /* now change focus if necessary */ if (focus) { GUITHREADINFO info; info.cbSize = sizeof(info); GetGUIThreadInfo( GetCurrentThreadId(), &info ); /* Do not change focus if the window is no more active */ if (hwnd == info.hwndActive) { if (!info.hwndFocus || !hwnd || GetAncestor( info.hwndFocus, GA_ROOT ) != hwnd) set_focus_window( hwnd ); } } return TRUE; }
static bool d3d_frame(void *data, const void *frame, unsigned width, unsigned height, unsigned pitch, const char *msg) { d3d_video_t *d3d = (d3d_video_t*)data; if (!frame) return true; RARCH_PERFORMANCE_INIT(d3d_frame); RARCH_PERFORMANCE_START(d3d_frame); // We cannot recover in fullscreen. if (d3d->needs_restore && IsIconic(d3d->hWnd)) return true; if (d3d->needs_restore && !d3d_restore(d3d)) { RARCH_ERR("[D3D]: Failed to restore.\n"); return false; } if (d3d->should_resize) { d3d_calculate_rect(d3d, d3d->screen_width, d3d->screen_height, d3d->video_info.force_aspect, g_extern.system.aspect_ratio); renderchain_set_final_viewport(d3d->chain, &d3d->final_viewport); d3d_recompute_pass_sizes(d3d); d3d->should_resize = false; } // render_chain() only clears out viewport, clear out everything. D3DVIEWPORT screen_vp; screen_vp.X = 0; screen_vp.Y = 0; screen_vp.MinZ = 0; screen_vp.MaxZ = 1; screen_vp.Width = d3d->screen_width; screen_vp.Height = d3d->screen_height; d3d->dev->SetViewport(&screen_vp); d3d->dev->Clear(0, 0, D3DCLEAR_TARGET, 0, 1, 0); // Insert black frame first, so we can screenshot, etc. if (g_settings.video.black_frame_insertion) { if (d3d->dev->Present(NULL, NULL, NULL, NULL) != D3D_OK) { RARCH_ERR("[D3D]: Present() failed.\n"); d3d->needs_restore = true; return true; } d3d->dev->Clear(0, 0, D3DCLEAR_TARGET, 0, 1, 0); } if (!renderchain_render(d3d->chain, frame, width, height, pitch, d3d->dev_rotation)) { RARCH_ERR("[D3D]: Failed to render scene.\n"); return false; } if (d3d->font_ctx && d3d->font_ctx->render_msg) { font_params_t font_parms = {0}; #ifdef _XBOX #if defined(_XBOX1) float msg_width = 60; float msg_height = 365; #elif defined(_XBOX360) float msg_width = (g_extern.lifecycle_state & (1ULL << MODE_MENU_HD)) ? 160 : 100; float msg_height = 120; #endif font_parms.x = msg_width; font_parms.y = msg_height; font_parms.scale = 21; #endif d3d->font_ctx->render_msg(d3d, msg, &font_parms); } #ifdef HAVE_MENU if (d3d->rgui && d3d->rgui->enabled) d3d_overlay_render(d3d, d3d->rgui); #endif #ifdef HAVE_OVERLAY if (d3d->overlays_enabled) { for (unsigned i = 0; i < d3d->overlays.size(); i++) d3d_overlay_render(d3d, &d3d->overlays[i]); } #endif RARCH_PERFORMANCE_STOP(d3d_frame); #ifdef HAVE_MENU if (g_extern.lifecycle_state & (1ULL << MODE_MENU) && driver.menu_ctx && driver.menu_ctx->frame) driver.menu_ctx->frame(d3d); #endif if (d3d && d3d->ctx_driver && d3d->ctx_driver->update_window_title) d3d->ctx_driver->update_window_title(d3d); if (d3d && d3d->ctx_driver && d3d->ctx_driver->swap_buffers) d3d->ctx_driver->swap_buffers(d3d); return true; }
LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { if ( wmode ) { // Perform W-Mode only functionality switch ( uMsg ) { case WM_SIZING: { SIZE border; GetBorderSize(hWnd, &border); RECT *rct = (RECT*)lParam; SIZE ws = { rct->right - rct->left - border.cx, rct->bottom - rct->top - border.cy }; if ( ws.cx < WMODE_MIN_WIDTH ) { ws.cx = WMODE_MIN_WIDTH; CorrectWindowWidth(wParam, &ws, rct, &border); } if ( ws.cy < WMODE_MIN_HEIGHT ) { ws.cy = WMODE_MIN_HEIGHT; CorrectWindowHeight(wParam, &ws, rct, &border); } if ( GetKeyState(VK_CONTROL) & 0x8000 && ws.cy != ws.cx * 3 / 4 ) { if ( wParam == WMSZ_TOP || wParam == WMSZ_BOTTOM ) { ws.cx = ws.cy * 4 / 3; CorrectWindowWidth(WMSZ_RIGHT, &ws, rct, &border); } else { ws.cy = ws.cx * 3 / 4; CorrectWindowHeight( (wParam == WMSZ_RIGHT || wParam == WMSZ_LEFT) ? WMSZ_BOTTOM : wParam, &ws, rct, &border); } } if ( isCorrectVersion ) // must be correct version to reference BWDATA { if ( ws.cx >= BW::BWDATA::GameScreenBuffer.width() - WMODE_SNAP_RANGE && ws.cx <= BW::BWDATA::GameScreenBuffer.width() + WMODE_SNAP_RANGE ) { ws.cx = BW::BWDATA::GameScreenBuffer.width(); CorrectWindowWidth( (wParam == WMSZ_TOP || wParam == WMSZ_BOTTOM) ? WMSZ_RIGHT : wParam, &ws, rct, &border); } if ( ws.cy >= BW::BWDATA::GameScreenBuffer.height() - WMODE_SNAP_RANGE && ws.cy <= BW::BWDATA::GameScreenBuffer.height() + WMODE_SNAP_RANGE ) { ws.cy = BW::BWDATA::GameScreenBuffer.height(); CorrectWindowHeight( (wParam == WMSZ_RIGHT || wParam == WMSZ_LEFT) ? WMSZ_BOTTOM : wParam, &ws, rct, &border); } } break; } // case WM_SIZING case WM_SIZE: { switch ( wParam ) { case SIZE_RESTORED: { RECT tempRect; GetClientRect(hWnd, &tempRect); windowRect.right = tempRect.right; windowRect.bottom = tempRect.bottom; WriteConfig("window", "width", tempRect.right); WriteConfig("window", "height", tempRect.bottom); break; } }// wParam switch break; } // case WM_SIZE case WM_MOVE: { RECT tempRect; GetWindowRect(hWnd, &tempRect); if ( tempRect.right > 0 && tempRect.bottom > 0 && tempRect.left < GetSystemMetrics(SM_CXFULLSCREEN) && tempRect.top < GetSystemMetrics(SM_CYFULLSCREEN) ) { windowRect.left = tempRect.left; windowRect.top = tempRect.top; WriteConfig("window", "left", tempRect.left); WriteConfig("window", "top", tempRect.top); } break; } // case WM_MOVE case WM_PAINT: if ( gbWantUpdate && pBits) { static DWORD dwLastUpdate = 0; DWORD dwNewTick = GetTickCount(); if ( dwLastUpdate + (IsIconic(hWnd) ? 200 : 20) > dwNewTick ) break; dwLastUpdate = dwNewTick; gbWantUpdate = false; // begin paint PAINTSTRUCT paint; HDC hdc = BeginPaint(hWnd, &paint); if ( isCorrectVersion ) // must be correct version, @todo: make independent { // Blit to the screen RECT cRect; GetClientRect(hWnd, &cRect); if ( cRect.right == BW::BWDATA::GameScreenBuffer.width() && cRect.bottom == BW::BWDATA::GameScreenBuffer.height() ) { BitBlt(hdc, 0, 0, BW::BWDATA::GameScreenBuffer.width(), BW::BWDATA::GameScreenBuffer.height(), hdcMem, 0, 0, SRCCOPY); } else { SetStretchBltMode(hdc, HALFTONE); //StretchBlt(hdc, 0, 0, cRect.right, cRect.bottom, hdcMem, 0, 0, BW::BWDATA::GameScreenBuffer->wid, BW::BWDATA::GameScreenBuffer->ht, SRCCOPY); StretchDIBits(hdc, 0, 0, cRect.right, cRect.bottom, 0, 0, BW::BWDATA::GameScreenBuffer.width(), BW::BWDATA::GameScreenBuffer.height(), pBits, (BITMAPINFO*)&wmodebmp, DIB_RGB_COLORS, SRCCOPY); } } // end paint EndPaint(hWnd, &paint); } // data break; case WM_NCMOUSEMOVE: SetCursorShowState(true); break; case WM_MOUSEMOVE: SetCursorShowState(false); lParam = FixPoints(lParam); break; case WM_LBUTTONDOWN: case WM_RBUTTONDOWN: case WM_MBUTTONDOWN: { RECT clientRct; GetClientRect(hWnd, &clientRct); ClientToScreen(hWnd, (LPPOINT)&clientRct.left); ClientToScreen(hWnd, (LPPOINT)&clientRct.right); ClipCursor(&clientRct); lParam = FixPoints(lParam); break; } case WM_MBUTTONUP: case WM_LBUTTONUP: case WM_RBUTTONUP: ClipCursor(NULL); lParam = FixPoints(lParam); break; case WM_MOUSEWHEEL: case WM_RBUTTONDBLCLK: case WM_LBUTTONDBLCLK: case WM_MBUTTONDBLCLK: lParam = FixPoints(lParam); break; case WM_ACTIVATEAPP: if ( wOriginalProc ) return CallWindowProc(wOriginalProc, hWnd, WM_ACTIVATEAPP, (WPARAM)1, NULL); case WM_SETCURSOR: case WM_ERASEBKGND: return DefWindowProc(hWnd, uMsg, wParam, lParam); case WM_SYSKEYDOWN: case WM_KEYDOWN: if ( wParam == VK_MENU && !(lParam & 0x40000000)) { RECT rct; GetClientRect(hWnd, &rct); ClientToScreen(hWnd, (LPPOINT)&rct.left); ClientToScreen(hWnd, (LPPOINT)&rct.right); ClipCursor(&rct); gbHoldingAlt = true; } break; case WM_SYSKEYUP: case WM_KEYUP: if ( wParam == VK_MENU ) { ClipCursor(NULL); gbHoldingAlt = false; } break; } // switch } // if wmode if ( isCorrectVersion ) { // Perform BWAPI-added functionality switch ( uMsg ) { case WM_SYSKEYDOWN: if ( wParam == VK_RETURN && (lParam & 0x20000000) && !(lParam & 0x40000000) ) { SetWMode(BW::BWDATA::GameScreenBuffer.width(), BW::BWDATA::GameScreenBuffer.height(), !wmode); return TRUE; } break; case WM_MOUSEMOVE: if ( GetWindowLong(ghMainWnd, GWL_STYLE) & WS_SYSMENU ) // Compatibility for Xen W-Mode { BW::BWDATA::InputFlags |= 1; POINTS pt = MAKEPOINTS(lParam); BW::BWDATA::Mouse.x = pt.x; BW::BWDATA::Mouse.y = pt.y; return TRUE; } break; case WM_LBUTTONDOWN: case WM_LBUTTONUP: case WM_LBUTTONDBLCLK: case WM_RBUTTONDOWN: case WM_RBUTTONUP: case WM_RBUTTONDBLCLK: case WM_MBUTTONDOWN: case WM_MBUTTONUP: case WM_MBUTTONDBLCLK: if ( GetWindowLong(ghMainWnd, GWL_STYLE) & WS_SYSMENU ) // Compatibility for Xen W-Mode { ButtonEvent(uMsg - WM_MOUSEFIRST + BW_EVN_MOUSEFIRST, lParam); return TRUE; } break; case WM_SYSCOMMAND: if ( wParam == SC_MAXIMIZE ) { SetWMode(BW::BWDATA::GameScreenBuffer.width(), BW::BWDATA::GameScreenBuffer.height(), false); return TRUE; } break; } } // Register Broodwar thread name RegisterThreadName("Broodwar Main"); // Call the original WndProc if ( wOriginalProc ) return CallWindowProc(wOriginalProc, hWnd, uMsg, wParam, lParam); return DefWindowProc(hWnd, uMsg, wParam, lParam); }
static int update_subwindow(void) { int x,y; RECT rd; WINDOWPOS wp; if(!sub_window) { WinID = -1; if(IsWindowVisible(mygui->subwindow) && guiInfo.sh_video && guiInfo.Playing) { ShowWindow(mygui->subwindow, SW_HIDE); return 0; } else if(!guiInfo.VideoWindow) return 0; else ShowWindow(mygui->subwindow, SW_SHOW); } /* we've come out of fullscreen at the end of file */ if((!IsWindowVisible(mygui->subwindow) || IsIconic(mygui->subwindow)) && guiInfo.VideoWindow) ShowWindow(mygui->subwindow, SW_SHOWNORMAL); /* get our current window coordinates */ GetWindowRect(mygui->subwindow, &rd); x = rd.left; y = rd.top; /* restore sub window position when coming out of fullscreen */ if(x <= 0) x = old_rect.left; if(y <= 0) y = old_rect.top; if(!guiInfo.Playing) { window *desc = NULL; int i; for (i=0; i<mygui->skin->windowcount; i++) if(mygui->skin->windows[i]->type == wiSub) desc = mygui->skin->windows[i]; rd.right = rd.left+desc->base->bitmap[0]->width; rd.bottom = rd.top+desc->base->bitmap[0]->height; sub_aspect = (float)(rd.right-rd.left)/(rd.bottom-rd.top); } else { rd.right = rd.left+guiInfo.VideoWidth; rd.bottom = rd.top+guiInfo.VideoHeight; if (movie_aspect > 0.0) // forced aspect from the cmdline sub_aspect = movie_aspect; } AdjustWindowRect(&rd, WS_OVERLAPPEDWINDOW | WS_SIZEBOX, 0); SetWindowPos(mygui->subwindow, 0, x, y, rd.right-rd.left, rd.bottom-rd.top, SWP_NOOWNERZORDER); wp.hwnd = mygui->subwindow; wp.x = rd.left; wp.y = rd.top; wp.cx = rd.right-rd.left; wp.cy = rd.bottom-rd.top; wp.flags = SWP_NOOWNERZORDER | SWP_SHOWWINDOW; /* erase the bitmap image if there's video */ if(guiInfo.Playing != GUI_STOP && guiInfo.sh_video) SendMessage(mygui->subwindow, WM_ERASEBKGND, (WPARAM)GetDC(mygui->subwindow), 0); /* reset the window aspect */ SendMessage(mygui->subwindow, WM_WINDOWPOSCHANGED, 0, (LPARAM)&wp); return 0; }
//--------------------------------------------------------------------- bool D3D10RenderWindow::isVisible() const { return (mHWnd && !IsIconic(mHWnd)); }
LRESULT CALLBACK HostWndProcW (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { RECT boundingRect; switch(message){ /* mousing */ case WM_MOUSEMOVE: recordMouseEvent(lastMessage); break; case WM_LBUTTONDOWN: case WM_RBUTTONDOWN: case WM_MBUTTONDOWN: if(GetFocus() != hwnd) SetFocus(hwnd); SetCapture(hwnd); /* capture mouse input */ recordMouseEvent(lastMessage); break; case WM_LBUTTONUP: case WM_RBUTTONUP: case WM_MBUTTONUP: if(GetFocus() != hwnd) SetFocus(hwnd); ReleaseCapture(); /* release mouse capture */ recordMouseEvent(lastMessage); break; /*keyboard events*/ case WM_KEYDOWN: case WM_SYSKEYDOWN: case WM_KEYUP: case WM_SYSKEYUP: case WM_CHAR: case WM_SYSCHAR: recordKeyboardEvent(lastMessage); break; /*window events*/ case WM_MOVE: case WM_SIZE: if ((GetWindowRect(hwnd, &boundingRect)) != 0){ sqWindowEvent *windowevent = (sqWindowEvent*) sqNextEventPut(); windowevent->type = EventTypeWindow; windowevent->timeStamp = lastMessage ? lastMessage->time : GetTickCount(); windowevent->action = WindowEventMetricChange; windowevent->value1 = boundingRect.left ; windowevent->value2 = boundingRect.top; windowevent->value3 = boundingRect.right; windowevent->value4 = boundingRect.bottom; windowevent->windowIndex =(int) hwnd; } break; case WM_PAINT: if ((GetWindowRect(hwnd, &boundingRect)) != 0){ sqWindowEvent *windowevent = (sqWindowEvent*) sqNextEventPut(); windowevent->type = EventTypeWindow; windowevent->timeStamp = lastMessage ? lastMessage->time : GetTickCount(); windowevent->action = WindowEventPaint; windowevent->value1 = boundingRect.left ; windowevent->value2 = boundingRect.top; windowevent->value3 = boundingRect.right; windowevent->value4 = boundingRect.bottom; windowevent->windowIndex =(int) hwnd; } break; case WM_CLOSE: { sqWindowEvent *windowevent = (sqWindowEvent*) sqNextEventPut(); windowevent->type = EventTypeWindow; windowevent->timeStamp = lastMessage ? lastMessage->time : GetTickCount(); windowevent->action = WindowEventClose; windowevent->windowIndex =(int) hwnd; } break; case WM_ACTIVATE: { sqWindowEvent *windowevent = (sqWindowEvent*) sqNextEventPut(); windowevent->type = EventTypeWindow; windowevent->timeStamp = lastMessage ? lastMessage->time : GetTickCount(); if (wParam == WA_INACTIVE) windowevent->action = WindowEventIconise; else windowevent->action = WindowEventActivated; windowevent->windowIndex =(int) hwnd; } break; case WM_GETMINMAXINFO: { sqWindowEvent *windowevent = (sqWindowEvent*) sqNextEventPut(); windowevent->type = EventTypeWindow; windowevent->timeStamp = lastMessage ? lastMessage->time : GetTickCount(); if (IsIconic(hwnd) != 0)windowevent->action = WindowEventIconise; else windowevent->action = WindowEventActivated; windowevent->windowIndex =(int) hwnd; } break; } return DefWindowProcW(hwnd,message,wParam,lParam); }
LRESULT CALLBACK Explorerplusplus::TabProxyWndProc(HWND hwnd,UINT Msg,WPARAM wParam,LPARAM lParam,int iTabId) { switch(Msg) { case WM_ACTIVATE: /* Restore the main window if necessary, and switch to the actual tab. */ if(IsIconic(m_hContainer)) { ShowWindow(m_hContainer,SW_RESTORE); } OnSelectTab(iTabId,FALSE); return 0; break; case WM_SETFOCUS: SetFocus(m_hListView[iTabId]); break; case WM_SYSCOMMAND: switch(wParam) { case SC_CLOSE: break; default: SendMessage(m_hListView[iTabId],WM_SYSCOMMAND,wParam,lParam); break; } break; /* Generate a thumbnail of the current tab. Basic procedure: 1. Generate a full-scale bitmap of the main window. 2. Overlay a bitmap of the specified tab onto the main window bitmap. 3. Shrink the resulting bitmap down to the correct thumbnail size. A thumbnail will be dynamically generated, provided the main window is not currently minimized (as we won't be able to grap a screenshot of it). If the main window is minimized, we'll use a cached screenshot of the tab (taken before the main window was minimized). */ case WM_DWMSENDICONICTHUMBNAIL: { HDC hdc; HDC hdcSrc; HBITMAP hbmTab = NULL; HBITMAP hPrevBitmap; Gdiplus::Color color(0,0,0); HRESULT hr; int iBitmapWidth; int iBitmapHeight; int iWidth; int iHeight; int iMaxWidth; int iMaxHeight; iMaxWidth = HIWORD(lParam); iMaxHeight = LOWORD(lParam); /* If the main window is minimized, it won't be possible to generate a thumbnail for any of the tabs. In that case, use a static 'No Preview Available' bitmap. */ if(IsIconic(m_hContainer)) { hbmTab = (HBITMAP)LoadImage(GetModuleHandle(0),MAKEINTRESOURCE(IDB_NOPREVIEWAVAILABLE),IMAGE_BITMAP,0,0,0); SetBitmapDimensionEx(hbmTab,223,130,NULL); } else { hbmTab = CaptureTabScreenshot(iTabId); } SIZE sz; GetBitmapDimensionEx(hbmTab,&sz); iBitmapWidth = sz.cx; iBitmapHeight = sz.cy; /* Shrink the bitmap. */ HDC hdcThumbnailSrc; HBITMAP hbmThumbnail; POINT pt; hdc = GetDC(m_hContainer); hdcSrc = CreateCompatibleDC(hdc); SelectObject(hdcSrc,hbmTab); hdcThumbnailSrc = CreateCompatibleDC(hdc); /* If the current height of the main window is less than the width, we'll create a thumbnail of maximum width; else maximum height. */ if((iBitmapWidth / iMaxWidth) > (iBitmapHeight / iMaxHeight)) { iWidth = iMaxWidth; iHeight = iMaxWidth * iBitmapHeight / iBitmapWidth; } else { iHeight = iMaxHeight; iWidth = iMaxHeight * iBitmapWidth / iBitmapHeight; } /* Thumbnail bitmap. */ Gdiplus::Bitmap bmpThumbnail(iWidth,iHeight,PixelFormat32bppARGB); bmpThumbnail.GetHBITMAP(color,&hbmThumbnail); hPrevBitmap = (HBITMAP)SelectObject(hdcThumbnailSrc,hbmThumbnail); /* Finally, shrink the full-scale bitmap down into a thumbnail. */ SetStretchBltMode(hdcThumbnailSrc,HALFTONE); SetBrushOrgEx(hdcThumbnailSrc,0,0,&pt); StretchBlt(hdcThumbnailSrc,0,0,iWidth,iHeight,hdcSrc,0,0,iBitmapWidth,iBitmapHeight,SRCCOPY); SelectObject(hdcThumbnailSrc,hPrevBitmap); DeleteDC(hdcThumbnailSrc); HMODULE hDwmapi; DwmSetIconicThumbnailProc DwmSetIconicThumbnail; hDwmapi = LoadLibrary(_T("dwmapi.dll")); if(hDwmapi != NULL) { DwmSetIconicThumbnail = (DwmSetIconicThumbnailProc)GetProcAddress(hDwmapi,"DwmSetIconicThumbnail"); if(DwmSetIconicThumbnail != NULL) { hr = DwmSetIconicThumbnail(hwnd,hbmThumbnail,0); } } FreeLibrary(hDwmapi); /* Delete the thumbnail bitmap. */ DeleteObject(hbmTab); SelectObject(hdcSrc,hPrevBitmap); DeleteObject(hbmThumbnail); DeleteDC(hdcSrc); ReleaseDC(m_hContainer,hdc); return 0; } break; case WM_DWMSENDICONICLIVEPREVIEWBITMAP: { HMODULE hDwmapi; TabPreviewInfo_t tpi; DwmSetIconicLivePreviewBitmapProc DwmSetIconicLivePreviewBitmap; tpi.hbm = NULL; if(IsIconic(m_hContainer)) { /* TODO: Show an image here... */ } else { GetTabLivePreviewBitmap(iTabId,&tpi); } hDwmapi = LoadLibrary(_T("dwmapi.dll")); if(hDwmapi != NULL) { DwmSetIconicLivePreviewBitmap = (DwmSetIconicLivePreviewBitmapProc)GetProcAddress(hDwmapi,"DwmSetIconicLivePreviewBitmap"); if(DwmSetIconicLivePreviewBitmap != NULL) { DwmSetIconicLivePreviewBitmap(hwnd,tpi.hbm,&tpi.ptOrigin,0); } } FreeLibrary(hDwmapi); if(tpi.hbm != NULL) { DeleteObject(tpi.hbm); } return 0; } break; case WM_CLOSE: { TCITEM tcItem; int nTabs; int i = 0; nTabs = TabCtrl_GetItemCount(m_hTabCtrl); if(nTabs == 1) { /* If this is the last tab, we'll close the whole application. */ SendMessage(m_hContainer,WM_CLOSE,0,0); } else { for(i = 0;i < nTabs;i++) { tcItem.mask = TCIF_PARAM; TabCtrl_GetItem(m_hTabCtrl,i,&tcItem); if((int)tcItem.lParam == iTabId) { /* Close the tab... */ CloseTab(i); break; } } } } break; } return DefWindowProc(hwnd,Msg,wParam,lParam); }
/* * MainWindowProc - procedure for main (root) window */ WINEXPORT LRESULT CALLBACK MainWindowProc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam ) { RECT rect; vi_rc rc; HANDLE hfileinfo; int cnt, i; char *buff; switch( msg ) { case WM_CREATE: root_window_id = hwnd; GetClientRect( hwnd, &rect ); edit_container_id = CreateContainerWindow( &rect ); InitWindows(); DragAcceptFiles( hwnd, TRUE ); timerID = SetTimer( hwnd, TIMER_ID, 60L * 1000L, NULL ); break; case WM_DROPFILES: hfileinfo = (HANDLE) wparam; cnt = DragQueryFile( hfileinfo, (UINT)-1, NULL, 0 ); buff = alloca( FILENAME_MAX + 2 ); /* we add a " at the beginning and at the end so we can handle path- and filenames with spaces */ if( buff != NULL ) { buff[0] = '"'; /* one " at the beginning of the filename */ for( i = 0; i < cnt; i++ ) { if( DragQueryFile( hfileinfo, i, buff + 1, FILENAME_MAX ) == (UINT)-1 ) { break; } strcat( buff, SingleQuote ); rc = EditFile( buff, false ); if( rc > ERR_NO_ERR ) { Error( GetErrorMsg( rc ) ); } } } DragFinish( hfileinfo ); break; case WM_TIMER: UpdateStatusWindow(); break; case WM_KEYDOWN: if( WindowsKeyPush( wparam, HIWORD( lparam ) ) ) { return( 0 ); } break; case WM_SIZE: DefFrameProc( hwnd, edit_container_id, msg, wparam, lparam ); RootState = wparam; if( wparam != SIZE_MINIMIZED ) { ResizeRoot(); GetWindowRect( hwnd, &RootRect ); if( wparam != SIZE_MAXIMIZED ) { RootState = 0; } } return( 0 ); case WM_MOVE: DefFrameProc( hwnd, edit_container_id, msg, wparam, lparam ); if( RootState != SIZE_MINIMIZED ) { GetWindowRect( hwnd, &RootRect ); } return( 0 ); case WM_ACTIVATEAPP: if( BAD_ID( current_window_id ) ) { break; } SetFocus( root_window_id ); #if 0 if( !wparam ) { InactiveWindow( current_window_id ); } else { SendMessage( edit_container_id, WM_MDIACTIVATE, (WPARAM)current_window_id, 0L ); } #endif if( wparam ) { ResetEditWindowCursor( current_window_id ); } else { GoodbyeCursor( current_window_id ); } break; case WM_MOUSEACTIVATE: SetFocus( hwnd ); return( MA_ACTIVATE ); case WM_SETFOCUS: if( BAD_ID( current_window_id ) ) { break; } if( !IsIconic( current_window_id ) ) { SendMessage( edit_container_id, WM_MDIACTIVATE, (WPARAM)current_window_id, 0L ); DCUpdate(); SetWindowCursor(); SetWindowCursorForReal(); return( 0 ); } break; case WM_NCLBUTTONDBLCLK: break; case WM_COMMAND: if( LOWORD( wparam ) > 0xF000 ) { break; } else { rc = MenuCommand( LOWORD( wparam ) ); if( rc != MENU_COMMAND_NOT_HANDLED ) { DCUpdateAll(); if( rc > ERR_NO_ERR ) { buff = GetErrorMsg( rc ); Error( buff ); } } SetWindowCursor(); } return( 0 ); case WM_INITMENU: if( (HMENU)wparam == GetMenu( hwnd ) ) { HandleInitMenu( (HMENU)wparam ); } else { ResetMenuBits(); } break; case WM_MENUSELECT: HandleMenuSelect( wparam, lparam ); break; case WM_ENDSESSION: if( wparam ) { ExitEditor( 0 ); // will not return } return( 0 ); case WM_QUERYENDSESSION: return( ExitWithPrompt( false, true ) ); case WM_CLOSE: ExitWithPrompt( true, true ); return( 0 ); #ifdef __NT__ case WM_MOUSEWHEEL: { int increment; ULONG linesPerNotch; HWND activeWnd; activeWnd = (HWND)SendMessage( edit_container_id, WM_MDIGETACTIVE, 0, 0 ); SystemParametersInfo( SPI_GETWHEELSCROLLLINES, 0, &linesPerNotch, 0 ); increment = GET_WHEEL_DELTA_WPARAM( wparam ) / 120; // see WM_MOUSEWHEEL-documentation for information about the "120" if( increment > 0 ) { for( i = 0; i < increment * (int)linesPerNotch; i++ ) { SendMessage( activeWnd, WM_VSCROLL, SB_LINEUP, 0 ); } } else { for( i = 0; i < (-increment) * (int)linesPerNotch; i++ ) { SendMessage( activeWnd, WM_VSCROLL, SB_LINEDOWN, 0 ); } } } return( 0 ); #endif case WM_DESTROY: DestroyToolBar(); DragAcceptFiles( hwnd, FALSE ); edit_container_id = NO_WINDOW; if( timerID ) { KillTimer( hwnd, TIMER_ID ); } return( 0 ); } return( DefFrameProc( hwnd, edit_container_id, msg, wparam, lparam ) ); } /* MainWindowProc */
LRESULT CALLBACK winMWExtWMWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { WindowPtr pWin = NULL; win32RootlessWindowPtr pRLWinPriv = NULL; ScreenPtr pScreen = NULL; winPrivScreenPtr pScreenPriv = NULL; winScreenInfo *pScreenInfo = NULL; HWND hwndScreen = NULL; POINT ptMouse; static Bool s_fTracking = FALSE; HDC hdcUpdate; PAINTSTRUCT ps; LPWINDOWPOS pWinPos = NULL; RECT rcClient; winWMMessageRec wmMsg; Bool fWMMsgInitialized = FALSE; /* Check if the Windows window property for our X window pointer is valid */ if ((pRLWinPriv = (win32RootlessWindowPtr) GetProp(hwnd, WIN_WINDOW_PROP)) != NULL) { pWin = pRLWinPriv->pFrame->win; pScreen = pWin->drawable.pScreen; if (pScreen) pScreenPriv = winGetScreenPriv(pScreen); if (pScreenPriv) pScreenInfo = pScreenPriv->pScreenInfo; if (pScreenPriv) hwndScreen = pScreenPriv->hwndScreen; wmMsg.msg = 0; wmMsg.hwndWindow = hwnd; wmMsg.iWindow = (Window) pWin->drawable.id; wmMsg.iX = pRLWinPriv->pFrame->x; wmMsg.iY = pRLWinPriv->pFrame->y; wmMsg.iWidth = pRLWinPriv->pFrame->width; wmMsg.iHeight = pRLWinPriv->pFrame->height; fWMMsgInitialized = TRUE; #if CYGDEBUG winDebugWin32Message("winMWExtWMWindowProc", hwnd, message, wParam, lParam); winDebug("\thWnd %08X\n", hwnd); winDebug("\tpScreenPriv %08X\n", pScreenPriv); winDebug("\tpScreenInfo %08X\n", pScreenInfo); winDebug("\thwndScreen %08X\n", hwndScreen); winDebug("winMWExtWMWindowProc (%08x) %08x %08x %08x\n", pRLWinPriv, message, wParam, lParam); #endif } /* Branch on message type */ switch (message) { case WM_CREATE: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_CREATE\n"); #endif /* */ SetProp(hwnd, WIN_WINDOW_PROP, (HANDLE) ((LPCREATESTRUCT) lParam)->lpCreateParams); return 0; case WM_CLOSE: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_CLOSE %d\n", pRLWinPriv->fClose); #endif /* Tell window-manager to close window */ if (pRLWinPriv->fClose) { DestroyWindow(hwnd); } else { if (winIsInternalWMRunning(pScreenInfo)) { /* Tell our Window Manager thread to kill the window */ wmMsg.msg = WM_WM_KILL; if (fWMMsgInitialized) winSendMessageToWM(pScreenPriv->pWMInfo, &wmMsg); } winWindowsWMSendEvent(WindowsWMControllerNotify, WindowsWMControllerNotifyMask, 1, WindowsWMCloseWindow, pWin->drawable.id, 0, 0, 0, 0); } return 0; case WM_DESTROY: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_DESTROY\n"); #endif /* Free the shaodw DC; which allows the bitmap to be freed */ DeleteDC(pRLWinPriv->hdcShadow); pRLWinPriv->hdcShadow = NULL; /* Free the shadow bitmap */ DeleteObject(pRLWinPriv->hbmpShadow); pRLWinPriv->hbmpShadow = NULL; /* Free the screen DC */ ReleaseDC(pRLWinPriv->hWnd, pRLWinPriv->hdcScreen); pRLWinPriv->hdcScreen = NULL; /* Free shadow buffer info header */ free(pRLWinPriv->pbmihShadow); pRLWinPriv->pbmihShadow = NULL; pRLWinPriv->fResized = FALSE; pRLWinPriv->pfb = NULL; free(pRLWinPriv); RemoveProp(hwnd, WIN_WINDOW_PROP); break; case WM_MOUSEMOVE: #if CYGMULTIWINDOW_DEBUG && 0 winDebug("winMWExtWMWindowProc - WM_MOUSEMOVE\n"); #endif /* Unpack the client area mouse coordinates */ ptMouse.x = GET_X_LPARAM(lParam); ptMouse.y = GET_Y_LPARAM(lParam); /* Translate the client area mouse coordinates to screen coordinates */ ClientToScreen(hwnd, &ptMouse); /* Screen Coords from (-X, -Y) -> Root Window (0, 0) */ ptMouse.x -= GetSystemMetrics(SM_XVIRTUALSCREEN); ptMouse.y -= GetSystemMetrics(SM_YVIRTUALSCREEN); /* We can't do anything without privates */ if (pScreenPriv == NULL || pScreenInfo->fIgnoreInput) break; /* Has the mouse pointer crossed screens? */ if (pScreen != miPointerGetScreen(inputInfo.pointer)) miPointerSetScreen(inputInfo.pointer, pScreenInfo->dwScreen, ptMouse.x - pScreenInfo->dwXOffset, ptMouse.y - pScreenInfo->dwYOffset); /* Are we tracking yet? */ if (!s_fTracking) { TRACKMOUSEEVENT tme; /* Setup data structure */ ZeroMemory(&tme, sizeof(tme)); tme.cbSize = sizeof(tme); tme.dwFlags = TME_LEAVE; tme.hwndTrack = hwnd; /* Call the tracking function */ if (!TrackMouseEvent(&tme)) ErrorF("winMWExtWMWindowProc - TrackMouseEvent failed\n"); /* Flag that we are tracking now */ s_fTracking = TRUE; } /* Kill the timer used to poll mouse events */ if (g_uipMousePollingTimerID != 0) { KillTimer(pScreenPriv->hwndScreen, WIN_POLLING_MOUSE_TIMER_ID); g_uipMousePollingTimerID = 0; } /* Deliver absolute cursor position to X Server */ winEnqueueMotion(ptMouse.x - pScreenInfo->dwXOffset, ptMouse.y - pScreenInfo->dwYOffset); return 0; case WM_NCMOUSEMOVE: #if CYGMULTIWINDOW_DEBUG && 0 winDebug("winMWExtWMWindowProc - WM_NCMOUSEMOVE\n"); #endif /* * We break instead of returning 0 since we need to call * DefWindowProc to get the mouse cursor changes * and min/max/close button highlighting in Windows XP. * The Platform SDK says that you should return 0 if you * process this message, but it fails to mention that you * will give up any default functionality if you do return 0. */ /* We can't do anything without privates */ if (pScreenPriv == NULL || pScreenInfo->fIgnoreInput) break; /* * Timer to poll mouse events. This is needed to make * programs like xeyes follow the mouse properly. */ if (g_uipMousePollingTimerID == 0) g_uipMousePollingTimerID = SetTimer(pScreenPriv->hwndScreen, WIN_POLLING_MOUSE_TIMER_ID, MOUSE_POLLING_INTERVAL, NULL); break; case WM_MOUSELEAVE: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_MOUSELEAVE\n"); #endif /* Mouse has left our client area */ /* Flag that we are no longer tracking */ s_fTracking = FALSE; /* * Timer to poll mouse events. This is needed to make * programs like xeyes follow the mouse properly. */ if (g_uipMousePollingTimerID == 0) g_uipMousePollingTimerID = SetTimer(pScreenPriv->hwndScreen, WIN_POLLING_MOUSE_TIMER_ID, MOUSE_POLLING_INTERVAL, NULL); return 0; case WM_LBUTTONDBLCLK: case WM_LBUTTONDOWN: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_LBUTTONDBLCLK\n"); #endif if (pScreenPriv == NULL || pScreenInfo->fIgnoreInput) break; SetCapture(hwnd); return winMouseButtonsHandle(pScreen, ButtonPress, Button1, wParam); case WM_LBUTTONUP: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_LBUTTONUP\n"); #endif if (pScreenPriv == NULL || pScreenInfo->fIgnoreInput) break; ReleaseCapture(); return winMouseButtonsHandle(pScreen, ButtonRelease, Button1, wParam); case WM_MBUTTONDBLCLK: case WM_MBUTTONDOWN: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_MBUTTONDBLCLK\n"); #endif if (pScreenPriv == NULL || pScreenInfo->fIgnoreInput) break; SetCapture(hwnd); return winMouseButtonsHandle(pScreen, ButtonPress, Button2, wParam); case WM_MBUTTONUP: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_MBUTTONUP\n"); #endif if (pScreenPriv == NULL || pScreenInfo->fIgnoreInput) break; ReleaseCapture(); return winMouseButtonsHandle(pScreen, ButtonRelease, Button2, wParam); case WM_RBUTTONDBLCLK: case WM_RBUTTONDOWN: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_RBUTTONDBLCLK\n"); #endif if (pScreenPriv == NULL || pScreenInfo->fIgnoreInput) break; SetCapture(hwnd); return winMouseButtonsHandle(pScreen, ButtonPress, Button3, wParam); case WM_RBUTTONUP: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_RBUTTONUP\n"); #endif if (pScreenPriv == NULL || pScreenInfo->fIgnoreInput) break; ReleaseCapture(); return winMouseButtonsHandle(pScreen, ButtonRelease, Button3, wParam); case WM_XBUTTONDBLCLK: case WM_XBUTTONDOWN: if (pScreenPriv == NULL || pScreenInfo->fIgnoreInput) break; SetCapture(hwnd); return winMouseButtonsHandle(pScreen, ButtonPress, HIWORD(wParam) + 5, wParam); case WM_XBUTTONUP: if (pScreenPriv == NULL || pScreenInfo->fIgnoreInput) break; ReleaseCapture(); return winMouseButtonsHandle(pScreen, ButtonRelease, HIWORD(wParam) + 5, wParam); case WM_MOUSEWHEEL: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_MOUSEWHEEL\n"); #endif /* Pass the message to the root window */ SendMessage(hwndScreen, message, wParam, lParam); return 0; case WM_MOUSEACTIVATE: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_MOUSEACTIVATE\n"); #endif #if 1 /* Check if this window needs to be made active when clicked */ if (winIsInternalWMRunning(pScreenInfo) && pWin->overrideRedirect) { #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_MOUSEACTIVATE - " "MA_NOACTIVATE\n"); #endif /* */ return MA_NOACTIVATE; } #endif if (!winIsInternalWMRunning(pScreenInfo) && !IsMouseActive(pWin)) return MA_NOACTIVATE; break; case WM_KILLFOCUS: /* Pop any pressed keys since we are losing keyboard focus */ winKeybdReleaseKeys(); return 0; case WM_SYSDEADCHAR: case WM_DEADCHAR: /* * NOTE: We do nothing with WM_*CHAR messages, * nor does the root window, so we can just toss these messages. */ return 0; case WM_SYSKEYDOWN: case WM_KEYDOWN: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_*KEYDOWN\n"); #endif /* * Don't pass Alt-F4 key combo to root window, * let Windows translate to WM_CLOSE and close this top-level window. * * NOTE: We purposely don't check the fUseWinKillKey setting because * it should only apply to the key handling for the root window, * not for top-level window-manager windows. * * ALSO NOTE: We do pass Ctrl-Alt-Backspace to the root window * because that is a key combo that no X app should be expecting to * receive, since it has historically been used to shutdown the X server. * Passing Ctrl-Alt-Backspace to the root window preserves that * behavior, assuming that -unixkill has been passed as a parameter. */ if (wParam == VK_F4 && (GetKeyState(VK_MENU) & 0x8000)) break; /* Pass the message to the root window */ SendMessage(hwndScreen, message, wParam, lParam); return 0; case WM_SYSKEYUP: case WM_KEYUP: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_*KEYUP\n"); #endif /* Pass the message to the root window */ SendMessage(hwndScreen, message, wParam, lParam); return 0; case WM_HOTKEY: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_HOTKEY\n"); #endif /* Pass the message to the root window */ SendMessage(hwndScreen, message, wParam, lParam); return 0; case WM_ERASEBKGND: #if CYGDEBUG winDebug("winMWExtWMWindowProc - WM_ERASEBKGND\n"); #endif /* * Pretend that we did erase the background but we don't care, * since we repaint the entire region anyhow * This avoids some flickering when resizing. */ return TRUE; case WM_PAINT: /* BeginPaint gives us an hdc that clips to the invalidated region */ hdcUpdate = BeginPaint(hwnd, &ps); /* Try to copy from the shadow buffer */ if (!BitBlt(hdcUpdate, ps.rcPaint.left, ps.rcPaint.top, ps.rcPaint.right - ps.rcPaint.left, ps.rcPaint.bottom - ps.rcPaint.top, pRLWinPriv->hdcShadow, ps.rcPaint.left, ps.rcPaint.top, SRCCOPY)) { LPVOID lpMsgBuf; /* Display a fancy error message */ FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL); ErrorF("winMWExtWMWindowProc - BitBlt failed: %s\n", (LPSTR) lpMsgBuf); LocalFree(lpMsgBuf); } /* EndPaint frees the DC */ EndPaint(hwnd, &ps); break; case WM_ACTIVATE: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_ACTIVATE\n"); #endif if (LOWORD(wParam) != WA_INACTIVE) { if (winIsInternalWMRunning(pScreenInfo)) { #if 0 /* Raise the window to the top in Z order */ wmMsg.msg = WM_WM_RAISE; if (fWMMsgInitialized) winSendMessageToWM(pScreenPriv->pWMInfo, &wmMsg); #endif /* Tell our Window Manager thread to activate the window */ wmMsg.msg = WM_WM_ACTIVATE; if (fWMMsgInitialized) if (!pWin || !pWin->overrideRedirect) /* for OOo menus */ winSendMessageToWM(pScreenPriv->pWMInfo, &wmMsg); } winWindowsWMSendEvent(WindowsWMControllerNotify, WindowsWMControllerNotifyMask, 1, WindowsWMActivateWindow, pWin->drawable.id, 0, 0, 0, 0); } return 0; #if 1 case WM_WINDOWPOSCHANGING: pWinPos = (LPWINDOWPOS) lParam; if (!(pWinPos->flags & SWP_NOZORDER)) { if (pRLWinPriv->fRestackingNow || pScreenPriv->fRestacking) { #if CYGMULTIWINDOW_DEBUG winDebug("Win %08x is now restacking.\n", (unsigned int) pRLWinPriv); #endif break; } if (winIsInternalWMRunning(pScreenInfo) || IsRaiseOnClick(pWin)) { #if CYGMULTIWINDOW_DEBUG winDebug("Win %08x has WINDOWSWM_RAISE_ON_CLICK.\n", (unsigned int) pRLWinPriv); #endif break; } #if CYGMULTIWINDOW_DEBUG winDebug("Win %08x forbid to change z order (%08x).\n", (unsigned int) pRLWinPriv, (unsigned int) pWinPos->hwndInsertAfter); #endif pWinPos->flags |= SWP_NOZORDER; } break; #endif case WM_MOVE: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_MOVE - %d ms\n", (unsigned int) GetTickCount()); #endif if (g_fNoConfigureWindow) break; #if 0 /* Bail if Windows window is not actually moving */ if (pRLWinPriv->dwX == (short) LOWORD(lParam) && pRLWinPriv->dwY == (short) HIWORD(lParam)) break; /* Also bail if we're maximizing, we'll do the whole thing in WM_SIZE */ { WINDOWPLACEMENT windPlace; windPlace.length = sizeof(WINDOWPLACEMENT); /* Get current window placement */ GetWindowPlacement(hwnd, &windPlace); /* Bail if maximizing */ if (windPlace.showCmd == SW_MAXIMIZE || windPlace.showCmd == SW_SHOWMAXIMIZED) break; } #endif #if CYGMULTIWINDOW_DEBUG winDebug("\t(%d, %d)\n", (short) LOWORD(lParam), (short) HIWORD(lParam)); #endif if (!pRLWinPriv->fMovingOrSizing) { if (winIsInternalWMRunning(pScreenInfo)) winAdjustXWindow(pWin, hwnd); winMWExtWMMoveXWindow(pWin, (LOWORD(lParam) - wBorderWidth(pWin) - GetSystemMetrics(SM_XVIRTUALSCREEN)), (HIWORD(lParam) - wBorderWidth(pWin) - GetSystemMetrics(SM_YVIRTUALSCREEN))); } return 0; case WM_SHOWWINDOW: #if CYGMULTIWINDOW_DEBUG || TRUE winDebug("winMWExtWMWindowProc - WM_SHOWWINDOW - %d ms\n", (unsigned int) GetTickCount()); #endif /* Bail out if the window is being hidden */ if (!wParam) return 0; if (!pScreenInfo->fInternalWM) //XXXX return 0; winMWExtWMUpdateWindowDecoration(pRLWinPriv, pScreenInfo); if (winIsInternalWMRunning(pScreenInfo)) { #if CYGMULTIWINDOW_DEBUG || TRUE winDebug("\tMapWindow\n"); #endif /* Tell X to map the window */ MapWindow(pWin, wClient(pWin)); if (!pRLWinPriv->pFrame->win->overrideRedirect) /* Bring the Windows window to the foreground */ SetForegroundWindow(hwnd); /* Setup the Window Manager message */ wmMsg.msg = WM_WM_MAP; wmMsg.iWidth = pRLWinPriv->pFrame->width; wmMsg.iHeight = pRLWinPriv->pFrame->height; /* Tell our Window Manager thread to map the window */ if (fWMMsgInitialized) winSendMessageToWM(pScreenPriv->pWMInfo, &wmMsg); } break; case WM_SIZING: /* Need to legalize the size according to WM_NORMAL_HINTS */ /* for applications like xterm */ return ValidateSizing(hwnd, pWin, wParam, lParam); case WM_WINDOWPOSCHANGED: { pWinPos = (LPWINDOWPOS) lParam; #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_WINDOWPOSCHANGED\n"); winDebug("\tflags: %s%s%s%s%s%s%s%s%s%s%s%s\n", (pWinPos->flags & SWP_DRAWFRAME) ? "SWP_DRAWFRAME " : "", (pWinPos->flags & SWP_FRAMECHANGED) ? "SWP_FRAMECHANGED " : "", (pWinPos->flags & SWP_HIDEWINDOW) ? "SWP_HIDEWINDOW " : "", (pWinPos->flags & SWP_NOACTIVATE) ? "SWP_NOACTIVATE " : "", (pWinPos->flags & SWP_NOCOPYBITS) ? "SWP_NOCOPYBITS " : "", (pWinPos->flags & SWP_NOMOVE) ? "SWP_NOMOVE " : "", (pWinPos-> flags & SWP_NOOWNERZORDER) ? "SWP_NOOWNERZORDER " : "", (pWinPos->flags & SWP_NOSIZE) ? "SWP_NOSIZE " : "", (pWinPos->flags & SWP_NOREDRAW) ? "SWP_NOREDRAW " : "", (pWinPos-> flags & SWP_NOSENDCHANGING) ? "SWP_NOSENDCHANGING " : "", (pWinPos->flags & SWP_NOZORDER) ? "SWP_NOZORDER " : "", (pWinPos->flags & SWP_SHOWWINDOW) ? "SWP_SHOWWINDOW " : ""); winDebug("\tno_configure: %s\n", (g_fNoConfigureWindow ? "Yes" : "No")); winDebug("\textend: (%d, %d, %d, %d)\n", pWinPos->x, pWinPos->y, pWinPos->cx, pWinPos->cy); #endif if (pWinPos->flags & SWP_HIDEWINDOW) break; /* Reorder if window z order was changed */ if ((pScreenPriv != NULL) && !(pWinPos->flags & SWP_NOZORDER) && !(pWinPos->flags & SWP_SHOWWINDOW) && winIsInternalWMRunning(pScreenInfo)) { #if CYGMULTIWINDOW_DEBUG winDebug("\twindow z order was changed\n"); #endif if (pWinPos->hwndInsertAfter == HWND_TOP || pWinPos->hwndInsertAfter == HWND_TOPMOST || pWinPos->hwndInsertAfter == HWND_NOTOPMOST) { #if CYGMULTIWINDOW_DEBUG winDebug("\traise to top\n"); #endif /* Raise the window to the top in Z order */ wmMsg.msg = WM_WM_RAISE; if (fWMMsgInitialized) winSendMessageToWM(pScreenPriv->pWMInfo, &wmMsg); } #if 1 else if (pWinPos->hwndInsertAfter == HWND_BOTTOM) { } else { /* Check if this window is top of X windows. */ HWND hWndAbove = NULL; DWORD dwCurrentProcessID = GetCurrentProcessId(); DWORD dwWindowProcessID = 0; for (hWndAbove = pWinPos->hwndInsertAfter; hWndAbove != NULL; hWndAbove = GetNextWindow(hWndAbove, GW_HWNDPREV)) { /* Ignore other XWin process's window */ GetWindowThreadProcessId(hWndAbove, &dwWindowProcessID); if ((dwWindowProcessID == dwCurrentProcessID) && GetProp(hWndAbove, WIN_WINDOW_PROP) && !IsWindowVisible(hWndAbove) && !IsIconic(hWndAbove)) /* ignore minimized windows */ break; } /* If this is top of X windows in Windows stack, raise it in X stack. */ if (hWndAbove == NULL) { #if CYGMULTIWINDOW_DEBUG winDebug("\traise to top\n"); #endif /* Raise the window to the top in Z order */ wmMsg.msg = WM_WM_RAISE; if (fWMMsgInitialized) winSendMessageToWM(pScreenPriv->pWMInfo, &wmMsg); } } #endif } if (!(pWinPos->flags & SWP_NOSIZE)) { if (IsIconic(hwnd)) { #if CYGMULTIWINDOW_DEBUG winDebug("\tIconic -> MINIMIZED\n"); #endif if (winIsInternalWMRunning(pScreenInfo)) { /* Raise the window to the top in Z order */ wmMsg.msg = WM_WM_LOWER; if (fWMMsgInitialized) winSendMessageToWM(pScreenPriv->pWMInfo, &wmMsg); } winWindowsWMSendEvent(WindowsWMControllerNotify, WindowsWMControllerNotifyMask, 1, WindowsWMMinimizeWindow, pWin->drawable.id, 0, 0, 0, 0); } else if (IsZoomed(hwnd)) { #if CYGMULTIWINDOW_DEBUG winDebug("\tZoomed -> MAXIMIZED\n"); #endif winWindowsWMSendEvent(WindowsWMControllerNotify, WindowsWMControllerNotifyMask, 1, WindowsWMMaximizeWindow, pWin->drawable.id, 0, 0, 0, 0); } else { #if CYGMULTIWINDOW_DEBUG winDebug("\tnone -> RESTORED\n"); #endif winWindowsWMSendEvent(WindowsWMControllerNotify, WindowsWMControllerNotifyMask, 1, WindowsWMRestoreWindow, pWin->drawable.id, 0, 0, 0, 0); } } if (!g_fNoConfigureWindow) { if (!pRLWinPriv->fMovingOrSizing /*&& (pWinPos->flags & SWP_SHOWWINDOW) */ ) { GetClientRect(hwnd, &rcClient); MapWindowPoints(hwnd, HWND_DESKTOP, (LPPOINT) &rcClient, 2); if (!(pWinPos->flags & SWP_NOMOVE) && !(pWinPos->flags & SWP_NOSIZE)) { #if CYGMULTIWINDOW_DEBUG winDebug("\tmove & resize\n"); #endif if (winIsInternalWMRunning(pScreenInfo)) winAdjustXWindow(pWin, hwnd); winMWExtWMMoveResizeXWindow(pWin, rcClient.left - wBorderWidth(pWin) - GetSystemMetrics (SM_XVIRTUALSCREEN), rcClient.top - wBorderWidth(pWin) - GetSystemMetrics (SM_YVIRTUALSCREEN), rcClient.right - rcClient.left - wBorderWidth(pWin) * 2, rcClient.bottom - rcClient.top - wBorderWidth(pWin) * 2); } else if (!(pWinPos->flags & SWP_NOMOVE)) { #if CYGMULTIWINDOW_DEBUG winDebug("\tmove\n"); #endif if (winIsInternalWMRunning(pScreenInfo)) winAdjustXWindow(pWin, hwnd); winMWExtWMMoveResizeXWindow(pWin, rcClient.left - wBorderWidth(pWin) - GetSystemMetrics (SM_XVIRTUALSCREEN), rcClient.top - wBorderWidth(pWin) - GetSystemMetrics (SM_YVIRTUALSCREEN), rcClient.right - rcClient.left - wBorderWidth(pWin) * 2, rcClient.bottom - rcClient.top - wBorderWidth(pWin) * 2); } else if (!(pWinPos->flags & SWP_NOMOVE)) { #if CYGMULTIWINDOW_DEBUG winDebug("\tmove\n"); #endif if (winIsInternalWMRunning(pScreenInfo)) winAdjustXWindow(pWin, hwnd); winMWExtWMMoveXWindow(pWin, rcClient.left - wBorderWidth(pWin) - GetSystemMetrics(SM_XVIRTUALSCREEN), rcClient.top - wBorderWidth(pWin) - GetSystemMetrics(SM_YVIRTUALSCREEN)); } else if (!(pWinPos->flags & SWP_NOSIZE)) { #if CYGMULTIWINDOW_DEBUG winDebug("\tresize\n"); #endif if (winIsInternalWMRunning(pScreenInfo)) winAdjustXWindow(pWin, hwnd); winMWExtWMResizeXWindow(pWin, rcClient.right - rcClient.left - wBorderWidth(pWin) * 2, rcClient.bottom - rcClient.top - wBorderWidth(pWin) * 2); } } } } #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_WINDOWPOSCHANGED - done.\n"); #endif return 0; case WM_SIZE: /* see dix/window.c */ /* FIXME: Maximize/Restore? */ #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_SIZE - %d ms\n", (unsigned int) GetTickCount()); #endif #if CYGMULTIWINDOW_DEBUG winDebug("\t(%d, %d) %d\n", (short) LOWORD(lParam), (short) HIWORD(lParam), g_fNoConfigureWindow); #endif if (g_fNoConfigureWindow) break; /* Branch on type of resizing occurring */ switch (wParam) { case SIZE_MINIMIZED: #if CYGMULTIWINDOW_DEBUG winDebug("\tSIZE_MINIMIZED\n"); #endif if (winIsInternalWMRunning(pScreenInfo)) { /* Raise the window to the top in Z order */ wmMsg.msg = WM_WM_LOWER; if (fWMMsgInitialized) winSendMessageToWM(pScreenPriv->pWMInfo, &wmMsg); } winWindowsWMSendEvent(WindowsWMControllerNotify, WindowsWMControllerNotifyMask, 1, WindowsWMMinimizeWindow, pWin->drawable.id, 0, 0, LOWORD(lParam), HIWORD(lParam)); break; case SIZE_RESTORED: #if CYGMULTIWINDOW_DEBUG winDebug("\tSIZE_RESTORED\n"); #endif winWindowsWMSendEvent(WindowsWMControllerNotify, WindowsWMControllerNotifyMask, 1, WindowsWMRestoreWindow, pWin->drawable.id, 0, 0, LOWORD(lParam), HIWORD(lParam)); break; case SIZE_MAXIMIZED: #if CYGMULTIWINDOW_DEBUG winDebug("\tSIZE_MAXIMIZED\n"); #endif winWindowsWMSendEvent(WindowsWMControllerNotify, WindowsWMControllerNotifyMask, 1, WindowsWMMaximizeWindow, pWin->drawable.id, 0, 0, LOWORD(lParam), HIWORD(lParam)); break; } /* Perform the resize and notify the X client */ if (!pRLWinPriv->fMovingOrSizing) { if (winIsInternalWMRunning(pScreenInfo)) winAdjustXWindow(pWin, hwnd); winMWExtWMResizeXWindow(pWin, (short) LOWORD(lParam) - wBorderWidth(pWin) * 2, (short) HIWORD(lParam) - wBorderWidth(pWin) * 2); } break; case WM_ACTIVATEAPP: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_ACTIVATEAPP - %d ms\n", (unsigned int) GetTickCount()); #endif if (wParam) { if (winIsInternalWMRunning(pScreenInfo)) { } else { } winWindowsWMSendEvent(WindowsWMActivationNotify, WindowsWMActivationNotifyMask, 1, WindowsWMIsActive, pWin->drawable.id, 0, 0, 0, 0); } else { winWindowsWMSendEvent(WindowsWMActivationNotify, WindowsWMActivationNotifyMask, 1, WindowsWMIsInactive, pWin->drawable.id, 0, 0, 0, 0); } break; case WM_SETCURSOR: if (LOWORD(lParam) == HTCLIENT) { if (!g_fSoftwareCursor) SetCursor(pScreenPriv->cursor.handle); return TRUE; } break; case WM_ENTERSIZEMOVE: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_ENTERSIZEMOVE - %d ms\n", (unsigned int) GetTickCount()); #endif pRLWinPriv->fMovingOrSizing = TRUE; break; case WM_EXITSIZEMOVE: #if CYGMULTIWINDOW_DEBUG winDebug("winMWExtWMWindowProc - WM_EXITSIZEMOVE - %d ms\n", (unsigned int) GetTickCount()); #endif pRLWinPriv->fMovingOrSizing = FALSE; GetClientRect(hwnd, &rcClient); MapWindowPoints(hwnd, HWND_DESKTOP, (LPPOINT) &rcClient, 2); if (winIsInternalWMRunning(pScreenInfo)) winAdjustXWindow(pWin, hwnd); winMWExtWMMoveResizeXWindow(pWin, rcClient.left - wBorderWidth(pWin) - GetSystemMetrics(SM_XVIRTUALSCREEN), rcClient.top - wBorderWidth(pWin) - GetSystemMetrics(SM_YVIRTUALSCREEN), rcClient.right - rcClient.left - wBorderWidth(pWin) * 2, rcClient.bottom - rcClient.top - wBorderWidth(pWin) * 2); break; case WM_MANAGE: ErrorF("winMWExtWMWindowProc - WM_MANAGE\n"); break; case WM_UNMANAGE: ErrorF("winMWExtWMWindowProc - WM_UNMANAGE\n"); break; default: break; } return DefWindowProc(hwnd, message, wParam, lParam); }
void CTwoOptDlg::OnPaint() { // device context for painting //CDC memDC ; // buffer context CPaintDC dc(this); if (IsIconic()) { SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0); // Center icon in client rectangle int cxIcon = GetSystemMetrics(SM_CXICON); int cyIcon = GetSystemMetrics(SM_CYICON); CRect rect; GetClientRect(&rect); int x = (rect.Width() - cxIcon + 1) / 2; int y = (rect.Height() - cyIcon + 1) / 2; // Draw the icon dc.DrawIcon(x, y, m_hIcon); } else { if ( CoordsMatrix_.size() < 1 ) return; // device context for painting CPen penDot(PS_DOT,1,RGB(255,0,0)); CPen penblack(PS_SOLID,3,RGB(0,0,0)); CRect rect; GetClientRect(&rect); int rectx1 = rect.left + 20; int rectx2 = rect.right - 170; int recty1 = rect.top + 25; int recty2 = rect.bottom - bottom_limit; dc.Rectangle(rectx1-5,recty1-5,rectx2+5,recty2+5); // Plot each node size_t tour_size = CoordsMatrix_.size(); for ( count = 0; count < tour_size; count++ ) { Coords mat = CoordsMatrix_[count]; xc1 =static_cast<int>(mat.GetX()); yc1 = static_cast<int>(mat.GetY()); xn1 = (float) ( xc1 - MinX ) / (float) ( MaxX - MinX ); yn1 = (float) ( yc1 - MinY ) / (float) ( MaxY - MinY ); xcoord1 = rectx1 + (int) (float) ( xn1 * abs( rectx1 - rectx2 ) ); ycoord1 = recty2 - (int) (float) ( yn1 * abs( recty1 - recty2 ) ); dc.SelectObject(&penblack); dc.Ellipse( xcoord1 - 2, ycoord1 - 2, xcoord1 + 2, ycoord1 + 2 ); //draw lines dc.SelectObject(&penDot); //draw last tour if ( hasRun && count < tour_size - 1 && m_lasttour.Tour.size()) { m_lasttour.Tour[count]; cc1 = static_cast<int>(m_lasttour.Tour[count]); cc2 = static_cast<int>(m_lasttour.Tour[count +1]); DrawNodes(cc1 , cc2, rectx1, rectx2, recty2, recty1, dc); } dc.SelectObject(&penblack); if ( hasRun && count < tour_size - 1 && m_besttour.Tour.size()) { cc1 = static_cast<int>(m_besttour.Tour[count]); cc2 = static_cast<int>(m_besttour.Tour[count +1]); DrawNodes(cc1 , cc2, rectx1, rectx2, recty2, recty1, dc); } } // Draw final link if ( hasRun ) { if(m_lasttour.Tour.size()) { cc1 = static_cast<int>(m_lasttour.Tour[tour_size-1]); cc2 = static_cast<int>( m_lasttour.Tour[0]); dc.SelectObject(&penDot); DrawNodes(cc1 , cc2, rectx1, rectx2, recty2, recty1, dc); } if(m_besttour.Tour.size()) { dc.SelectObject(&penblack); cc1 = static_cast<int>(m_besttour.Tour[tour_size-1]); cc2 = static_cast<int>(m_besttour.Tour[0]); DrawNodes(cc1 , cc2, rectx1, rectx2, recty2, recty1, dc); } } CDialogEx::OnPaint(); } }
BOOL TWIN_DriverMessage(LPMSG lpMsg, HWND hWnd, UINT uMin, UINT uMax,UINT uFlg,BOOL bNoWait) { DWORD dwerv; HANDLE hTask; LPQUEUE lpQueue; if (hWnd && !IsWindow(hWnd)) hWnd = 0; if (hWnd) hTask = GetWindowTask(hWnd); else hTask = GetCurrentTask(); lpQueue = QueueGetPtr(hTask); /******************************************/ /* what is this? it is not called... */ /*hFocusTask = GetWindowTask(GetFocus()); */ /******************************************/ lpMsg->hwnd = 0; labLoop: while(1) { while (lpSendMessageStack && lpSendMessageStack->hReceivingTask == GetCurrentTask() && !lpSendMessageStack->bSendReceived) { TWIN_ReceiveMessage(FALSE); } /* try for a message from application queue */ if (QueueGetMsg(lpQueue, lpMsg, hWnd, uMin, uMax, uFlg)) { break; } /* try for a message from system queue */ if (QueueGetMsg(0,lpMsg,hWnd,uMin,uMax,uFlg)) { break; } if (uMin <= WM_PAINT && (!uMax || uMax >= WM_PAINT)) { /* finally, check if the window needs a paint message */ if(lpQueue->wQueueFlags & QFPAINT) { labTryNext: if((lpMsg->hwnd = InternalUpdateWindows())) { if (TestWF(lpMsg->hwnd, WFNCDIRTY)) { if (NonEmptyNCRect(lpMsg->hwnd)) { lpMsg->message = WM_NCPAINT; lpMsg->wParam = 0; lpMsg->lParam = 0L; break; } else { ClearWF(lpMsg->hwnd, WFNCDIRTY); } } if (TestWF(lpMsg->hwnd, WFDIRTY)) { if (IsIconic(lpMsg->hwnd) && GetClassIcon(lpMsg->hwnd)) { lpMsg->message = WM_PAINTICON; lpMsg->wParam = 1; } else { lpMsg->message = WM_PAINT; lpMsg->wParam = 0; } lpMsg->lParam = 0L; break; } else goto labTryNext; } lpQueue->wQueueFlags &= ~QFPAINT; } } if ((uMin <= WM_TIMER && (!uMax || uMax >= WM_TIMER)) || (uMin <= WM_SYSTIMER && (!uMax || uMax >= WM_SYSTIMER))) { if(lpQueue->wQueueFlags & QFTIMER) { if (TWIN_GetTimerMsg(hWnd,hTask,lpMsg,uFlg)) { break; } } } /* none of the above, so see if system is ready. */ if (!TWIN_InDriverWait) { TWIN_InDriverWait = TRUE; dwerv = DriverWaitEvent(TRUE); TWIN_InDriverWait = FALSE; if (!dwerv && !bNoWait) { /* * The code here used to call ReadyTask(GetCurrentTask()) * before calling InternalYield(), but that results in * a solid-run condition if more than one task is * defined, because it results in the other task looking * like it's ready to run, when all tasks should be waiting * on a driver event. So we yield if necessary, but do * not set ourselves as ready-to-run if we do. We will * be run again when we first get a message in our queue. */ #if defined(MAC_TASKING_PATCH) ReadyTask(GetCurrentTask()); #endif if (!InternalYield()) { TWIN_InDriverWait = TRUE; (void)DriverWaitEvent(FALSE); TWIN_InDriverWait = FALSE; } } else if (!(uFlg & PM_NOYIELD)) Yield(); } else if (!(uFlg & PM_NOYIELD)) InternalYield(); if(bNoWait) return FALSE; } if (CallGetMessageHooks(lpMsg,uFlg & PM_REMOVE)) goto labLoop; return TRUE; }
void CImageWnd::OnSize(BOOL refreshNow) { if (m_pAppWnd == NULL) return; // If application window is being iconified, hide the current view if (IsIconic(m_pAppWnd->m_hWnd)) { if (m_pView) m_pView->Hide(); return; } // Get application rectangle CRect appRect; m_pAppWnd->GetClientRect(appRect); // Get view rectangle CRect viewRect; if (m_pViewWnd != NULL) { m_pViewWnd->GetWindowRect(viewRect); m_pAppWnd->ScreenToClient(viewRect); } else { viewRect = appRect; } if (m_pViewWnd != NULL && m_pHorzScr != NULL && m_pVertScr != NULL) { // Get scroll bars rectangles CRect horzRect, vertRect; m_pHorzScr->GetWindowRect(horzRect); m_pVertScr->GetWindowRect(vertRect); m_pAppWnd->ScreenToClient(horzRect); m_pAppWnd->ScreenToClient(vertRect); // Adjust windows' position viewRect.right = appRect.right - 5 - vertRect.Width(); viewRect.bottom = appRect.bottom - 5 - horzRect.Height(); m_pViewWnd->MoveWindow(viewRect.left, viewRect.top, viewRect.Width(), viewRect.Height(), TRUE); horzRect.top = viewRect.bottom; horzRect.right = viewRect.right; horzRect.bottom = appRect.bottom - 5; m_pHorzScr->MoveWindow(horzRect.left, horzRect.top, horzRect.Width(), horzRect.Height(), TRUE); vertRect.left = viewRect.right; vertRect.right = appRect.right - 5; vertRect.bottom = viewRect.bottom; m_pVertScr->MoveWindow(vertRect.left, vertRect.top, vertRect.Width(), vertRect.Height(), TRUE); } if (m_pView) { // Call corresponding handler m_pView->OnSize(refreshNow); // Update scroll bars' position and range // Has to be called twice (JPC) UpdateScrollBars(); UpdateScrollBars(); // Update view rectangle m_ViewRect = viewRect; m_ViewRect.left += m_pView->GetScaleParamsDst().Left(); m_ViewRect.top += m_pView->GetScaleParamsDst().Top(); m_ViewRect.right = m_ViewRect.left + m_pView->GetWidth(); m_ViewRect.bottom = m_ViewRect.top + m_pView->GetHeight(); // Update tracker limits CRect limitRect; limitRect.top = 0; limitRect.left = 0; limitRect.right = m_pView->GetWidth(); limitRect.bottom = m_pView->GetHeight(); m_RectTracker.SetLimitRect(&limitRect); if (m_pViewWnd == NULL) { // Check if unused region of the AppWnd should be repainted int viewWidth = m_pView->GetWidth(); int viewHeight = m_pView->GetHeight(); if (appRect.Width() > viewWidth) { CRect rect = appRect; rect.left = viewWidth; m_pAppWnd->InvalidateRect(rect, TRUE); } if (appRect.Height() > viewHeight) { CRect rect = appRect; rect.top = viewHeight; m_pAppWnd->InvalidateRect(rect, TRUE); } } } }
/* * Functions should call RedrawAll if they need the room to be redrawn. * This sets a flag, and the next time an opportunity arises, the room * is redrawn via a call to RedrawForce. */ void RedrawForce(void) { HDC hdc; static DWORD lastEndFrame = 0; DWORD endFrame, startFrame; int totalFrameTime, oldMode; char buffer[32]; if (GameGetState() == GAME_INVALID || /*!need_redraw ||*/ IsIconic(hMain) || view.cx == 0 || view.cy == 0 || current_room.rows == 0 || current_room.cols == 0) { need_redraw = False; return; } timeBeginPeriod(1); startFrame = timeGetTime(); /* REVIEW: Clearing flag before draw phase allows draw phase to set flag. * This is useful in rare circumstances when an effect should * last only one frame, even if animation is off. */ need_redraw = False; hdc = GetDC(hMain); DrawRoom(hdc, view.x, view.y, ¤t_room, map); endFrame = timeGetTime(); msDrawFrame = (int)(endFrame - startFrame); totalFrameTime = (int)(endFrame - lastEndFrame); // if totalFrameTime is less than one, clamp to 1 so we don't divide by 0 or get negative fps if (1 > totalFrameTime) totalFrameTime = 1; fps = 1000 / (int)totalFrameTime; if (config.maxFPS) { if (fps > config.maxFPS) { int msSleep = (1000 / config.maxFPS) - totalFrameTime; Sleep(msSleep); } } lastEndFrame = endFrame; timeEndPeriod(1); if (config.showFPS) { RECT rc,lagBox; wsprintf(buffer, "FPS=%d (%dms) ", fps, msDrawFrame); ZeroMemory(&rc,sizeof(rc)); rc.bottom = DrawText(hdc,buffer,-1,&rc,DT_SINGLELINE|DT_CALCRECT); Lagbox_GetRect(&lagBox); OffsetRect(&rc,lagBox.right + TOOLBAR_SEPARATOR_WIDTH,lagBox.top); DrawWindowBackground(hdc, &rc, rc.left, rc.top); oldMode = SetBkMode(hdc,TRANSPARENT); DrawText(hdc,buffer,-1,&rc,DT_SINGLELINE); SetBkMode(hdc,oldMode); GdiFlush(); } ReleaseDC(hMain, hdc); GameWindowSetCursor(); // We may have moved; reset cursor }
LONG_PTR CALLBACK HotkeyHandlerDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam) { static POINT ptLast; static int iMousedown; if (msg == WM_TASKBARCREATED) { CreateSystrayIcon(FALSE); if (nen_options.bTraySupport) CreateSystrayIcon(TRUE); return 0; } TContainerData *p; switch (msg) { case WM_CREATE: for (int i=0; i < SIZEOF(_hotkeydescs); i++) { _hotkeydescs[i].cbSize = sizeof(HOTKEYDESC); Hotkey_Register(&_hotkeydescs[i]); } WM_TASKBARCREATED = RegisterWindowMessageA("TaskbarCreated"); ShowWindow(hwndDlg, SW_HIDE); hSvcHotkeyProcessor = CreateServiceFunction(MS_TABMSG_HOTKEYPROCESS, HotkeyProcessor); SetTimer(hwndDlg, TIMERID_SENDLATER, TIMEOUT_SENDLATER, NULL); break; case WM_HOTKEY: { CLISTEVENT *cli = (CLISTEVENT *)CallService(MS_CLIST_GETEVENT, (WPARAM)INVALID_HANDLE_VALUE, 0); if (cli != NULL) { if (strncmp(cli->pszService, "SRMsg/TypingMessage", strlen(cli->pszService))) { CallService(cli->pszService, 0, (LPARAM)cli); break; } } if (wParam == 0xc001) SendMessage(hwndDlg, DM_TRAYICONNOTIFY, 101, WM_MBUTTONDOWN); } break; // handle the popup menus (session list, favorites, recents... // just draw some icons, nothing more :) case WM_MEASUREITEM: { LPMEASUREITEMSTRUCT lpmi = (LPMEASUREITEMSTRUCT) lParam; lpmi->itemHeight = 0; lpmi->itemWidth = 6; } return TRUE; case WM_DRAWITEM: { LPDRAWITEMSTRUCT dis = (LPDRAWITEMSTRUCT) lParam; TWindowData *dat = 0; if (dis->CtlType == ODT_MENU && (dis->hwndItem == (HWND)PluginConfig.g_hMenuFavorites || dis->hwndItem == (HWND)PluginConfig.g_hMenuRecent)) { HICON hIcon = (HICON)dis->itemData; DrawMenuItem(dis, hIcon, 0); return TRUE; } else if (dis->CtlType == ODT_MENU) { HWND hWnd = M.FindWindow((MCONTACT)dis->itemID); DWORD idle = 0; if (hWnd == NULL) { SESSION_INFO *si = SM_FindSessionByHCONTACT((MCONTACT)dis->itemID); hWnd = si ? si->hWnd : 0; } if (hWnd) dat = (TWindowData*)GetWindowLongPtr(hWnd, GWLP_USERDATA); if (dis->itemData >= 0) { HICON hIcon; if (dis->itemData > 0) hIcon = dis->itemData & 0x10000000 ? pci->hIcons[ICON_HIGHLIGHT] : PluginConfig.g_IconMsgEvent; else if (dat != NULL) { hIcon = MY_GetContactIcon(dat); idle = dat->idle; } else hIcon = PluginConfig.g_iconContainer; DrawMenuItem(dis, hIcon, idle); return TRUE; } } } break; case DM_TRAYICONNOTIFY: if (wParam == 100 || wParam == 101) { switch (lParam) { case WM_LBUTTONUP: { POINT pt; GetCursorPos(&pt); if (wParam == 100) SetForegroundWindow(hwndDlg); if (GetMenuItemCount(PluginConfig.g_hMenuTrayUnread) > 0) { BOOL iSelection = TrackPopupMenu(PluginConfig.g_hMenuTrayUnread, TPM_RETURNCMD, pt.x, pt.y, 0, hwndDlg, NULL); HandleMenuEntryFromhContact((MCONTACT)iSelection); } else TrackPopupMenu(GetSubMenu(PluginConfig.g_hMenuContext, 8), TPM_RETURNCMD, pt.x, pt.y, 0, hwndDlg, NULL); if (wParam == 100) PostMessage(hwndDlg, WM_NULL, 0, 0); } break; case WM_MBUTTONDOWN: { if (wParam == 100) SetForegroundWindow(hwndDlg); int iCount = GetMenuItemCount(PluginConfig.g_hMenuTrayUnread); if (iCount > 0) { UINT uid = 0; MENUITEMINFOA mii = {0}; mii.fMask = MIIM_DATA; mii.cbSize = sizeof(mii); int i = iCount - 1; do { GetMenuItemInfoA(PluginConfig.g_hMenuTrayUnread, i, TRUE, &mii); if (mii.dwItemData > 0) { uid = GetMenuItemID(PluginConfig.g_hMenuTrayUnread, i); HandleMenuEntryFromhContact((MCONTACT)uid); break; } } while (--i >= 0); if (uid == 0 && pLastActiveContainer != NULL) { // no session found, restore last active container if (IsIconic(pLastActiveContainer->hwnd) || !IsWindowVisible(pLastActiveContainer->hwnd)) { SendMessage(pLastActiveContainer->hwnd, WM_SYSCOMMAND, SC_RESTORE, 0); SetForegroundWindow(pLastActiveContainer->hwnd); SetFocus(GetDlgItem(pLastActiveContainer->hwndActive, IDC_MESSAGE)); } else if (GetForegroundWindow() != pLastActiveContainer->hwnd) { SetForegroundWindow(pLastActiveContainer->hwnd); SetFocus(GetDlgItem(pLastActiveContainer->hwndActive, IDC_MESSAGE)); } else { if (PluginConfig.m_HideOnClose) ShowWindow(pLastActiveContainer->hwnd, SW_HIDE); else SendMessage(pLastActiveContainer->hwnd, WM_SYSCOMMAND, SC_MINIMIZE, 0); } } } if (wParam == 100) PostMessage(hwndDlg, WM_NULL, 0, 0); } break; case WM_RBUTTONUP: { HMENU submenu = PluginConfig.g_hMenuTrayContext; POINT pt; if (wParam == 100) SetForegroundWindow(hwndDlg); GetCursorPos(&pt); CheckMenuItem(submenu, ID_TRAYCONTEXT_DISABLEALLPOPUPS, MF_BYCOMMAND | (nen_options.iDisable ? MF_CHECKED : MF_UNCHECKED)); CheckMenuItem(submenu, ID_TRAYCONTEXT_DON40223, MF_BYCOMMAND | (nen_options.iNoSounds ? MF_CHECKED : MF_UNCHECKED)); CheckMenuItem(submenu, ID_TRAYCONTEXT_DON, MF_BYCOMMAND | (nen_options.iNoAutoPopup ? MF_CHECKED : MF_UNCHECKED)); EnableMenuItem(submenu, ID_TRAYCONTEXT_HIDEALLMESSAGECONTAINERS, MF_BYCOMMAND | (nen_options.bTraySupport) ? MF_ENABLED : MF_GRAYED); CheckMenuItem(submenu, ID_TRAYCONTEXT_SHOWTHETRAYICON, MF_BYCOMMAND | (nen_options.bTraySupport ? MF_CHECKED : MF_UNCHECKED)); BOOL iSelection = TrackPopupMenu(submenu, TPM_RETURNCMD, pt.x, pt.y, 0, hwndDlg, NULL); if (iSelection) { MENUITEMINFO mii = {0}; mii.cbSize = sizeof(mii); mii.fMask = MIIM_DATA | MIIM_ID; GetMenuItemInfo(submenu, (UINT_PTR)iSelection, FALSE, &mii); if (mii.dwItemData != 0) // this must be an itm of the fav or recent menu HandleMenuEntryFromhContact((MCONTACT)iSelection); else { switch (iSelection) { case ID_TRAYCONTEXT_SHOWTHETRAYICON: nen_options.bTraySupport = !nen_options.bTraySupport; CreateSystrayIcon(nen_options.bTraySupport ? TRUE : FALSE); break; case ID_TRAYCONTEXT_DISABLEALLPOPUPS: nen_options.iDisable ^= 1; break; case ID_TRAYCONTEXT_DON40223: nen_options.iNoSounds ^= 1; break; case ID_TRAYCONTEXT_DON: nen_options.iNoAutoPopup ^= 1; break; case ID_TRAYCONTEXT_HIDEALLMESSAGECONTAINERS: for (p = pFirstContainer; p; p = p->pNext) ShowWindow(p->hwnd, SW_HIDE); break; case ID_TRAYCONTEXT_RESTOREALLMESSAGECONTAINERS: for (p = pFirstContainer; p; p = p->pNext) ShowWindow(p->hwnd, SW_SHOW); break; case ID_TRAYCONTEXT_BE: nen_options.iDisable = 1; nen_options.iNoSounds = 1; nen_options.iNoAutoPopup = 1; for (p = pFirstContainer; p; p = p->pNext) SendMessage(p->hwnd, WM_SYSCOMMAND, SC_MINIMIZE, 1); break; } } } if (wParam == 100) PostMessage(hwndDlg, WM_NULL, 0, 0); break; } } } break; // handle an event from the popup module (mostly window activation). Since popups may run in different threads, the message // is posted to our invisible hotkey handler which does always run within the main thread. // wParam is the hContact // lParam the event handle case DM_HANDLECLISTEVENT: // if lParam == NULL, don't consider clist events, just open the message tab if (lParam == 0) HandleMenuEntryFromhContact(wParam); else { CLISTEVENT *cle = (CLISTEVENT *)CallService(MS_CLIST_GETEVENT, wParam, 0); if (cle) { if (ServiceExists(cle->pszService)) { CallService(cle->pszService, 0, (LPARAM)cle); CallService(MS_CLIST_REMOVEEVENT, (WPARAM)cle->hContact, (LPARAM)cle->hDbEvent); } } // still, we got that message posted.. the event may be waiting in tabSRMMs tray... else HandleMenuEntryFromhContact(wParam); } break; case DM_DOCREATETAB: { HWND hWnd = M.FindWindow(lParam); if (hWnd && IsWindow(hWnd)) { TContainerData *pContainer = 0; SendMessage(hWnd, DM_QUERYCONTAINER, 0, (LPARAM)&pContainer); if (pContainer) { int iTabs = TabCtrl_GetItemCount(GetDlgItem(pContainer->hwnd, IDC_MSGTABS)); if (iTabs == 1) SendMessage(pContainer->hwnd, WM_CLOSE, 0, 1); else SendMessage(hWnd, WM_CLOSE, 0, 1); CreateNewTabForContact((TContainerData*)wParam, lParam, 0, NULL, TRUE, TRUE, FALSE, 0); } } } break; case DM_DOCREATETAB_CHAT: { SESSION_INFO *si = SM_FindSessionByHWND((HWND)lParam); if (si && IsWindow(si->hWnd)) { TContainerData *pContainer = 0; SendMessage(si->hWnd, DM_QUERYCONTAINER, 0, (LPARAM)&pContainer); if (pContainer) { int iTabs = TabCtrl_GetItemCount(GetDlgItem(pContainer->hwnd, 1159)); if (iTabs == 1) SendMessage(pContainer->hwnd, WM_CLOSE, 0, 1); else SendMessage(si->hWnd, WM_CLOSE, 0, 1); si->hWnd = CreateNewRoom((TContainerData*)wParam, si, TRUE, 0, 0); } } } break; case DM_SENDMESSAGECOMMANDW: SendMessageCommand_W(wParam, lParam); if (lParam) mir_free((void*)lParam); return 0; case DM_SENDMESSAGECOMMAND: SendMessageCommand(wParam, lParam); if (lParam) mir_free((void*)lParam); return 0; // sent from the popup to "dismiss" the event. we should do this in the main thread case DM_REMOVECLISTEVENT: CallService(MS_CLIST_REMOVEEVENT, wParam, lParam); db_event_markRead(wParam, (HANDLE)lParam); return 0; case DM_SETLOCALE: { HKL hkl = (HKL)lParam; MCONTACT hContact = wParam; HWND hWnd = M.FindWindow(hContact); if (hWnd) { TWindowData *dat = (TWindowData*)GetWindowLongPtr(hWnd, GWLP_USERDATA); if (dat) { if (hkl) { dat->hkl = hkl; PostMessage(dat->hwnd, DM_SETLOCALE, 0, 0); } DBVARIANT dbv; if (0 == db_get_ts(hContact, SRMSGMOD_T, "locale", &dbv)) { GetLocaleID(dat, dbv.ptszVal); db_free(&dbv); UpdateReadChars(dat); } } } } return 0; // react to changes in the desktop composition state // (enable/disable DWM, change to a non-aero visual style // or classic Windows theme case WM_DWMCOMPOSITIONCHANGED: { bool fNewAero = M.getAeroState(); // refresh dwm state SendMessage(hwndDlg, WM_THEMECHANGED, 0, 0); for (p = pFirstContainer; p; p = p->pNext) { if (fNewAero) SetAeroMargins(p); else { MARGINS m = {0}; if (M.m_pfnDwmExtendFrameIntoClientArea) M.m_pfnDwmExtendFrameIntoClientArea(p->hwnd, &m); } if (p->SideBar->isActive()) RedrawWindow(GetDlgItem(p->hwnd, 5000), NULL, NULL, RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW); // the container for the sidebar buttons RedrawWindow(p->hwnd, NULL, NULL, RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW|RDW_ALLCHILDREN); } } M.BroadcastMessage(WM_DWMCOMPOSITIONCHANGED, 0, 0); break; // this message is fired when the user changes desktop color // settings (Desktop->personalize) // the handler reconfigures the aero-related skin images for // tabs and buttons to match the new desktop color theme. case WM_DWMCOLORIZATIONCOLORCHANGED: M.getAeroState(); Skin->setupAeroSkins(); CSkin::initAeroEffect(); break; // user has changed the visual style or switched to/from // classic Windows theme case WM_THEMECHANGED: M.getAeroState(); Skin->setupTabCloseBitmap(); CSkin::initAeroEffect(); PluginConfig.m_ncm.cbSize = sizeof(NONCLIENTMETRICS); SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &PluginConfig.m_ncm, 0); FreeTabConfig(); ReloadTabConfig(); for (p = pFirstContainer; p; p = p->pNext) { SendMessage(GetDlgItem(p->hwnd, IDC_MSGTABS), EM_THEMECHANGED, 0, 0); BroadCastContainer(p, EM_THEMECHANGED, 0, 0); } break; case DM_SPLITSENDACK: { SendJob *job = sendQueue->getJobByIndex((int)wParam); ACKDATA ack = {0}; ack.hContact = job->hOwner; ack.hProcess = job->hSendId; ack.type = ACKTYPE_MESSAGE; ack.result = ACKRESULT_SUCCESS; if (job->hOwner && job->iAcksNeeded && job->hOwner && job->iStatus == SendQueue::SQ_INPROGRESS) { if (IsWindow(job->hwndOwner)) ::SendMessage(job->hwndOwner, HM_EVENTSENT, (WPARAM)MAKELONG(wParam, 0), (LPARAM)&ack); else sendQueue->ackMessage(0, (WPARAM)MAKELONG(wParam, 0), (LPARAM)&ack); } } return 0; case DM_LOGSTATUSCHANGE: CGlobals::logStatusChange(wParam, reinterpret_cast<CContactCache *>(lParam)); return 0; case DM_MUCFLASHWORKER: { FLASH_PARAMS *p = reinterpret_cast<FLASH_PARAMS*>(lParam); if (1 == wParam) { CallService(MS_CLIST_CONTACTDOUBLECLICKED, (WPARAM)p->hContact, 1); p->bActiveTab = TRUE; p->bInactive = FALSE; p->bMustAutoswitch = p->bMustFlash = FALSE; } if (2 == wParam) { p->bActiveTab = TRUE; p->bInactive = FALSE; p->bMustAutoswitch = p->bMustFlash = FALSE; SendMessage(p->hWnd, DM_ACTIVATEME, 0, 0); } DoFlashAndSoundWorker(p); } return 0; case WM_POWERBROADCAST: case WM_DISPLAYCHANGE: for (p = pFirstContainer; p; p = p->pNext) if (CSkin::m_skinEnabled) { // invalidate cached background DCs for skinned containers p->oldDCSize.cx = p->oldDCSize.cy = 0; SelectObject(p->cachedDC, p->oldHBM); DeleteObject(p->cachedHBM); DeleteDC(p->cachedDC); p->cachedDC = 0; RedrawWindow(p->hwnd, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_FRAME); } break; case WM_ACTIVATE: if (LOWORD(wParam) != WA_ACTIVE) SetWindowPos(hwndDlg, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE); return 0; case WM_CLOSE: return 0; case WM_TIMER: if (wParam == TIMERID_SENDLATER) { // send heartbeat to each container, they use this to update // dynamic content (i.e. local time in the info panel). for (p = pFirstContainer; p; p = p->pNext) SendMessage(p->hwnd, WM_TIMER, TIMERID_HEARTBEAT, 0); // process send later contacts and jobs, if enough time has elapsed if (sendLater->isAvail() && !sendLater->isInteractive() && (time(0) - sendLater->lastProcessed()) > CSendLater::SENDLATER_PROCESS_INTERVAL) { sendLater->setLastProcessed(time(0)); // check the list of contacts that may have new send later jobs // (added on user's request) sendLater->processContacts(); // start processing the job list if (!sendLater->isJobListEmpty()) { KillTimer(hwndDlg, wParam); sendLater->startJobListProcess(); SetTimer(hwndDlg, TIMERID_SENDLATER_TICK, TIMEOUT_SENDLATER_TICK, 0); } } } // process one entry per tick (default: 200ms) // TODO better timings, possibly slow down when many jobs are in the // queue. else if (wParam == TIMERID_SENDLATER_TICK) { if ( !sendLater->haveJobs()) { KillTimer(hwndDlg, wParam); SetTimer(hwndDlg, TIMERID_SENDLATER, TIMEOUT_SENDLATER, 0); sendLater->qMgrUpdate(true); } else sendLater->processCurrentJob(); } break; case WM_DESTROY: KillTimer(hwndDlg, TIMERID_SENDLATER_TICK); KillTimer(hwndDlg, TIMERID_SENDLATER); DestroyServiceFunction(hSvcHotkeyProcessor); break; } return DefWindowProc(hwndDlg, msg, wParam, lParam); }
/* this function gets called by mplayer to update the gui */ int gui(int what, void *data) { stream_t *stream = data; #ifdef CONFIG_DVDREAD dvd_priv_t *dvdp; #endif if(!mygui || !mygui->skin) return 0; if(guiInfo.mpcontext) { audio_out = mpctx_get_audio_out(guiInfo.mpcontext); video_out = mpctx_get_video_out(guiInfo.mpcontext); mixer = mpctx_get_mixer(guiInfo.mpcontext); playtree = mpctx_get_playtree_iter(guiInfo.mpcontext); } switch (what) { case GUI_PREPARE: { audio_id = -1; video_id = -1; dvdsub_id = -1; vobsub_id = -1; stream_cache_size = -1; autosync = 0; dvd_title = 0; force_fps = 0; if(!mygui->playlist->tracks) return 0; switch(guiInfo.StreamType) { case STREAMTYPE_FILE: case STREAMTYPE_STREAM: uiSetFileName(NULL, mygui->playlist->tracks[mygui->playlist->current]->filename, SAME_STREAMTYPE); guiInfo.Track = mygui->playlist->current + 1; break; #ifdef CONFIG_DVDREAD case STREAMTYPE_DVD: { char tmp[512]; dvd_chapter = guiInfo.Chapter; dvd_angle = guiInfo.Angle; sprintf(tmp,"dvd://%d", guiInfo.Track); uiSetFileName(NULL, tmp, SAME_STREAMTYPE); break; } #endif } guiInfo.VideoWindow = 1; if(gtkAONorm) greplace(&af_cfg.list, "volnorm", "volnorm"); if(gtkAOExtraStereo) { char *name = malloc(12 + 20 + 1); snprintf(name, 12 + 20, "extrastereo=%f", gtkAOExtraStereoMul); name[12 + 20] = 0; greplace(&af_cfg.list, "extrastereo", name); free(name); } if(gtkCacheOn) stream_cache_size = gtkCacheSize; if(gtkAutoSyncOn) autosync = gtkAutoSync; guiInfo.NewPlay = 0; break; } case GUI_SET_AUDIO: { if (data && !guiInfo.sh_video) guiInfo.VideoWindow = 0; if(IsWindowVisible(mygui->subwindow) && !guiInfo.VideoWindow) ShowWindow(mygui->subwindow, SW_HIDE); break; } case GUI_SET_CONTEXT: guiInfo.mpcontext = data; break; case GUI_SET_VIDEO: { guiInfo.sh_video = data; if (data) { sh_video_t *sh = data; codecname = sh->codec->name; /* we have video, show the subwindow */ if(!IsWindowVisible(mygui->subwindow) || IsIconic(mygui->subwindow)) ShowWindow(mygui->subwindow, SW_SHOWNORMAL); if(WinID == -1) update_subwindow(); } break; } case GUI_SETUP_VIDEO_WINDOW: { guiInfo.VideoWidth = vo_dwidth; guiInfo.VideoHeight = vo_dheight; sub_aspect = (float)guiInfo.VideoWidth/guiInfo.VideoHeight; if(WinID != -1) update_subwindow(); break; } case GUI_SET_STREAM: { guiInfo.StreamType = stream->type; switch(stream->type) { #ifdef CONFIG_DVDREAD case STREAMTYPE_DVD: guiInfo.Tracks = 0; stream_control(stream, STREAM_CTRL_GET_NUM_TITLES, &guiInfo.Tracks); guiInfo.Chapters = 0; stream_control(stream, STREAM_CTRL_GET_NUM_CHAPTERS, &guiInfo.Chapters); guiInfo.Angles = 0; stream_control(stream, STREAM_CTRL_GET_NUM_ANGLES, &guiInfo.Angles); dvdp = stream->priv; guiInfo.AudioStreams = dvdp->nr_of_channels; memcpy(guiInfo.AudioStream, dvdp->audio_streams, sizeof(dvdp->audio_streams)); guiInfo.Subtitles = dvdp->nr_of_subtitles; memcpy(guiInfo.Subtitle, dvdp->subtitles, sizeof(dvdp->subtitles)); guiInfo.Chapter = dvd_chapter + 1; guiInfo.Angle = dvd_angle + 1; guiInfo.Track = dvd_title + 1; break; #endif } break; } case GUI_REDRAW: mygui->updatedisplay(mygui, mygui->mainwindow); break; case GUI_SET_AFILTER: guiInfo.afilter = data; break; case GUI_SET_STATE: { guiInfo.Playing = (int) data; switch (guiInfo.Playing) { case GUI_PLAY: { guiInfo.Playing = GUI_PLAY; break; } case GUI_STOP: { guiInfo.Playing = GUI_STOP; if(movie_aspect >= 0) movie_aspect = -1; update_subwindow(); break; } case GUI_PAUSE: guiInfo.Playing = GUI_PAUSE; break; } break; } case GUI_RUN_COMMAND: { mp_msg(MSGT_GPLAYER,MSGL_V, "cmd: %d\n", (int) data); /* MPlayer asks us to quit */ switch((int) data) { case MP_CMD_VO_FULLSCREEN: uiFullScreen(); break; case MP_CMD_QUIT: { mygui->uninit(mygui); nfree(mygui); exit_player(EXIT_QUIT); return 1; } case MP_CMD_PLAY_TREE_STEP: guiSetEvent(evNext); break; case -MP_CMD_PLAY_TREE_STEP: guiSetEvent(evPrev); break; case MP_CMD_STOP: guiSetEvent(evStop); break; default: break; } break; } case GUI_RUN_MESSAGE: break; case GUI_HANDLE_EVENTS: break; case GUI_SET_MIXER: { if(audio_out) { /* Some audio_out drivers do not support balance e.g. dsound */ /* FIXME this algo is not correct */ float l, r; mixer_getvolume(mixer, &l, &r); guiInfo.Volume = (r > l ? r : l); /* max(r,l) */ if (r != l) guiInfo.Balance = ((r-l) + 100.0f) * 0.5f; else guiInfo.Balance = 50.0f; } break; } case GUI_END_FILE: { if(!uiGotoTheNext && guiInfo.Playing) { uiGotoTheNext = 1; break; } if(uiGotoTheNext && guiInfo.Playing && (mygui->playlist->current < (mygui->playlist->trackcount - 1)) && guiInfo.StreamType != STREAMTYPE_DVD && guiInfo.StreamType != STREAMTYPE_DVDNAV) { /* we've finished this file, reset the aspect */ if(movie_aspect >= 0) movie_aspect = -1; uiGotoTheNext = 1; guiInfo.NewPlay = GUI_FILE_NEW; uiSetFileName(NULL, mygui->playlist->tracks[(mygui->playlist->current)++]->filename, STREAMTYPE_FILE); //sprintf(guiInfo.Filename, mygui->playlist->tracks[(mygui->playlist->current)++]->filename); } if(guiInfo.NewPlay == GUI_FILE_NEW) break; guiInfo.ElapsedTime = 0; guiInfo.Position = 0; guiInfo.AudioChannels = 0; #ifdef CONFIG_DVDREAD guiInfo.Track = 1; guiInfo.Chapter = 1; guiInfo.Angle = 1; #endif if (mygui->playlist->current == (mygui->playlist->trackcount - 1)) mygui->playlist->current = 0; fullscreen = 0; if(style == WS_VISIBLE | WS_POPUP) { style = WS_OVERLAPPEDWINDOW | WS_SIZEBOX; SetWindowLong(mygui->subwindow, GWL_STYLE, style); } gui(GUI_SET_STATE, (void *) GUI_STOP); break; } default: mp_msg(MSGT_GPLAYER, MSGL_ERR, "[GUI] GOT UNHANDLED EVENT %i\n", what); } return 1; }
WINEXPORT LRESULT CALLBACK WMainWndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam ) { HMENU menu; #if 0 HWND win; #endif LRESULT ret; bool pass_to_def; WAccelEditInfo *einfo; WORD wp; MINMAXINFO *minmax; about_info ai; pass_to_def = TRUE; ret = FALSE; einfo = (WAccelEditInfo *)GET_WNDLONGPTR( hWnd, 0 ); WSetCurrentEditInfo( einfo ); if( einfo != NULL && einfo->getting_key ) { if( WGetKeyPressProc( einfo, message, wParam, lParam ) ) { einfo->getting_key = FALSE; DestroyWindow( einfo->key_info.text_win ); ReleaseCapture(); WHandleChange( einfo ); pass_to_def = FALSE; } } switch( message ) { case WM_ACTIVATE: if( GET_WM_ACTIVATE_FACTIVE( wParam, lParam ) && !GET_WM_ACTIVATE_FMINIMIZED( wParam, lParam ) && einfo != NULL && einfo->edit_dlg != (HWND)NULL ) { SetFocus( einfo->edit_dlg ); pass_to_def = FALSE; } break; case WM_INITMENU: if( wParam == (WPARAM)GetMenu( hWnd ) ) { // set the cut and copy menu items if( SendDlgItemMessage( einfo->edit_dlg, IDM_ACCEDLIST, LB_GETCURSEL, 0, 0 ) != LB_ERR ) { EnableMenuItem( (HMENU)wParam, IDM_ACC_CUT, MF_ENABLED ); EnableMenuItem( (HMENU)wParam, IDM_ACC_COPY, MF_ENABLED ); } else { EnableMenuItem( (HMENU)wParam, IDM_ACC_CUT, MF_GRAYED ); EnableMenuItem( (HMENU)wParam, IDM_ACC_COPY, MF_GRAYED ); } // set the paste menu item if( OpenClipboard( hWnd ) ) { if( //IsClipboardFormatAvailable( WClipbdFormat ) || IsClipboardFormatAvailable( WItemClipbdFormat ) ) { EnableMenuItem( (HMENU)wParam, IDM_ACC_PASTE, MF_ENABLED ); } else { EnableMenuItem( (HMENU)wParam, IDM_ACC_PASTE, MF_GRAYED ); } CloseClipboard(); } } break; case WM_CREATE: einfo = ((CREATESTRUCT *)lParam)->lpCreateParams; SET_WNDLONGPTR( hWnd, 0, (LONG_PTR)einfo ); break; case WM_MENUSELECT: if( einfo != NULL ) { menu = WGetMenuHandle( einfo ); WHandleMenuSelect( einfo->wsb, menu, wParam, lParam ); setLastMenuSelect( einfo, wParam, lParam ); } break; case WM_GETMINMAXINFO: minmax = (MINMAXINFO *)lParam; minmax->ptMinTrackSize.x = appWidth; minmax->ptMinTrackSize.y = appHeight; break; case WM_MOVE: if( einfo != NULL ) { if( IsZoomed( hWnd ) ) { WSetOption( WOptScreenMax, TRUE ); } else if( !IsIconic( hWnd ) ) { WUpdateScreenPosOpt( hWnd ); WSetOption( WOptScreenMax, FALSE ); } } break; case WM_SIZE: if( einfo != NULL ) { if( wParam == SIZE_MAXIMIZED ) { WSetOption( WOptScreenMax, TRUE ); } else if( wParam != SIZE_MINIMIZED ) { WUpdateScreenPosOpt( hWnd ); WSetOption( WOptScreenMax, FALSE ); } WResizeWindows( einfo ); } break; #if 0 case WM_ACTIVATE: if( GET_WM_ACTIVATE_FACTIVE( wParam, lParam ) != WA_INACTIVE ) { einfo = (WAccelEditInfo *)GET_WNDLONGPTR( hWnd, 0 ); if( einfo != NULL && einfo->edit_dlg != (HWND)NULL ) { SetFocus( einfo->edit_dlg ); } WSetCurrentEditInfo( einfo ); } else { WSetCurrentEditInfo( NULL ); } break; #endif case WM_COMMAND: wp = LOWORD( wParam ); switch( wp ) { case IDM_ACC_CLEAR: WHandleClear( einfo ); pass_to_def = FALSE; break; case IDM_ACC_UPDATE: SendMessage( einfo->info->parent, ACCEL_PLEASE_SAVEME, 0, (LPARAM)einfo->hndl ); pass_to_def = FALSE; break; case IDM_ACC_OPEN: pass_to_def = FALSE; if( einfo->info->modified ) { ret = WQuerySave( einfo, FALSE ); if( !ret ) { break; } } ret = SendMessage( einfo->info->parent, ACCEL_PLEASE_OPENME, 0, (LPARAM)einfo->hndl ); ret = FALSE; break; case IDM_ACC_SAVE: WSaveObject( einfo, FALSE, FALSE ); pass_to_def = FALSE; break; case IDM_ACC_SAVEAS: WSaveObject( einfo, TRUE, FALSE ); pass_to_def = FALSE; break; case IDM_ACC_SAVEINTO: WSaveObject( einfo, TRUE, TRUE ); pass_to_def = FALSE; break; case IDM_ACC_EXIT: /* clean up before we exit */ PostMessage( einfo->win, WM_CLOSE, 0, 0 ); break; case IDM_ACC_PASTE: WPasteAccelItem( einfo ); pass_to_def = FALSE; break; case IDM_ACC_COPY: case IDM_ACC_CUT: WClipAccelItem( einfo, wp == IDM_ACC_CUT ); pass_to_def = FALSE; break; case IDM_ACC_DELETE: WDeleteAccelEntry( einfo ); pass_to_def = FALSE; break; case IDM_ACC_NEWITEM: WInsertAccelEntry( einfo ); pass_to_def = FALSE; break; case IDM_ACC_KEYVALUE: WSetStatusByID( einfo->wsb, W_GETTINGKEYS, -1 ); WHandleGetKeyValue( einfo, einfo->last_menu_select == IDM_ACC_KEYVALUE ); WSetStatusReadyText( einfo->wsb ); pass_to_def = FALSE; break; case IDM_ACC_SYMBOLS: handleSymbols( einfo ); pass_to_def = FALSE; break; case IDM_ACC_LOAD_SYMBOLS: handleLoadSymbols( einfo ); pass_to_def = FALSE; break; case IDM_ACC_SHOWRIBBON: menu = WGetMenuHandle( einfo ); WShowRibbon( einfo, menu ); pass_to_def = FALSE; break; case IDM_ACC_MEM_FLAGS: WSetStatusByID( einfo->wsb, W_CHANGEACCELMEMFLAGS, -1 ); einfo->info->modified |= WChangeMemFlags( einfo->win, &einfo->info->MemFlags, einfo->info->res_name, WGetEditInstance(), WAccHelpRoutine ); pass_to_def = FALSE; WSetStatusReadyText( einfo->wsb ); break; case IDM_ACC_RENAME: WHandleRename( einfo ); pass_to_def = FALSE; break; case IDM_HELP: WAccHelpRoutine(); pass_to_def = FALSE; break; case IDM_HELP_SEARCH: WAccHelpSearchRoutine(); pass_to_def = FALSE; break; case IDM_HELP_ON_HELP: WAccHelpOnHelpRoutine(); pass_to_def = FALSE; break; case IDM_ACC_ABOUT: ai.owner = hWnd; ai.inst = WGetEditInstance(); ai.name = AllocRCString( W_ABOUT_NAME ); ai.version = AllocRCString( W_ABOUT_VERSION ); ai.first_cr_year = "2002"; ai.title = AllocRCString( W_ABOUT_TITLE ); DoAbout( &ai ); FreeRCString( ai.name ); FreeRCString( ai.version ); FreeRCString( ai.title ); pass_to_def = FALSE; break; } break; case WM_DESTROY: WWinHelp( hWnd, "resacc.hlp", HELP_QUIT, 0 ); WCleanup( einfo ); break; case WM_CLOSE: ret = TRUE; pass_to_def = WHandleWM_CLOSE( einfo, wParam != 0 ); wParam = 0; break; } if( pass_to_def ) { ret = DefWindowProc( hWnd, message, wParam, lParam ); } return( ret ); }
/************************************************************************ UnhookZoom Unhooks the zoom window from the specified window. if this was its owner then zoom window destroys itself.. ************************************************************************/ void UnhookZoom(HWND hWnd) { HWND hOwner, hWndMe; if (!hZoomWindow) return; hOwner = GetZoomOwner(hZoomWindow); if (hOwner != hWnd || !hOwner) return; hWndMe = hZoomWindow; DestroyWindow(hWndMe); // will set hZoomWindow = NULL hZoomWindow = NULL; } //************************************************************************ // ZoomSizeToDef // Computes and sets size and position on the screen // for the new zoom window according to the defaults //***********************************************************************/ void ZoomSizeToDef() { LPIMAGE lpMyImage; RECT rOwner, rArea, rParent; HWND hWndOwner,hParent; int x,y,height, width; int borderW, borderH; STRING szString; if (!hZoomWindow) return; lpMyImage = (LPIMAGE)GetImagePtr (hZoomWindow ); hWndOwner = GetZoomOwner(hZoomWindow); hParent = PictPubApp.Get_hWndAstral(); if (!hWndOwner || !hParent) return; if (hZoomWindow && lpMyImage ) { x = View.rZoomRect.left; y = View.rZoomRect.top; width = View.rZoomRect.right - View.rZoomRect.left; height = View.rZoomRect.bottom - View.rZoomRect.top; if (height == 0 || width == 0) { // no previous values // use saved values if possible GetDefaultString( _T("sizeZoom"), _T("0,0"), szString, sizeof(STRING) ); AsciiToInt2( szString, &width, &height); if (width+height != 0) { MoveWindow (hZoomWindow,x,y,width, height, FALSE); if (RestorePopup( hZoomWindow, _T("xyZoom"), NULL )) { // Restore popup will change View.rZoomRect x = View.rZoomRect.left; y = View.rZoomRect.top; MoveWindow (hZoomWindow,x,y,width, height, FALSE); return; } } // saved values failed, now use defaults GetWindowRect(hZoomWindow, &rArea); borderW = rArea.right - rArea.left; borderH = rArea.bottom - rArea.top; GetClientRect(hZoomWindow, &rArea); borderW -= rArea.right - rArea.left; borderH -= rArea.bottom - rArea.top; GetClientRect(hWndOwner, &rOwner); GetClientRect(hParent, &rParent); height = FMUL(RectHeight(&rOwner), View.ZoomDefaultSize)+borderH; width = FMUL(RectWidth(&rOwner), View.ZoomDefaultSize)+borderW; x = rParent.right-width; y = rParent.top + borderH; if (IsIconic(hWndOwner)) { height = (rOwner.bottom - rOwner.top)+borderH; width = (rOwner.right - rOwner.left)+borderW; } } MoveWindow (hZoomWindow,x,y,width, height, FALSE); } }
/** * Tries to switch to the main window of the VM process. * * @return true if successfully switched and false otherwise. */ bool UIVMItem::switchTo() { #ifdef VBOX_WS_MAC ULONG64 id = m_machine.ShowConsoleWindow(); #else WId id = (WId) m_machine.ShowConsoleWindow(); #endif AssertWrapperOk(m_machine); if (!m_machine.isOk()) return false; /* winId = 0 it means the console window has already done everything * necessary to implement the "show window" semantics. */ if (id == 0) return true; #if defined (VBOX_WS_WIN) || defined (VBOX_WS_X11) return vboxGlobal().activateWindow(id, true); #elif defined (VBOX_WS_MAC) /* * This is just for the case were the other process cannot steal * the focus from us. It will send us a PSN so we can try. */ ProcessSerialNumber psn; psn.highLongOfPSN = id >> 32; psn.lowLongOfPSN = (UInt32)id; OSErr rc = ::SetFrontProcess(&psn); if (!rc) Log(("GUI: %#RX64 couldn't do SetFrontProcess on itself, the selector (we) had to do it...\n", id)); else Log(("GUI: Failed to bring %#RX64 to front. rc=%#x\n", id, rc)); return !rc; #endif return false; /// @todo Below is the old method of switching to the console window // based on the process ID of the console process. It should go away // after the new (callback-based) method is fully tested. #if 0 if (!canSwitchTo()) return false; #if defined (VBOX_WS_WIN) HWND hwnd = mWinId; /* if there are blockers (modal and modeless dialogs, etc), find the * topmost one */ HWND hwndAbove = NULL; do { hwndAbove = GetNextWindow(hwnd, GW_HWNDPREV); HWND hwndOwner; if (hwndAbove != NULL && ((hwndOwner = GetWindow(hwndAbove, GW_OWNER)) == hwnd || hwndOwner == hwndAbove)) hwnd = hwndAbove; else break; } while (1); /* first, check that the primary window is visible */ if (IsIconic(mWinId)) ShowWindow(mWinId, SW_RESTORE); else if (!IsWindowVisible(mWinId)) ShowWindow(mWinId, SW_SHOW); #if 0 LogFlowFunc(("mWinId=%08X hwnd=%08X\n", mWinId, hwnd)); #endif /* then, activate the topmost in the group */ AllowSetForegroundWindow(m_pid); SetForegroundWindow(hwnd); return true; #elif defined (VBOX_WS_X11) return false; #elif defined (VBOX_WS_MAC) ProcessSerialNumber psn; OSStatus rc = ::GetProcessForPID(m_pid, &psn); if (!rc) { rc = ::SetFrontProcess(&psn); if (!rc) { ShowHideProcess(&psn, true); return true; } } return false; #else return false; #endif #endif }
//--------------------------------------------------------------------- void D3D10RenderWindow::windowMovedOrResized() { if (!mHWnd || IsIconic(mHWnd)) return; RECT rc; // top and left represent outer window position GetWindowRect(mHWnd, &rc); mTop = rc.top; mLeft = rc.left; // width and height represent drawable area only GetClientRect(mHWnd, &rc); unsigned int width = rc.right; unsigned int height = rc.bottom; if (mWidth == width && mHeight == height) return; md3dpp.Windowed = !mIsFullScreen; md3dpp.SwapEffect = DXGI_SWAP_EFFECT_DISCARD ; // triple buffer if VSync is on md3dpp.BufferCount = mVSync ? 2 : 1; md3dpp.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; md3dpp.OutputWindow = mHWnd; md3dpp.BufferDesc.Width = mWidth; md3dpp.BufferDesc.Height = mHeight; md3dpp.BufferDesc.RefreshRate.Numerator=1; md3dpp.BufferDesc.RefreshRate.Denominator = mIsFullScreen ? mDisplayFrequency : 0; mWidth = width; mHeight = height; UINT Flags = 0; if( mIsFullScreen ) Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; mpSwapChain->ResizeBuffers(md3dpp.BufferCount, width, height, md3dpp.BufferDesc.Format, Flags); /* SAFE_RELEASE( mpRenderSurface ); if (mIsSwapChain) { DXGI_SWAP_CHAIN_DESC pp = md3dpp; pp.BufferDesc.Height = width; pp.BufferDesc.Height = height; //SAFE_RELEASE( mpRenderZBuffer ); SAFE_RELEASE( mpSwapChain ); HRESULT hr = mDriver->mDevice->CreateAdditionalSwapChain( &pp, &mpSwapChain); if (FAILED(hr)) { LogManager::getSingleton().stream(LML_CRITICAL) << "D3D10RenderWindow: failed to reset device to new dimensions << " << width << " x " << height << ". Trying to recover."; // try to recover hr = mDriver->mDevice->CreateAdditionalSwapChain( &md3dpp, &mpSwapChain); if (FAILED(hr)) OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Reset window to last size failed", "D3D10RenderWindow::resize" ); } else { md3dpp = pp; mWidth = width; mHeight = height; hr = mpSwapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &mpRenderSurface); hr = mDriver->mDevice->CreateDepthStencilSurface( mWidth, mHeight, md3dpp.AutoDepthStencilFormat, md3dpp.MultiSampleType, md3dpp.MultiSampleQuality, (md3dpp.Flags & D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL), &mpRenderZBuffer, NULL ); if (FAILED(hr)) { OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Failed to create depth stencil surface for Swap Chain", "D3D10RenderWindow::resize" ); } } } // primary windows must reset the device else { md3dpp.BufferDesc.Width = mWidth = width; md3dpp.BufferDesc.Height = mHeight = height; static_cast<D3D10RenderSystem*>( Root::getSingleton().getRenderSystem())->_notifyDeviceLost(); } // Notify viewports of resize ViewportList::iterator it = mViewportList.begin(); while( it != mViewportList.end() ) (*it++).second->_updateDimensions(); */ }
WINEXPORT LRESULT CALLBACK WdeMainWndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam ) { HMENU menu; LRESULT ret; bool pass_to_def; WdeResInfo *res_info; WORD wp; about_info ai; if( WdeCleanupStarted ) { if( message == WM_DESTROY ) { PostQuitMessage( 0 ); } return( DefFrameProc( hWnd, hWinWdeMDIClient, message, wParam, lParam ) ); } pass_to_def = TRUE; ret = FALSE; res_info = WdeGetCurrentRes(); menu = WdeGetMenuHandle(); switch( message ) { case WM_INITMENU: handleInitMenu( menu ); break; case WM_USER: WdeSetStatusByID( -1, WDE_ONLYONEINSTANCE ); break; case WM_MENUSELECT: WdeHandleMenuSelect( wParam, lParam ); break; case WM_MEASUREITEM: WdeHandleMeasureItem( (MEASUREITEMSTRUCT *)lParam ); ret = TRUE; pass_to_def = FALSE; break; case WM_DRAWITEM: WdeHandleDrawItem( (DRAWITEMSTRUCT *)lParam ); ret = TRUE; pass_to_def = FALSE; break; case WM_MOVE: if( IsZoomed( hWnd ) ) { WdeSetOption( WdeOptIsScreenMax, TRUE ); } else if( !IsIconic( hWnd ) ) { WdeUpdateScreenPosOpt(); WdeSetOption( WdeOptIsScreenMax, FALSE ); } break; case WM_SIZE: if( wParam == SIZE_MAXIMIZED ) { WdeSetOption( WdeOptIsScreenMax, TRUE ); } else if( wParam != SIZE_MINIMIZED ) { WdeUpdateScreenPosOpt(); WdeSetOption( WdeOptIsScreenMax, FALSE ); } if( wParam != SIZE_MINIMIZED ) { WdeResizeWindows(); } pass_to_def = FALSE; break; case WM_COMMAND: wp = LOWORD( wParam ); if( !WdeIsMenuIDValid( menu, wp ) ) { break; } switch( wp ) { case IDM_SELECT_MODE: case IDM_DIALOG_TOOL: case IDM_PBUTTON_TOOL: case IDM_CBUTTON_TOOL: case IDM_RBUTTON_TOOL: case IDM_GBUTTON_TOOL: case IDM_FRAME_TOOL: case IDM_TEXT_TOOL: case IDM_ICON_TOOL: case IDM_EDIT_TOOL: case IDM_LISTBOX_TOOL: case IDM_COMBOBOX_TOOL: case IDM_HSCROLL_TOOL: case IDM_VSCROLL_TOOL: case IDM_SIZEBOX_TOOL: case IDM_STATUSBAR_TOOL: case IDM_LISTVIEW_TOOL: case IDM_TREEVIEW_TOOL: case IDM_TABCNTL_TOOL: case IDM_ANIMATE_TOOL: case IDM_UPDOWN_TOOL: case IDM_TRACKBAR_TOOL: case IDM_PROGRESS_TOOL: case IDM_HOTKEY_TOOL: case IDM_HEADER_TOOL: case IDM_CUSTOM1_TOOL: case IDM_CUSTOM2_TOOL: WdeSetBaseObject( wp ); pass_to_def = FALSE; break; case IDM_STICKY_TOOLS: WdeToggleStickyTools(); pass_to_def = FALSE; break; case IDM_FMLEFT: case IDM_FMRIGHT: case IDM_FMTOP: case IDM_FMBOTTOM: case IDM_FMVCENTRE: case IDM_FMHCENTRE: case IDM_ESCAPE: case IDM_DELETEOBJECT: case IDM_SPACE_HORZ: case IDM_SPACE_VERT: ret = WdePassToEdit( message, wParam, lParam ); pass_to_def = FALSE; break; case IDM_SELECT_DIALOG: WdeSelectDialog( res_info ); pass_to_def = FALSE; break; case IDM_OPTIONS: WdeDisplayOptions (); pass_to_def = FALSE; break; case IDM_NEW_RES: WdeCreateNewResource( NULL ); pass_to_def = FALSE; break; case IDM_DDE_CLEAR: WdeClearCurrentResource(); pass_to_def = FALSE; break; case IDM_OPEN_RES: WdeOpenResource( NULL ); pass_to_def = FALSE; break; case IDM_SAVE_RES: WdeSaveResource( res_info, FALSE ); pass_to_def = FALSE; break; case IDM_SAVEAS_RES: WdeSaveResource( res_info, TRUE ); pass_to_def = FALSE; break; case IDM_DDE_UPDATE_PRJ: WdeUpdateDDEEditSession(); break; case IDM_PASTEOBJECT: if( FMPasteValid() ) { ret = WdePassToEdit( message, wParam, lParam ); } pass_to_def = FALSE; break; case IDM_CUTOBJECT: case IDM_COPYOBJECT: ret = WdePassToEdit( message, wParam, lParam ); pass_to_def = FALSE; break; case IDM_SAME_WIDTH: WdeSameSize( R_RIGHT ); pass_to_def = FALSE; break; case IDM_SAME_HEIGHT: WdeSameSize( R_BOTTOM ); pass_to_def = FALSE; break; case IDM_SAME_SIZE: WdeSameSize( R_BOTTOM | R_RIGHT ); pass_to_def = FALSE; break; case IDM_SIZETOTEXT: WdeHandleSizeToText(); pass_to_def = FALSE; break; case IDM_GOTO_INFOBAR: WdeSetFocusToInfo(); pass_to_def = FALSE; break; case IDM_GOTO_OBJECT: WdeHandleGotoCurrentObject(); pass_to_def = FALSE; break; case IDM_DIALOG_RESTORE: WdeRestoreCurrentDialog(); pass_to_def = FALSE; break; case IDM_TAB: case IDM_STAB: WdeHandleTabEvent( wp == IDM_TAB ); pass_to_def = FALSE; break; #if 0 /* this strategy has been rejected in favor of the hide option */ case IDM_REMOVE_DIALOG: WdeRemoveDialog( res_info ); pass_to_def = FALSE; break; #endif case IDM_HIDE_DIALOG: WdeHideCurrentDialog(); pass_to_def = FALSE; break; case IDM_TEST_MODE: WdeHandleTestModeMenu( res_info ); pass_to_def = FALSE; break; case IDM_DIALOG_NEW: if( WdeCreateNewDialog( NULL, res_info->is32bit ) ) { WdeHandleGotoCurrentObject(); } pass_to_def = FALSE; break; case IDM_DIALOG_SAVE: case IDM_DIALOG_SAVEAS: case IDM_DIALOG_SAVEINTO: WdeSaveCurrentDialog( wp ); pass_to_def = FALSE; break; case IDM_SET_ORDER: case IDM_SET_TABS: case IDM_SET_GROUPS: WdeSetDialogMode( wp ); pass_to_def = FALSE; break; case IDM_DEFINEOBJECT: case IDM_GEN_DEFINEOBJECT: if( !WdeDefineCurrentObject( wp ) ) { WdeWriteTrail( "WdeResWndProc: Define failed!" ); } pass_to_def = FALSE; break; case IDM_MDI_CASCADE: case IDM_MDI_TILEV: case IDM_MDI_TILEH: case IDM_MDI_ARRANGE: WdeHandleMDIArrangeEvents( wp ); pass_to_def = FALSE; break; case IDM_EXIT: /* clean up before we exit */ PostMessage( hWinWdeMain, WM_CLOSE, 0, 0 ); break; case IDM_SELCUST1: case IDM_SELCUST2: if( !WdeSetCurrentCustControl( wp - IDM_SELCUST1 ) ) { WdeWriteTrail( "WdeMainWndProc: WdeSetCurrentCustControl failed!" ); WdeSetStatusByID( -1, WDE_SETFAILED ); } pass_to_def = FALSE; break; case IDM_MS_CUSTOM: WdeLoadCustomLib( TRUE, FALSE ); pass_to_def = FALSE; break; #ifndef __NT__ case IDM_BOR_CUSTOM: WdeLoadCustomLib( FALSE, FALSE ); pass_to_def = FALSE; break; #endif case IDM_LOADLIB: WdeLoadCustomLib( FALSE, TRUE ); pass_to_def = FALSE; break; case IDM_WRITE_SYMBOLS: WdeResourceHashTableAction( res_info, WRITE_HASH ); pass_to_def = FALSE; break; case IDM_LOAD_SYMBOLS: WdeResourceHashTableAction( res_info, LOAD_HASH ); pass_to_def = FALSE; break; case IDM_VIEW_SYMBOLS: WdeResourceHashTableAction( res_info, VIEW_HASH ); pass_to_def = FALSE; break; case IDM_SHOW_TOOLS: WdeHandleShowToolsMenu(); pass_to_def = FALSE; break; case IDM_SHOW_RIBBON: WdeShowRibbon(); pass_to_def = FALSE; break; case IDM_HELP: WdeHelpRoutine(); pass_to_def = FALSE; break; case IDM_HELP_SEARCH: WdeHelpSearchRoutine(); pass_to_def = FALSE; break; case IDM_HELP_ON_HELP: WdeHelpOnHelpRoutine(); pass_to_def = FALSE; break; case IDM_ABOUT: ai.owner = hWnd; ai.inst = hInstWde; ai.name = AllocRCString( WDE_ABOUT_NAME ); ai.version = AllocRCString( WDE_ABOUT_VERSION ); ai.first_cr_year = "1984"; ai.title = AllocRCString( WDE_ABOUT_TITLE ); DoAbout( &ai ); FreeRCString( ai.name ); FreeRCString( ai.version ); FreeRCString( ai.title ); pass_to_def = FALSE; break; } break; case WM_DESTROY: WWinHelp( hWinWdeMain, "resdlg.hlp", HELP_QUIT, 0 ); PostQuitMessage( 0 ); break; case WDE_FATAL_EXIT: WdeFatalExit = TRUE; WdeQueryKillApp( TRUE ); PostMessage( hWinWdeMain, WM_CLOSE, 0, 0 ); break; case WM_ENDSESSION: if ( !wParam ) { WdeFatalExit = FALSE; } break; case WM_QUERYENDSESSION: ret = WdeQueryKillApp( FALSE ); if( ret ) { WdeFatalExit = TRUE; pass_to_def = FALSE; } break; case WM_CLOSE: // this prevents the user from closing the editor during // DDE initialization if( !wParam && !EnableMenuInput ) { return( 0 ); } /* clean up before we exit */ WdeCleanupStarted = TRUE; if( wParam ) { // wParam is non-zero if the DDE connection died WdeFatalExit = TRUE; WdeQueryKillApp( TRUE ); wParam = 0; } if( !WdeCleanup( res_info, WdeFatalExit ) ) { WdeCleanupStarted = FALSE; pass_to_def = FALSE; } } if( pass_to_def ) { ret = DefFrameProc( hWnd, hWinWdeMDIClient, message, wParam, lParam ); } return( ret ); }
/* CDirect3D::Render does the actual rendering, changes the draw surface if necessary and recalculates the vertex information if filter output size changes IN: Src - the input surface */ void CDirect3D::Render(SSurface Src) { SSurface Dst; RECT dstRect; unsigned int newFilterScale; D3DLOCKED_RECT lr; D3DLOCKED_RECT lrConv; HRESULT hr; if(!init_done) return; //create a new draw surface if the filter scale changes //at least factor 2 so we can display unscaled hi-res images newFilterScale = max(2,max(GetFilterScale(GUI.ScaleHiRes),GetFilterScale(GUI.Scale))); if(newFilterScale!=filterScale) { ChangeDrawSurfaceSize(newFilterScale); } if(FAILED(hr = pDevice->TestCooperativeLevel())) { switch(hr) { case D3DERR_DEVICELOST: //do no rendering until device is restored return; case D3DERR_DEVICENOTRESET: //we can reset now if(!IsIconic(dPresentParams.hDeviceWindow)) ResetDevice(); return; default: DXTRACE_ERR_MSGBOX(TEXT("Internal driver error"), hr); return; } } //BlankTexture(drawSurface); if(FAILED(hr = drawSurface->LockRect(0, &lr, NULL, 0))) { DXTRACE_ERR_MSGBOX(TEXT("Unable to lock texture"), hr); return; } else { Dst.Surface = (unsigned char *)lr.pBits; Dst.Height = quadTextureSize; Dst.Width = quadTextureSize; Dst.Pitch = lr.Pitch; RenderMethod (Src, Dst, &dstRect); if(!Settings.AutoDisplayMessages) { WinSetCustomDisplaySurface((void *)Dst.Surface, Dst.Pitch/2, dstRect.right-dstRect.left, dstRect.bottom-dstRect.top, GetFilterScale(CurrentScale)); S9xDisplayMessages ((uint16*)Dst.Surface, Dst.Pitch/2, dstRect.right-dstRect.left, dstRect.bottom-dstRect.top, GetFilterScale(CurrentScale)); } drawSurface->UnlockRect(0); } if (!GUI.Stretch || GUI.AspectRatio) { Clear(); } //if the output size of the render method changes we need to update the viewport if(afterRenderHeight != dstRect.bottom || afterRenderWidth != dstRect.right) { afterRenderHeight = dstRect.bottom; afterRenderWidth = dstRect.right; SetViewport(); } pDevice->SetTexture(0, drawSurface); pDevice->SetVertexDeclaration(vertexDeclaration); pDevice->SetStreamSource(0,vertexBuffer,0,sizeof(VERTEX)); if(shader_type == D3D_SHADER_CG) { RECT displayRect; //Get maximum rect respecting AR setting displayRect=CalculateDisplayRect(dPresentParams.BackBufferWidth,dPresentParams.BackBufferHeight, dPresentParams.BackBufferWidth,dPresentParams.BackBufferHeight); cgShader->Render(drawSurface, XMFLOAT2((float)quadTextureSize, (float)quadTextureSize), XMFLOAT2((float)afterRenderWidth, (float)afterRenderHeight), XMFLOAT2((float)(displayRect.right - displayRect.left), (float)(displayRect.bottom - displayRect.top)), XMFLOAT2((float)dPresentParams.BackBufferWidth, (float)dPresentParams.BackBufferHeight)); } SetFiltering(); pDevice->SetVertexDeclaration(vertexDeclaration); pDevice->BeginScene(); pDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP,0,2); pDevice->EndScene(); pDevice->Present(NULL, NULL, NULL, NULL); if (GUI.ReduceInputLag) { IDirect3DSurface9 *surface; RECT r = { 0, 0, 2, 2 }; if (pDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &surface) == D3D_OK) { if (surface->LockRect(&lr, &r, D3DLOCK_READONLY) == D3D_OK) { surface->UnlockRect(); } surface->Release(); } } return; }
/////////////////////////////////////////////////// // call this function to page wnds,when // the window is resized. void CBSWndContainer::UpdateWnd() { if(!IsWindowVisible()||IsIconic()) return; ///////////////////// //计算显示总区域 //得到窗口的设备坐标 CRect rtContainer; GetClientRect(&rtContainer); GetShowRect(&rtContainer); rtContainer.DeflateRect(1,1); //调整Container位置 if(m_bAutoAdjustPos) AdjustRect(&rtContainer); ///////////////////// // if(m_bMultiScreen) { //多屏状态 CRect rt; int nCount=m_PageList.GetCount(); int i=0; for(POSITION pos=m_PageList.GetHeadPosition(); pos!=NULL;) { CWnd *p=m_PageList.GetNext(pos); rt=rtContainer; CalcPageRect(&rt,i,nCount); rt.DeflateRect(WINDOW_SPACE,WINDOW_SPACE,WINDOW_SPACE,WINDOW_SPACE); //窗口之间的间隔 p->MoveWindow(&rt); p->ShowWindow(SW_SHOW); i++; WinSetRect(p,rt); } if( m_bDrawActive && m_PageList.GetCount()>1 ) DrawActivePage(TRUE); } else { //单屏状态 for(POSITION pos=m_PageList.GetHeadPosition(); pos!=NULL;) { CWnd *p=m_PageList.GetNext(pos); if(p==m_pActivePage) { p->MoveWindow(&rtContainer); WinSetRect(p,rtContainer); } else { if(m_bFullScreen) { p->MoveWindow(0,0,1,1); WinSetRect(p,CRect(0,0,1,1)); } else { p->MoveWindow(rtContainer.right+1,rtContainer.bottom+1,1,1); WinSetRect(p,CRect(rtContainer.right+1,rtContainer.bottom+1,1,1)); } } } } }
LRESULT CALLBACK InternalWndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam) { PAINTSTRUCT ps; // Structure for the paint message POINT p = {0, 0}; // Translation point for the window's client region HRESULT hRet; switch (iMsg) { case WM_MOVE: // Make sure we're not moving to be minimized - because otherwise // our ratio varialbes (g_dwXRatio and g_dwYRatio) will end up // being 0, and once we hit CheckBoundries it divides by 0. if (!IsIconic(hwnd)) { g_rcSrc.left = 0; g_rcSrc.right = g_sizex; g_rcSrc.top = 0; g_rcSrc.bottom = g_sizey; GetClientRect(hwnd, &g_rcDst); g_dwXRatio = (g_rcDst.right - g_rcDst.left) * 1000 / (g_rcSrc.right - g_rcSrc.left); g_dwYRatio = (g_rcDst.bottom - g_rcDst.top) * 1000 / (g_rcSrc.bottom - g_rcSrc.top); ClientToScreen(hwnd, &p); g_rcDst.left = p.x; g_rcDst.top = p.y; g_rcDst.bottom += p.y; g_rcDst.right += p.x; CheckBoundries(); } else // Else, hide the overlay... just in case we can't do // destination color keying, this will pull the overlay // off of the screen for the user. if (g_pDDSOverlay && g_pDDSPrimary) g_pDDSOverlay->UpdateOverlay(NULL, g_pDDSPrimary, NULL, DDOVER_HIDE, NULL); // Check to make sure our window exists before we tell it to // repaint. This will fail the first time (while the window is being created). if (hwnd) { InvalidateRect(hwnd, NULL, FALSE); UpdateWindow(hwnd); } return 0L; case WM_SIZE: // Another check for the minimization action. This check is // quicker though... if (wParam != SIZE_MINIMIZED) { GetClientRect(hwnd, &g_rcDst); ClientToScreen(hwnd, &p); g_rcDst.left = p.x; g_rcDst.top = p.y; g_rcDst.bottom += p.y; g_rcDst.right += p.x; g_rcSrc.left = 0; g_rcSrc.right = g_sizex; g_rcSrc.top = 0; g_rcSrc.bottom = g_sizey; // Here we multiply by 1000 to preserve 3 decimal places in the // division opperation (we picked 1000 to be on the same order // of magnitude as the stretch factor for easier comparisons) g_dwXRatio = (g_rcDst.right - g_rcDst.left) * 1000 / (g_rcSrc.right - g_rcSrc.left); g_dwYRatio = (g_rcDst.bottom - g_rcDst.top) * 1000 / (g_rcSrc.bottom - g_rcSrc.top); CheckBoundries(); } return 0L; case WM_PAINT: BeginPaint(hwnd, &ps); // Check the primary surface to see if it's lost - if so you can // pretty much bet that the other surfaces are also lost - thus // restore EVERYTHING! If we got our surfaces stolen by a full // screen app - then we'll destroy our primary - and won't be able // to initialize it again. When we get our next paint message (the // full screen app closed for example) we'll want to try to reinit // the surfaces again - that's why there is a check for // g_pDDSPrimary == NULL. The other option, is that our program // went through this process, could init the primary again, but it // couldn't init the overlay, that's why there's a third check for // g_pDDSOverlay == NULL. Make sure that the check for // !g_pDDSPrimary is BEFORE the IsLost call - that way if the // pointer is NULL (ie. !g_pDDSPrimary is TRUE) - the compiler // won't try to evaluate the IsLost function (which, since the // g_pDDSPrimary surface is NULL, would be bad...). if (!g_pDDSPrimary || (g_pDDSPrimary->IsLost() != DD_OK) || (g_pDDSOverlay == NULL)) { DestroyOverlay(); DestroyPrimary(); if (DDPrimaryInit()) if (DDOverlayInit()) if (!DrawOverlay()) DestroyOverlay(); } // UpdateOverlay is how we put the overlay on the screen. if (g_pDDSOverlay && g_pDDSPrimary && g_video->updating) { hRet = g_pDDSOverlay->UpdateOverlay(&g_rcSrc, g_pDDSPrimary, &g_rcDst, g_OverlayFlags, &g_OverlayFX); #ifdef _DEBUG if(hRet != DD_OK) DisplayError("Can't update overlay", hRet); #endif } EndPaint(hwnd, &ps); return 0L; // process mouse and keyboard events case WM_LBUTTONDOWN: mouse(1, lParam); break; case WM_LBUTTONUP: mouse(-1, lParam); break; case WM_RBUTTONDOWN: mouse(2, lParam); break; case WM_RBUTTONUP: mouse(-2, lParam); break; case WM_MBUTTONDOWN: mouse(3, lParam); break; case WM_MBUTTONUP: mouse(-3, lParam); break; case WM_CHAR: g_video->on_key(wParam); break; case WM_DISPLAYCHANGE: return 0L; case WM_DESTROY: // Now, shut down the window... PostQuitMessage(0); return 0L; } return g_pUserProc? g_pUserProc(hwnd, iMsg, wParam, lParam) : DefWindowProc(hwnd, iMsg, wParam, lParam); }
HWND TSAPI CreateNewTabForContact(TContainerData *pContainer, MCONTACT hContact, int isSend, const char *pszInitialText, BOOL bActivateTab, BOOL bPopupContainer, BOOL bWantPopup, HANDLE hdbEvent) { TCHAR newcontactname[128], tabtitle[128]; int newItem; DBVARIANT dbv = {0}; if (M.FindWindow(hContact) != 0) { _DebugPopup(hContact, _T("Warning: trying to create duplicate window")); return 0; } // if we have a max # of tabs/container set and want to open something in the default container... if (hContact != 0 && M.GetByte("limittabs", 0) && !_tcsncmp(pContainer->szName, _T("default"), 6)) { if ((pContainer = FindMatchingContainer(_T("default"), hContact)) == NULL) { TCHAR szName[CONTAINER_NAMELEN + 1]; mir_sntprintf(szName, CONTAINER_NAMELEN, _T("default")); if ((pContainer = CreateContainer(szName, CNT_CREATEFLAG_CLONED, hContact)) == NULL) return 0; } } TNewWindowData newData = {0}; newData.hContact = hContact; newData.isWchar = isSend; newData.szInitialText = pszInitialText; char *szProto = GetContactProto(newData.hContact); ZeroMemory(&newData.item, sizeof(newData.item)); // obtain various status information about the contact TCHAR *contactName = pcli->pfnGetContactDisplayName(newData.hContact, 0); /* * cut nickname if larger than x chars... */ if (contactName && lstrlen(contactName) > 0) { if (M.GetByte("cuttitle", 0)) CutContactName(contactName, newcontactname, SIZEOF(newcontactname)); else { lstrcpyn(newcontactname, contactName, SIZEOF(newcontactname)); newcontactname[127] = 0; } //Mad: to fix tab width for nicknames with ampersands Utils::DoubleAmpersands(newcontactname); } else lstrcpyn(newcontactname, _T("_U_"), SIZEOF(newcontactname)); WORD wStatus = (szProto == NULL ? ID_STATUS_OFFLINE : db_get_w(newData.hContact, szProto, "Status", ID_STATUS_OFFLINE)); TCHAR *szStatus = pcli->pfnGetStatusModeDescription(szProto == NULL ? ID_STATUS_OFFLINE : db_get_w(newData.hContact, szProto, "Status", ID_STATUS_OFFLINE), 0); if (M.GetByte("tabstatus", 1)) mir_sntprintf(tabtitle, SIZEOF(tabtitle), _T("%s (%s) "), newcontactname, szStatus); else mir_sntprintf(tabtitle, SIZEOF(tabtitle), _T("%s "), newcontactname); newData.item.pszText = tabtitle; newData.item.mask = TCIF_TEXT | TCIF_IMAGE | TCIF_PARAM; newData.item.iImage = 0; newData.item.cchTextMax = 255; HWND hwndTab = GetDlgItem(pContainer->hwnd, IDC_MSGTABS); // hide the active tab if (pContainer->hwndActive && bActivateTab) ShowWindow(pContainer->hwndActive, SW_HIDE); { int iTabIndex_wanted = M.GetDword(hContact, "tabindex", pContainer->iChilds * 100); int iCount = TabCtrl_GetItemCount(hwndTab); TCITEM item = {0}; int relPos; int i; pContainer->iTabIndex = iCount; if (iCount > 0) { for (i = iCount - 1; i >= 0; i--) { item.mask = TCIF_PARAM; TabCtrl_GetItem(hwndTab, i, &item); HWND hwnd = (HWND)item.lParam; TWindowData *dat = (TWindowData*)GetWindowLongPtr(hwnd, GWLP_USERDATA); if (dat) { relPos = M.GetDword(dat->hContact, "tabindex", i * 100); if (iTabIndex_wanted <= relPos) pContainer->iTabIndex = i; } } } } newItem = TabCtrl_InsertItem(hwndTab, pContainer->iTabIndex, &newData.item); SendMessage(hwndTab, EM_REFRESHWITHOUTCLIP, 0, 0); if (bActivateTab) TabCtrl_SetCurSel(GetDlgItem(pContainer->hwnd, IDC_MSGTABS), newItem); newData.iTabID = newItem; newData.iTabImage = newData.item.iImage; newData.pContainer = pContainer; newData.iActivate = (int) bActivateTab; pContainer->iChilds++; newData.bWantPopup = bWantPopup; newData.hdbEvent = hdbEvent; HWND hwndNew = CreateDialogParam(g_hInst, MAKEINTRESOURCE(IDD_MSGSPLITNEW), GetDlgItem(pContainer->hwnd, IDC_MSGTABS), DlgProcMessage, (LPARAM)&newData); /* * switchbar support */ if (pContainer->dwFlags & CNT_SIDEBAR) { TWindowData *dat = (TWindowData*)GetWindowLongPtr(hwndNew, GWLP_USERDATA); if (dat) pContainer->SideBar->addSession(dat, pContainer->iTabIndex); } SendMessage(pContainer->hwnd, WM_SIZE, 0, 0); // if the container is minimized, then pop it up... if (IsIconic(pContainer->hwnd)) { if (bPopupContainer) { SendMessage(pContainer->hwnd, WM_SYSCOMMAND, SC_RESTORE, 0); SetFocus(pContainer->hwndActive); } else { if (pContainer->dwFlags & CNT_NOFLASH) SendMessage(pContainer->hwnd, DM_SETICON, 0, (LPARAM)LoadSkinnedIcon(SKINICON_EVENT_MESSAGE)); else FlashContainer(pContainer, 1, 0); } } if (bActivateTab) { ActivateExistingTab(pContainer, hwndNew); SetFocus(hwndNew); RedrawWindow(pContainer->hwnd, NULL, NULL, RDW_ERASENOW); UpdateWindow(pContainer->hwnd); if (GetForegroundWindow() != pContainer->hwnd && bPopupContainer == TRUE) SetForegroundWindow(pContainer->hwnd); } else if (!IsIconic(pContainer->hwnd) && IsWindowVisible(pContainer->hwnd)) { SendMessage(pContainer->hwndActive, WM_SIZE, 0, 0); RedrawWindow(pContainer->hwndActive, NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_UPDATENOW); RedrawWindow(pContainer->hwndActive, NULL, NULL, RDW_ERASENOW | RDW_UPDATENOW); } //MaD if (PluginConfig.m_HideOnClose&&!IsWindowVisible(pContainer->hwnd)) { WINDOWPLACEMENT wp={0}; wp.length = sizeof(wp); GetWindowPlacement(pContainer->hwnd, &wp); BroadCastContainer(pContainer, DM_CHECKSIZE, 0, 0); // make sure all tabs will re-check layout on activation if (wp.showCmd == SW_SHOWMAXIMIZED) ShowWindow(pContainer->hwnd, SW_SHOWMAXIMIZED); else { if (bPopupContainer) ShowWindow(pContainer->hwnd, SW_SHOWNORMAL); else ShowWindow(pContainer->hwnd, SW_SHOWMINNOACTIVE); } SendMessage(pContainer->hwndActive, WM_SIZE, 0, 0); } if (PluginConfig.m_bIsWin7 && PluginConfig.m_useAeroPeek && CSkin::m_skinEnabled) CWarning::show(CWarning::WARN_AEROPEEK_SKIN, MB_ICONWARNING|MB_OK); if (ServiceExists(MS_HPP_EG_EVENT) && ServiceExists(MS_IEVIEW_EVENT) && db_get_b(0, "HistoryPlusPlus", "IEViewAPI", 0)) if (IDYES == CWarning::show(CWarning::WARN_HPP_APICHECK, MB_ICONWARNING|MB_YESNO)) db_set_b(0, "HistoryPlusPlus", "IEViewAPI", 0); return hwndNew; // return handle of the new dialog }
void SetIconic() { if (IsIconic(GetConsoleWindow())) ConsoleIconic = 1; else ConsoleIconic = 0; }
int Docking_ProcessWindowMessage(WPARAM wParam, LPARAM lParam) { APPBARDATA abd; static int draggingTitle; MSG *msg = (MSG *)wParam; if (msg->message == WM_DESTROY) cfg::writeByte("CList", "Docked", (BYTE)docked); if (!docked && msg->message != WM_CREATE && msg->message != WM_MOVING && msg->message != WM_CREATEDOCKED && msg->message != WM_MOVE) return 0; switch (msg->message) { case WM_CREATE: //if (GetSystemMetrics(SM_CMONITORS)>1) return 0; if (cfg::getByte("CList", "Docked", 0)) PostMessage(msg->hwnd, WM_CREATEDOCKED, 0, 0); draggingTitle = 0; return 0; case WM_CREATEDOCKED: //we need to post a message just after creation to let main message function do some work docked = (int)(char)cfg::getByte("CList", "Docked", 0); if (IsWindowVisible(msg->hwnd) && !IsIconic(msg->hwnd)) { RECT rc, rcMonitor; memset(&abd, 0, sizeof(abd)); abd.cbSize = sizeof(abd); abd.hWnd = msg->hwnd; abd.lParam = 0; abd.uCallbackMessage = WM_DOCKCALLBACK; SHAppBarMessage(ABM_NEW, &abd); GetWindowRect(msg->hwnd, &rc); Docking_GetMonitorRectFromWindow(msg->hwnd, &rcMonitor); Docking_AdjustPosition(msg->hwnd, &rcMonitor, &rc); MoveWindow(msg->hwnd, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, TRUE); } break; case WM_ACTIVATE: memset(&abd, 0, sizeof(abd)); abd.cbSize = sizeof(abd); abd.hWnd = msg->hwnd; SHAppBarMessage(ABM_ACTIVATE, &abd); return 0; case WM_WINDOWPOSCHANGED: memset(&abd, 0, sizeof(abd)); abd.cbSize = sizeof(abd); abd.hWnd = msg->hwnd; SHAppBarMessage(ABM_WINDOWPOSCHANGED, &abd); return 0; case WM_MOVING: { RECT rcMonitor; POINT ptCursor; // stop early if (GetAsyncKeyState(VK_CONTROL) & 0x8000) return 0; // GetMessagePos() is no good, position is always unsigned GetCursorPos(&ptCursor); Docking_GetMonitorRectFromPoint(ptCursor, &rcMonitor); if ((ptCursor.x < rcMonitor.left + EDGESENSITIVITY) || (ptCursor.x >= rcMonitor.right - EDGESENSITIVITY)) { if (!(GetWindowLongPtr(msg->hwnd, GWL_EXSTYLE) & WS_EX_TOOLWINDOW)) { SendMessage(msg->hwnd, CLUIINTM_REDRAW, 0, 0); MessageBox(0, TranslateT("The contact list cannot be docked when using the default title bar and border. Use a toolwindow or borderless style instead."), TranslateT("Contact list docking"), MB_OK); return 0; } memset(&abd, 0, sizeof(abd)); abd.cbSize = sizeof(abd); abd.hWnd = msg->hwnd; abd.lParam = 0; abd.uCallbackMessage = WM_DOCKCALLBACK; SHAppBarMessage(ABM_NEW, &abd); if (ptCursor.x < rcMonitor.left + EDGESENSITIVITY) docked = DOCKED_LEFT; else docked = DOCKED_RIGHT; SendMessage(msg->hwnd, WM_LBUTTONUP, 0, MAKELPARAM(ptCursor.x, ptCursor.y)); GetWindowRect(msg->hwnd, (LPRECT)msg->lParam); Docking_AdjustPosition(msg->hwnd, (LPRECT)&rcMonitor, (LPRECT)msg->lParam); PostMessage(msg->hwnd, CLUIINTM_REDRAW, 0, 0); return TRUE; } } return 0; case WM_MOVE: if (docked) { RECT rc, rcMonitor; Docking_GetMonitorRectFromWindow(msg->hwnd, &rcMonitor); GetWindowRect(msg->hwnd, &rc); Docking_AdjustPosition(msg->hwnd, &rcMonitor, &rc); MoveWindow(msg->hwnd, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, TRUE); return 1; } return 0; case WM_SIZING: { RECT rcMonitor; Docking_GetMonitorRectFromWindow(msg->hwnd, &rcMonitor); Docking_AdjustPosition(msg->hwnd, &rcMonitor, (LPRECT)msg->lParam); *((LRESULT *)lParam) = TRUE; } return TRUE; case WM_SHOWWINDOW: if (msg->lParam) return 0; if ((msg->wParam && docked < 0) || (!msg->wParam && docked > 0)) docked = -docked; memset(&abd, 0, sizeof(abd)); abd.cbSize = sizeof(abd); abd.hWnd = msg->hwnd; if (msg->wParam) { RECT rc, rcMonitor; Docking_GetMonitorRectFromWindow(msg->hwnd, &rcMonitor); abd.lParam = 0; abd.uCallbackMessage = WM_DOCKCALLBACK; SHAppBarMessage(ABM_NEW, &abd); GetWindowRect(msg->hwnd, &rc); Docking_AdjustPosition(msg->hwnd, &rcMonitor, &rc); MoveWindow(msg->hwnd, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, FALSE); } else SHAppBarMessage(ABM_REMOVE, &abd); return 0; case WM_NCHITTEST: { LONG result = DefWindowProc(msg->hwnd, WM_NCHITTEST, msg->wParam, msg->lParam); if (result == HTSIZE || result == HTTOP || result == HTTOPLEFT || result == HTTOPRIGHT || result == HTBOTTOM || result == HTBOTTOMRIGHT || result == HTBOTTOMLEFT) { *((LRESULT *)lParam) = HTCLIENT; return TRUE; } if (docked == DOCKED_LEFT && result == HTLEFT) { *((LRESULT *)lParam) = HTCLIENT; return TRUE; } if (docked == DOCKED_RIGHT && result == HTRIGHT) { *((LRESULT *)lParam) = HTCLIENT; return TRUE; } } return 0; case WM_SYSCOMMAND: if ((msg->wParam & 0xFFF0) != SC_MOVE) return 0; SetActiveWindow(msg->hwnd); SetCapture(msg->hwnd); draggingTitle = 1; *((LRESULT *)lParam) = 0; return TRUE; case WM_MOUSEMOVE: if (!draggingTitle) return 0; { RECT rc; POINT pt; GetClientRect(msg->hwnd, &rc); if (((docked == DOCKED_LEFT || docked == -DOCKED_LEFT) && (short)LOWORD(msg->lParam) > rc.right) || ((docked == DOCKED_RIGHT || docked == -DOCKED_RIGHT) && (short)LOWORD(msg->lParam) < 0)) { ReleaseCapture(); draggingTitle = 0; memset(&abd, 0, sizeof(abd)); abd.cbSize = sizeof(abd); abd.hWnd = msg->hwnd; SHAppBarMessage(ABM_REMOVE, &abd); docked = 0; GetCursorPos(&pt); PostMessage(msg->hwnd, WM_NCLBUTTONDOWN, HTCAPTION, MAKELPARAM(pt.x, pt.y)); SetWindowPos(msg->hwnd, 0, pt.x - rc.right / 2, pt.y - GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYSMCAPTION) / 2, cluiPos.right, cluiPos.bottom, SWP_NOZORDER); } } return 1; case WM_LBUTTONUP: if (draggingTitle) { ReleaseCapture(); draggingTitle = 0; } return 0; case WM_DOCKCALLBACK: switch (msg->wParam) { case ABN_WINDOWARRANGE: ShowWindow(msg->hwnd, msg->lParam ? SW_HIDE : SW_SHOW); break; } return TRUE; case WM_DESTROY: if (docked > 0) { memset(&abd, 0, sizeof(abd)); abd.cbSize = sizeof(abd); abd.hWnd = msg->hwnd; SHAppBarMessage(ABM_REMOVE, &abd); } return 0; } return 0; }
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpstrCmdLine, int nCmdShow) { g_hInstance = hInstance; json_value* appSettings = GetApplicationSettings(); if (GetApplicationSettingsError().length()) { std::string error = GetApplicationSettingsError(); error.append("\nApplication will terminate immediately. "); FatalError(NULL, error); } // Debugging options. bool show_console = (*appSettings)["debugging"]["show_console"]; bool subprocess_show_console = (*appSettings)["debugging"]["subprocess_show_console"]; std::string log_level = (*appSettings)["debugging"]["log_level"]; std::string log_file = (*appSettings)["debugging"]["log_file"]; log_file = GetAbsolutePath(log_file); // Initialize logging. if (std::wstring(lpstrCmdLine).find(L"--type=") != std::string::npos) { // This is a subprocess. InitializeLogging(subprocess_show_console, log_level, log_file); } else { // Main browser process. InitializeLogging(show_console, log_level, log_file); } // Command line arguments LPWSTR *argv; int argc; argv = CommandLineToArgvW(GetCommandLineW(), &argc); if (argv) { for (int i = 0; i < argc; i++) { std::string argument = WideToUtf8(std::wstring(argv[i])); size_t pos = argument.find("="); if (pos != std::string::npos) { std::string name = argument.substr(0, pos); std::string value = argument.substr(pos+1, std::string::npos); if (name == "--cgi-environment" && value.length()) { g_cgiEnvironmentFromArgv.assign(value); } } } } else { LOG_WARNING << "CommandLineToArgvW() failed"; } // CEF subprocesses. CefMainArgs main_args(hInstance); CefRefPtr<App> app(new App); int exit_code = CefExecuteProcess(main_args, app.get(), NULL); if (exit_code >= 0) { ShutdownLogging(); return exit_code; } LOG_INFO << "--------------------------------------------------------"; LOG_INFO << "Started application"; if (log_file.length()) LOG_INFO << "Logging to: " << log_file; else LOG_INFO << "No logging file set"; LOG_INFO << "Log level = " << FILELog::ToString(FILELog::ReportingLevel()); // Main window title option. std::string main_window_title = (*appSettings)["main_window"]["title"]; if (main_window_title.empty()) main_window_title = GetExecutableName(); // Single instance guid option. const char* single_instance_guid = (*appSettings)["application"]["single_instance_guid"]; if (single_instance_guid && single_instance_guid[0] != 0) { int guidSize = strlen(single_instance_guid) + 1; g_singleInstanceApplicationGuid = new wchar_t[guidSize]; Utf8ToWide(single_instance_guid, g_singleInstanceApplicationGuid, guidSize); } if (g_singleInstanceApplicationGuid && g_singleInstanceApplicationGuid[0] != 0) { g_singleInstanceApplication.Initialize( g_singleInstanceApplicationGuid); if (g_singleInstanceApplication.IsRunning()) { HWND hwnd = FindWindow(g_singleInstanceApplicationGuid, NULL); if (hwnd) { if (IsIconic(hwnd)) ShowWindow(hwnd, SW_RESTORE); SetForegroundWindow(hwnd); return 0; } } } // Window class name. if (g_singleInstanceApplicationGuid) { swprintf_s(g_windowClassName, _countof(g_windowClassName), L"%s", g_singleInstanceApplicationGuid); } else { swprintf_s(g_windowClassName, _countof(g_windowClassName), L"%s", Utf8ToWide(GetExecutableName()).c_str()); } if (!StartWebServer()) { FatalError(NULL, "Error while starting an internal local server.\n" "Application will terminate immediately."); } CefSettings cef_settings; // log_file std::string chrome_log_file = (*appSettings)["chrome"]["log_file"]; chrome_log_file = GetAbsolutePath(chrome_log_file); CefString(&cef_settings.log_file) = chrome_log_file; // log_severity std::string chrome_log_severity = (*appSettings)["chrome"]["log_severity"]; cef_log_severity_t log_severity = LOGSEVERITY_DEFAULT; if (chrome_log_severity == "verbose") { log_severity = LOGSEVERITY_VERBOSE; } else if (chrome_log_severity == "info") { log_severity = LOGSEVERITY_INFO; } else if (chrome_log_severity == "warning") { log_severity = LOGSEVERITY_WARNING; } else if (chrome_log_severity == "error") { log_severity = LOGSEVERITY_ERROR; } else if (chrome_log_severity == "error-report") { log_severity = LOGSEVERITY_ERROR_REPORT; } else if (chrome_log_severity == "disable") { log_severity = LOGSEVERITY_DISABLE; } cef_settings.log_severity = log_severity; // cache_path std::string cache_path = (*appSettings)["chrome"]["cache_path"]; cache_path = GetAbsolutePath(cache_path); CefString(&cef_settings.cache_path) = cache_path; // remote_debugging_port // A value of -1 will disable remote debugging. int remote_debugging_port = static_cast<long>( (*appSettings)["chrome"]["remote_debugging_port"]); if (remote_debugging_port == 0) { remote_debugging_port = random(49152, 65535+1); int i = 100; while (((i--) > 0) && remote_debugging_port == GetWebServerPort()) { remote_debugging_port = random(49152, 65535+1); } } if (remote_debugging_port > 0) { LOG_INFO << "remote_debugging_port = " << remote_debugging_port; cef_settings.remote_debugging_port = remote_debugging_port; } // Sandbox support cef_settings.no_sandbox = true; CefInitialize(main_args, cef_settings, app.get(), NULL); CreateMainWindow(hInstance, nCmdShow, main_window_title); CefRunMessageLoop(); CefShutdown(); LOG_INFO << "Ended application"; LOG_INFO << "--------------------------------------------------------"; ShutdownLogging(); return 0; }
int Docking_ProcessWindowMessage(WPARAM wParam,LPARAM lParam) { APPBARDATA abd; static int draggingTitle; MSG *msg=(MSG*)wParam; if(msg->message==WM_DESTROY) DBWriteContactSettingByte(NULL,"CList","Docked",(BYTE)docked); if(!docked && msg->message!=WM_CREATE && msg->message!=WM_MOVING && msg->message!=WM_CREATEDOCKED && msg->message != WM_MOVE && msg->message != WM_SIZE) return 0; switch(msg->message) { case WM_CREATE: //if(GetSystemMetrics(SM_CMONITORS)>1) return 0; if(DBGetContactSettingByte(NULL,"CList","Docked",0)) { PostMessage(msg->hwnd,WM_CREATEDOCKED,0,0); } draggingTitle=0; return 0; case WM_CREATEDOCKED: //we need to post a message just after creation to let main message function do some work docked=(int)(char)DBGetContactSettingByte(NULL,"CList","Docked",0); if(IsWindowVisible(msg->hwnd) && !IsIconic(msg->hwnd)) { RECT rc, rcMonitor; ZeroMemory(&abd,sizeof(abd)); abd.cbSize=sizeof(abd); abd.hWnd=msg->hwnd; abd.lParam=0; abd.uCallbackMessage=WM_DOCKCALLBACK; SHAppBarMessage(ABM_NEW,&abd); GetWindowRect(msg->hwnd,&rc); Docking_GetMonitorRectFromWindow(msg->hwnd,&rcMonitor); Docking_AdjustPosition(msg->hwnd,&rcMonitor,&rc); MoveWindow(msg->hwnd,rc.left,rc.top,rc.right-rc.left,rc.bottom-rc.top,TRUE); dock_prevent_moving=0; OnMoving(msg->hwnd,&rc); dock_prevent_moving=1; ReposButtons(msg->hwnd,0,NULL); } break; case WM_CAPTURECHANGED: ReposButtons(msg->hwnd,0,NULL); return 0; case WM_ACTIVATE: ZeroMemory(&abd,sizeof(abd)); abd.cbSize=sizeof(abd); abd.hWnd=msg->hwnd; SHAppBarMessage(ABM_ACTIVATE,&abd); return 0; case WM_SIZE: ReposButtons(msg->hwnd,1,NULL); return 0; case WM_WINDOWPOSCHANGED: { if (docked) ReposButtons(msg->hwnd,0,NULL); return 0; ZeroMemory(&abd,sizeof(abd)); abd.cbSize=sizeof(abd); abd.hWnd=msg->hwnd; SHAppBarMessage(ABM_WINDOWPOSCHANGED,&abd); ReposButtons(msg->hwnd,0,NULL); return 0; } case WM_MOVING: { RECT rcMonitor; RECT rcWindow; RECT *rc; int dx=0; POINT ptCursor; if (docked) return 0; // stop early if(!(GetAsyncKeyState(VK_CONTROL)&0x8000)) return 0; // GetMessagePos() is no good, position is always unsigned GetCursorPos(&ptCursor); GetWindowRect(msg->hwnd,&rcWindow); dock_drag_dx=rcWindow.left-ptCursor.x; dock_drag_dy=rcWindow.top-ptCursor.y; Docking_GetMonitorRectFromPoint(ptCursor,&rcMonitor); if(((ptCursor.x<rcMonitor.left+EDGESENSITIVITY) || (ptCursor.x>=rcMonitor.right-EDGESENSITIVITY)) ) { ZeroMemory(&abd,sizeof(abd)); abd.cbSize=sizeof(abd); abd.hWnd=msg->hwnd; abd.lParam=0; abd.uCallbackMessage=WM_DOCKCALLBACK; SHAppBarMessage(ABM_NEW,&abd); if(ptCursor.x<rcMonitor.left+EDGESENSITIVITY) docked=DOCKED_LEFT; else docked=DOCKED_RIGHT; // TempDock=1; GetWindowRect(msg->hwnd,(LPRECT)msg->lParam); rc=(RECT*)msg->lParam; if (docked==DOCKED_RIGHT) dx=(rc->right>rcMonitor.right)?rc->right-rcMonitor.right:0; else dx=(rc->left<rcMonitor.left)?rc->left-rcMonitor.left:0; OffsetRect(rc,-dx,0); Docking_AdjustPosition(msg->hwnd,(LPRECT)&rcMonitor,(LPRECT)msg->lParam); SendMessage(msg->hwnd,WM_SIZE,0,0); dock_prevent_moving=0; OnMoving(msg->hwnd,(LPRECT)msg->lParam); dock_prevent_moving=1; mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,0); DBWriteContactSettingByte(NULL,"CList","Docked",(BYTE)docked); ReposButtons(msg->hwnd,0,NULL); return TRUE; } return 0; } case WM_EXITSIZEMOVE: { RECT rcMonitor; RECT rcWindow; if (TempDock) TempDock=0; GetWindowRect(msg->hwnd,&rcWindow); Docking_GetMonitorRectFromWindow(msg->hwnd,&rcMonitor); Docking_AdjustPosition(msg->hwnd,&rcMonitor,&rcWindow); *((LRESULT*)lParam)=TRUE; dock_prevent_moving=0; SetWindowPos(msg->hwnd,0,rcWindow.left,rcWindow.top,0,0,SWP_NOSIZE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOSENDCHANGING); OnMoving(msg->hwnd,&rcWindow); ReposButtons(msg->hwnd,0,NULL);//-=-=-= dock_prevent_moving=1; return 1; } case WM_MOVE: { if(docked && 0) { RECT rc, rcMonitor; Docking_GetMonitorRectFromWindow(msg->hwnd,&rcMonitor); GetWindowRect(msg->hwnd,&rc); Docking_AdjustPosition(msg->hwnd,&rcMonitor,&rc); MoveWindow(msg->hwnd,rc.left,rc.top,rc.right-rc.left,rc.bottom-rc.top,TRUE); OnMoving(msg->hwnd,&rc); ReposButtons(msg->hwnd,0,NULL);//-=-=-= return 1; } ReposButtons(msg->hwnd,2,NULL); return 0; } case WM_SIZING: { /*RECT rcMonitor; Docking_GetMonitorRectFromWindow(msg->hwnd,&rcMonitor); Docking_AdjustPosition(msg->hwnd,&rcMonitor,(LPRECT)msg->lParam); *((LRESULT*)lParam)=TRUE; */ RECT rc; int dx=0, dy=0; int d=0; if (docked) ReposButtons(msg->hwnd,0,NULL); return FALSE; rc=*(RECT*)(msg->lParam); dock_prevent_moving=0; OnMoving(msg->hwnd,&rc); //-=-=-= return TRUE; } case WM_SHOWWINDOW: if(msg->lParam) return 0; if((msg->wParam && docked<0) || (!msg->wParam && docked>0)) docked=-docked; ZeroMemory(&abd,sizeof(abd)); abd.cbSize=sizeof(abd); abd.hWnd=msg->hwnd; if(msg->wParam) { RECT rc, rcMonitor; Docking_GetMonitorRectFromWindow(msg->hwnd,&rcMonitor); abd.lParam=0; abd.uCallbackMessage=WM_DOCKCALLBACK; SHAppBarMessage(ABM_NEW,&abd); GetWindowRect(msg->hwnd,&rc); Docking_AdjustPosition(msg->hwnd,&rcMonitor,&rc); MoveWindow(msg->hwnd,rc.left,rc.top,rc.right-rc.left,rc.bottom-rc.top,FALSE); OnMoving(msg->hwnd,&rc); ReposButtons(msg->hwnd,0,NULL);//-=-=-= } else { SHAppBarMessage(ABM_REMOVE,&abd); } return 0; case WM_NCHITTEST: { LONG result; result=DefWindowProc(msg->hwnd,WM_NCHITTEST,msg->wParam,msg->lParam); if(result==HTSIZE || result==HTTOP || result==HTTOPLEFT || result==HTTOPRIGHT || result==HTBOTTOM || result==HTBOTTOMRIGHT || result==HTBOTTOMLEFT) {*((LRESULT*)lParam)=HTCLIENT; return TRUE;} if(docked==DOCKED_LEFT && result==HTLEFT) {*((LRESULT*)lParam)=HTCLIENT; return TRUE;} if(docked==DOCKED_RIGHT && result==HTRIGHT) {*((LRESULT*)lParam)=HTCLIENT; return TRUE;} return 0; } case WM_SYSCOMMAND: if((msg->wParam&0xFFF0)!=SC_MOVE) return 0; SetActiveWindow(msg->hwnd); SetCapture(msg->hwnd); draggingTitle=1; *((LRESULT*)lParam)=0; return TRUE; case WM_MOUSEMOVE: if(!draggingTitle) return 0; { RECT rc; POINT pt; GetClientRect(msg->hwnd,&rc); if(((docked==DOCKED_LEFT || docked==-DOCKED_LEFT) && (short)LOWORD(msg->lParam)>rc.right) || ((docked==DOCKED_RIGHT || docked==-DOCKED_RIGHT) && (short)LOWORD(msg->lParam)<0)) { ReleaseCapture(); draggingTitle=0; ZeroMemory(&abd,sizeof(abd)); abd.cbSize=sizeof(abd); abd.hWnd=msg->hwnd; SHAppBarMessage(ABM_REMOVE,&abd); docked=0; GetCursorPos(&pt); PostMessage(msg->hwnd,WM_NCLBUTTONDOWN,HTCAPTION,MAKELPARAM(pt.x,pt.y)); SetWindowPos(msg->hwnd,0,pt.x-rc.right/2,pt.y-GetSystemMetrics(SM_CYFRAME)-GetSystemMetrics(SM_CYSMCAPTION)/2,DBGetContactSettingDword(NULL,"CList","Width",0),DBGetContactSettingDword(NULL,"CList","Height",0),SWP_NOZORDER); DBWriteContactSettingByte(NULL,"CList","Docked",(BYTE)docked); // ReposButtons(msg->hwnd,0); } return 1; } case WM_LBUTTONUP: if(draggingTitle) { ReleaseCapture(); draggingTitle=0; } return 0; case WM_DOCKCALLBACK: switch(msg->wParam) { case ABN_WINDOWARRANGE: ShowWindowNew(msg->hwnd,msg->lParam?SW_HIDE:SW_SHOW); { RECT rc, rcMonitor; Docking_GetMonitorRectFromWindow(msg->hwnd,&rcMonitor); GetWindowRect(msg->hwnd,&rc); Docking_AdjustPosition(msg->hwnd,&rcMonitor,&rc); OnMoving(msg->hwnd,&rc); //-=-=-= ReposButtons(msg->hwnd,0,NULL); dock_prevent_moving=1; } break; } return TRUE; case WM_DESTROY: if(docked>0) { ZeroMemory(&abd,sizeof(abd)); abd.cbSize=sizeof(abd); abd.hWnd=msg->hwnd; SHAppBarMessage(ABM_REMOVE,&abd); ReposButtons(msg->hwnd,0,NULL); } return 0; } return 0; }