POPUP Window on WM_MOUSEHOVER in WIN32 API - how to close it? - winapi

I am relatively novice in WIN32 API and have problems with the code shown below, which is from my WinProc function: I use TrackMouseEvent with TME_HOVER to get a WM_MOUSEHOVER when the mouse cursor stays for a while in my window. This works if I call TrackMouseEvent on each WM_MOUSEMOVE, but not if I call in only once somewhere else. Why? (this is the 1st question)
When I receive WM_MOUSEHOVER I create a POPUP window, which I can see, and call again TrackMouseEvent for TME_LEAVE. This works and I receive WM_MOUSELEAVE when the mouse cursor leaves my window, then I want to hide and destroy the popup window (the HWND of which I stored in a static variable) but this does not work, the popup windows stays there. Why? (this is the 2nd question)
Can anybody give me an example or link to a simple example showing TrackMouseEvent and PopUp windows? Many Thanks.
case WM_MOUSEMOVE:
{
TRACKMOUSEEVENT tme;
tme.cbSize = sizeof(TRACKMOUSEEVENT);
tme.dwFlags = TME_HOVER;
tme.hwndTrack = hSBox;
TrackMouseEvent(&tme);
}
break;
case WM_MOUSEHOVER:
{
hPop = CreateWindowEx(WS_EX_STATICEDGE, //WS_EX_CLIENTEDGE,
TEXT("STATIC"),
TEXT("pop-up"),
WS_POPUP | WS_BORDER,
100, 100, 100, 100,
hWnd, (HMENU)0, hInstance, NULL);
ShowWindow(hPop, SW_SHOW);
TRACKMOUSEEVENT tme;
tme.cbSize = sizeof(TRACKMOUSEEVENT);
tme.dwFlags = TME_LEAVE;
tme.hwndTrack = hSBox;
TrackMouseEvent(&tme);
}
return 0;
case WM_MOUSELEAVE:
{
ShowWindow(hPop, SW_HIDE);
DestroyWindow(hPop);
}
return 0;

By the way, I also found that what I want to do can also be done with windows TOOLTIPS_CLASS.
The most recommendable link I found for this are:
http://winapi.foosyerdoos.org.uk/info/common_cntrls.php#CreateTooltip
https://github.com/wine-mirror/wine/blob/master/dlls/comctl32/tooltips.c
Unicode tooltips not showing up

There are two problems that I can see:
Your problem with TME_HOVER is because you're not initialising the dwHoverTime member; you should set it to HOVER_DEFAULT. Otherwise the hover timeout will be set to whatever random value is on the stack.
Your second problem is that each call to TrackMouseEvent overrides the previous one. Because you're calling TrackMouseEvent on every WM_MOUSEMOVE message, the TME_LEAVE call is quickly being overridden by your next TME_HOVER call.
The solution to this is to use some sort of flag in your WM_MOUSEMOVE handler, so that you only call TrackMouseEvent once, when the mouse first enters your window. Tracking is cancelled when you get the WM_MOUSEHOVER and WM_MOUSELEAVE messages, so at those points you'd reset the flag so that next time you get WM_MOUSEMOVE you can start it again if necessary.
// note: BOOL g_fMouseTracking needs to be declared in the same place
// hPop is
case WM_MOUSEMOVE:
if (!g_fMouseTracking && !hPop)
{
// start tracking if we aren't already
TRACKMOUSEEVENT tme;
tme.cbSize = sizeof(TRACKMOUSEEVENT);
tme.dwFlags = TME_HOVER | TME_LEAVE;
tme.hwndTrack = hSBox;
tme.dwHoverTime = HOVER_DEFAULT;
g_fMouseTracking = TrackMouseEvent(&tme);
}
break;
case WM_MOUSEHOVER:
g_fMouseTracking = FALSE; // tracking now cancelled
if (!hPop)
{
hPop = CreateWindowEx(WS_EX_STATICEDGE, //WS_EX_CLIENTEDGE,
TEXT("STATIC"),
TEXT("pop-up"),
WS_POPUP | WS_BORDER,
100, 100, 100, 100,
hWnd, (HMENU)0, hInstance, NULL);
ShowWindow(hPop, SW_SHOW);
// set up leave tracking
TRACKMOUSEEVENT tme;
tme.cbSize = sizeof(TRACKMOUSEEVENT);
tme.dwFlags = TME_LEAVE;
tme.hwndTrack = hSBox;
g_fMouseTracking = TrackMouseEvent(&tme);
}
return 0;
case WM_MOUSELEAVE:
g_fMouseTracking = FALSE; // tracking now cancelled
if (hPop)
{
// close popup if it's open
ShowWindow(hPop, SW_HIDE);
DestroyWindow(hPop);
hPop = NULL;
}
return 0;

Related

WM_PAINT: Manage hovering on an item of a tab control

So I'm overriding the WM_PAINT message of a tab control to add a close button, and to make a consistent look with the other controls of my application, I need to highlight the currently hovered item. The problem is the repainting does not work as expected, and I don't know how to manage the hovering state. The hovered item doesn't know when the mouse cursor has left it.
Here is a piece of code:
switch (msg) {
case WM_PAINT:
{
auto style = GetWindowLongPtr(m_self, GWL_STYLE);
// Let the system process the WM_PAINT message if the Owner Draw Fixed style is set.
if (style & TCS_OWNERDRAWFIXED) {
break;
}
PAINTSTRUCT ps{};
HDC hdc = BeginPaint(m_self, &ps);
RECT rc{};
GetClientRect(m_self, &rc);
// Paint the background
HBRUSH bkgnd_brush = GetSysColorBrush(COLOR_BTNFACE);
FillRect(hdc, &rc, bkgnd_brush);
DeleteObject(bkgnd_brush);
// Get infos about the control
int tabsCount = TabCtrl_GetItemCount(m_self);
int tabsSelect = TabCtrl_GetCurSel(m_self);
int ctl_identifier = GetDlgCtrlID(m_self);
// Draw each items
for (int i = 0; i < tabsCount; ++i) {
DRAWITEMSTRUCT dis{ ODT_TAB, ctl_identifier, static_cast<UINT>(i),
ODA_DRAWENTIRE, 0, m_self, hdc, RECT{}, 0 };
TabCtrl_GetItemRect(m_self, i, &dis.rcItem);
const UINT buffSize = 128;
wchar_t buff[buffSize];
TCITEM ti{};
ti.mask = TCIF_TEXT;
ti.pszText = buff;
ti.cchTextMax = buffSize;
this->Notify<int, LPTCITEM>(TCM_GETITEM, i, &ti); // Template class == SendMessageW
// Get item state
bool isHover = false;
HBRUSH hBrush = NULL;
POINT pt{};
GetCursorPos(&pt);
ScreenToClient(m_self, &pt);
// Item's bounds
if ((pt.x >= dis.rcItem.left && pt.x <= dis.rcItem.right) && (pt.y >= dis.rcItem.top && pt.y <= dis.rcItem.bottom)) {
m_hoveredTab = dis.rcItem;
isHover = true;
}
// Paint item according to its current state
hBrush = CreateSolidBrush(
(i == tabsSelect) ?
RGB(255, 131, 10) : isHover ?
RGB(255, 10, 73) : RGB(102, 10, 255));
FillRect(hdc, &dis.rcItem, hBrush);
DeleteObject(hBrush);
// Draw Text
SetBkMode(hdc, TRANSPARENT);
SetTextColor(hdc, RGB(0, 0, 0));
DrawTextW(hdc, buff, lstrlen(buff), &dis.rcItem, DT_SINGLELINE | DT_LEFT | DT_VCENTER);
}
EndPaint(m_self, &ps);
return 0;
}
// MOUSE EVENTS
case WM_MOUSEMOVE:
{
if (m_mouseTracking == FALSE) {
TRACKMOUSEEVENT trackMouseStruct{};
trackMouseStruct.cbSize = sizeof(trackMouseStruct);
trackMouseStruct.dwFlags = TME_HOVER | TME_LEAVE;
trackMouseStruct.hwndTrack = m_self;
trackMouseStruct.dwHoverTime = 1; // Shorter hover time to instantly hover a tab item
m_mouseTracking = TrackMouseEvent(&trackMouseStruct);
}
break;
}
case WM_MOUSEHOVER:
{
m_lostFocus = false;
break;
}
case WM_MOUSELEAVE:
{
m_mouseTracking = FALSE;
m_lostFocus = true;
break;
}
. . .
TrackMouseEvent detects hovering and leaving a window. The tab control is a single window that shows multiple tabs. If the cursor is hovering on one tab and is then moved to another tab (or to dead space in the tab control window), the TrackMouseEvent technique will not notify you.
Also, TrackMouseEvent could be interfering with the mouse tracking the tab control tries to do itself. Unfortunately, subclassing controls to modify their behavior usually requires knowing details of their implementation. For example, if you hadn't replaced the handling of WM_MOUSEMOVE, the tab control would probably do its own mouse tracking there in order to decide when to show its tooltip.
I think your best bet is to let the control process its messages as designed and to use the owner-draw mechanism to customize its appearance.
I finally managed to get something closer to the original control (even if there's a little bit of flicker, but it's pretty evident because the code below is just a "test" to understand how the tab control works.)
LRESULT TabsWindow::HandleMessage(UINT msg, WPARAM wParam, LPARAM lParam) {
switch (msg) {
// Track the mouse cursor to check if it has hit a tab.
case WM_MOUSEMOVE:
{
if (_enableMouseTracking == FALSE) {
TRACKMOUSEEVENT trackMouseStruct{};
trackMouseStruct.cbSize = sizeof(trackMouseStruct);
trackMouseStruct.dwFlags = TME_LEAVE;
trackMouseStruct.hwndTrack = m_self;
_enableMouseTracking = TrackMouseEvent(&trackMouseStruct);
}
_prevHoverTabIndex = _hoverTabIndex;
POINT coordinates{ GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
_hoverTabIndex = this->GetTabIndexFrom(coordinates);
if (_hoverTabIndex != _prevHoverTabIndex) {
// We need to loop over tabs as we don't know which tab has the
// highest height, and of course, the width of each tab can vary
// depending on many factors such as the text width (Assuming the
// TCS_FIXEDWIDTH style was not set, but it'll work too...)
int count = this->Notify(TCM_GETITEMCOUNT, 0, 0);
RECT rc{ 0, 0, 0, 0 };
for (int i = 0; i != count; ++i) {
RECT currItm{};
this->Notify(TCM_GETITEMRECT, i, &currItm);
UnionRect(&rc, &currItm, &rc);
_tabBarRc = rc;
}
InvalidateRect(m_self, &rc, FALSE);
UpdateWindow(m_self);
}
}
return 0;
case WM_MOUSELEAVE: // The tab bar must be redrawn
{
_hoverTabIndex = -1;
InvalidateRect(m_self, &_tabBarRc, FALSE);
UpdateWindow(m_self);
_enableMouseTracking = FALSE;
}
return 0;
case WM_ERASEBKGND:
{
return TRUE;
}
case WM_PAINT:
{
auto style = GetWindowLongPtr(m_self, GWL_STYLE);
if ((style & TCS_OWNERDRAWFIXED)) {
break;
}
PAINTSTRUCT ps{};
HDC hdc = BeginPaint(m_self, &ps);
// Total Size
RECT rc{};
GetClientRect(m_self, &rc);
// Paint the background
HBRUSH bkgnd = GetSysColorBrush(COLOR_BTNFACE);
FillRect(hdc, &rc, bkgnd);
// Get some infos about tabs
int tabsCount = TabCtrl_GetItemCount(m_self);
int tabsSelect = TabCtrl_GetCurSel(m_self);
int ctl_identifier = GetDlgCtrlID(m_self);
for (int i = 0; i < tabsCount; ++i) {
DRAWITEMSTRUCT dis{ ODT_TAB, ctl_identifier, static_cast<UINT>(i), ODA_DRAWENTIRE, 0, m_self, hdc, RECT{}, 0 };
TabCtrl_GetItemRect(m_self, i, &dis.rcItem);
RECT intersect{}; // Draw the relevant items that needs to be redrawn
if (IntersectRect(&intersect, &ps.rcPaint, &dis.rcItem)) {
HBRUSH hBrush = CreateSolidBrush
(
(i == tabsSelect) ? RGB(255, 0, 255) : (i == _hoverTabIndex) ? RGB(0, 0, 255) : RGB(0, 255, 255)
);
FillRect(hdc, &dis.rcItem, hBrush);
DeleteObject(hBrush);
}
}
EndPaint(m_self, &ps);
return 0;
}
return DefSubclassProc(m_self, msg, lParam, wParam);
}
// Helpers to get the current hovered tab
int TabsWindow::GetTabIndexFrom(POINT& pt)
{
TCHITTESTINFO hit_test_info{};
hit_test_info.pt = pt;
return static_cast<int>(this->Notify(TCM_HITTEST, 0, &hit_test_info));
}
bool TabsWindow::GetItemRectFrom(int index, RECT& out)
{
if (index < -1) {
return false;
}
return this->Notify(TCM_GETITEMRECT, index, &out);
}
Explanations
The Tab Control, fortunately, provides ways to get the hovered item. First, TCM_HITTEST allows us to get the current index based on the passed RECT. TCM_GETITEMRECT does the opposite.
We need to track the mouse cursor to detect whether it is on a tab or not. The tab control does not seem to use WM_MOUSEHOVER at all, but it effectively uses WM_MOUSELEAVE as we can see on Spy++ with a standard tab control.
Firstly, I tried to "disable" the WM_MOUSEMOVE message, and the tab control was not responsible. However, when WM_MOUSELEAVE is disabled, it works as expected but does not update the window if the mouse cursor leaves the tab control (so, the focus effect sticks on the previously hovered tab, which is no longer).
Finally, everything depends on the WM_MOUSEMOVE event, and the WM_MOUSELEAVE message is not so big because it only handles the "focus exit state" of the tab control but is necessary to exit the hovered state of a tab.
Again, the above code is just a skeleton filled with problems, but it works and reproduces the same behavior as the stock control.

Stop program continuing WM_KEYDOWN process

I'm not sure if it's the correct wording for my question but the issue revolves around it. I have 2 boxes that both validate on KillFocus. And another method which is called if the user presses the Next button, which calls a method that evaluates if they can continue, which validates these fields.
Due to how old this code base is, modifying this will cause issues elsewhere so I need to find a way around this without changing the way the can continue sequence is called. Here's some scenarios.
The user enters an invalid value in field 1, they press enter, the program fires the kill focus method and shows the error message, the enter key has pressed the next button which in turn validates the it again and shows the error again (different MsgBox same error). Meaning unless they unfocus manually then press enter they will always get two message boxes.
I believe this is due to the above reason as they have pressed enter which killed the focus instead of just calling can next.
Is there a way to stop the entire WM_KEYDOWN trail if it fails within the KillFocus method?
I'm sorry if this is a little bit vague and hazey, this is what I believe is happening.
#DavidHeffernan do you know of any other way to validate fields in the way that WM_KILLFOCUS does?
Allow me to make a suggestion. You can validate edit control's input in EN_CHANGE handler. From the docs:
Sent when the user has taken an action that may have altered text in an edit control.
Each time user types something, you will get this notification, which seems like a good place to validate data.
If data is invalid, you would then disable Next button using EnableWindow and indicate error somehow.
You could use EM_SHOWBALLOONTIP to pop tooltip with error message or simply change the background color of the edit control to red.
Below is the small example that illustrates my point. You should add better error checking of course, but the main idea is there:
#include <windows.h>
#include <CommCtrl.h>
#define IDC_BTN_NEXT 1000
#define IDC_BOX1 2000
#define IDC_BOX2 3000
// enable Visual Styles
#pragma comment( linker, "/manifestdependency:\"type='win32' \
name='Microsoft.Windows.Common-Controls' version='6.0.0.0' \
processorArchitecture='*' publicKeyToken='6595b64144ccf1df' \
language='*'\"")
// link with Common Controls library
#pragma comment( lib, "comctl32.lib")
void onBtnNext()
{
MessageBeep(0);
}
void onKillFocus(HWND box)
{
//==================== these are needed to disable Next button
HWND hwnd = ::GetParent(box);
if (NULL == hwnd) // critical error
return; // TODO: add error handling
HWND btnNext = ::GetDlgItem(hwnd, IDC_BTN_NEXT);
if (NULL == btnNext) // critical error
return; // TODO: add error handling
//==============================================================
int len = ::GetWindowTextLength(box);
if (0 == len) // it is ok, empty text, just return
return;
// if possible, use std::wstring here, I assumed you can't...
wchar_t *txt = new wchar_t[len +1];
if (0 == ::GetWindowText(box, txt, len + 1)) // critical error, according to documentation
{
// TODO: add error handling
delete[] txt;
return;
}
//====== simple validation for illustration only, treat uppercase letter as error
int isTextValid = ::isupper(txt[0]);
for (int i = 1; 0 == isTextValid && i < (len + 1); isTextValid = ::isupper(txt[++i]));
delete[] txt;
//==============================================
if (isTextValid)
{
EDITBALLOONTIP ebt;
ebt.cbStruct = sizeof(EDITBALLOONTIP);
ebt.pszText = L" Tooltip text";
ebt.pszTitle = L" Tooltip title";
ebt.ttiIcon = TTI_ERROR_LARGE;
if (!::SendMessage(box, EM_SHOWBALLOONTIP, 0, (LPARAM)&ebt))
{
//TODO: tooltip won't show, handle error
}
EnableWindow(btnNext, FALSE); // disable Next button
return; // our work is successfully done
}
if (!::SendMessage(box, EM_HIDEBALLOONTIP, 0, 0))
{
//TODO: tooltip won't hide, handle error
}
EnableWindow(btnNext, TRUE); // enable Next button
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_CREATE:
{
HWND hwndBox1 = CreateWindowEx(0, WC_EDIT, L"",
WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL,
20, 20, 250, 20, hwnd, (HMENU)IDC_BOX1,
((LPCREATESTRUCT)lParam)->hInstance, 0);
if (NULL == hwndBox1) // add better error handling, this is for illustration only
return -1;
HWND hwndBox2 = CreateWindowEx(0, WC_EDIT, L"",
WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL,
20, 50, 250, 20, hwnd, (HMENU)IDC_BOX2,
((LPCREATESTRUCT)lParam)->hInstance, 0);
if (NULL == hwndBox2) // add better error handling, this is for illustration only
return -1;
HWND hwndBtnNext = CreateWindowEx(0, WC_BUTTON, L"Next",
WS_CHILD | WS_VISIBLE | BS_CENTER | BS_DEFPUSHBUTTON,
20, 80, 50, 25, hwnd, (HMENU)IDC_BTN_NEXT,
((LPCREATESTRUCT)lParam)->hInstance, 0);
if (NULL == hwndBtnNext) // add better error handling, this is for illustration only
return -1;
}
return 0L;
case WM_COMMAND:
{
switch (HIWORD(wParam))
{
case BN_CLICKED:
{
if (LOWORD(wParam) != IDC_BTN_NEXT)
break;
onBtnNext();
}
break;
case EN_CHANGE:
{
if (LOWORD(wParam) != IDC_BOX1 && (LOWORD(wParam) != IDC_BOX2))
break;
onKillFocus((HWND)lParam);
}
break;
default:
break;
}
}
break;
case WM_CLOSE:
::DestroyWindow(hwnd);
return 0L;
case WM_DESTROY:
{
::PostQuitMessage(0);
}
return 0L;
default:
return ::DefWindowProc(hwnd, msg, wParam, lParam);
}
return 0;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine,
int nCmdShow)
{
WNDCLASSEX wc;
HWND hwnd;
MSG Msg;
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = 0;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(hInstance, IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW);
wc.lpszMenuName = NULL;
wc.lpszClassName = L"Main_Window";
wc.hIconSm = LoadIcon(hInstance, IDI_APPLICATION);
if (!RegisterClassEx(&wc))
return 0;
INITCOMMONCONTROLSEX iccex;
iccex.dwSize = sizeof(INITCOMMONCONTROLSEX);
iccex.dwICC = ICC_STANDARD_CLASSES;
InitCommonControlsEx(&iccex);
hwnd = CreateWindowEx(0, L"Main_Window", L"Test",
WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION,
50, 50, 305, 160, NULL, NULL, hInstance, 0);
ShowWindow(hwnd, nCmdShow);
UpdateWindow(hwnd);
while (GetMessage(&Msg, NULL, 0, 0) > 0)
{
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
return Msg.wParam;
}
The issue was solved in a "unconventional" way, but it worked. I noticed through debugging that the program lost focus twice on the box, once when ENTER was pressed and once when the message box popped up.
I used a static bool to avoid my program doing the error checking twice. It looks something like this -
void onKillFocus()
{
static bool isValidated = false;
if(!isValidated)
{
isValidated = true;
if(/*ValidationCheck*/)
{
//messagebox for error
}
}
}
By using this, the validation is only ran once when focus is killed stopping the message box from appearing twice, as the static bool is only alive for as long as the method is ran, meaning it's reset every time killfocus is called.

Windows, restoring window bug

I'm playing around with Windows and D2D1
However when restoring my minimized borderless/menuless window
sometimes I get this very ugly bug
For a frame (or a few more) before the window gets drawn with D2D1
it will display this title bar with the name of the window.
This happens on about 5-10% of the restore operations.
The window class style is set to
CS_DBLCLKS|CS_OWNDC
but Ive also tried other styles.
The Window is created with CreateWindow and WS_POPUP|WS_SYSMENU as dwStyle
My rendering method is called on WM_PAINT but I also tried to move it so it
gets called every time but that does not help.
Any help is appreciated :)
#
I've found a workaround which I'm not completely fine with
Instead of calling ShowWindow(hWnd, SW_RESTORE)
I call
ShowWindow(hWnd, SW_HIDE);
ShowWindow(hWnd, SW_RESTORE);
ShowWindow(hWnd, SW_SHOW);
This however results in the taskbar icon being "renewed" which I dont want either.
Short simplified example code which features this problem (when minimizing/restoring)
#include <Windows.h>
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE prevInstance, LPSTR cmd, int cmdShow)
{
WNDCLASSEX TestWC = { 0 };
TestWC.cbSize = sizeof(WNDCLASSEX);
TestWC.hbrBackground = (HBRUSH)CreateSolidBrush(RGB(50, 50, 50));
TestWC.lpfnWndProc = DefWindowProc;
TestWC.lpszClassName = "Testklasse";
TestWC.style = CS_DBLCLKS | CS_OWNDC;
TestWC.hCursor = LoadCursor(NULL, IDC_ARROW);
RegisterClassEx(&TestWC);
HWND htest = CreateWindow("Testklasse", "Test", WS_POPUP | WS_SYSMENU | WS_VISIBLE, 200, 200, 400, 248, 0, 0, 0, 0);
MSG wMsg = { 0 };
bool shown = true;
while (wMsg.message != WM_QUIT)
{
if (PeekMessage(&wMsg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&wMsg);
DispatchMessage(&wMsg);
}
if (GetAsyncKeyState(VK_INSERT) & 0x8000 && shown)
{
shown = false;
ShowWindow(htest, SW_MINIMIZE);
continue;
}
if (GetAsyncKeyState(VK_DELETE) & 0x8000 && !shown)
{
shown = true;
ShowWindow(htest, SW_RESTORE);
continue;
}
if (GetAsyncKeyState(VK_END) & 0x8000)
PostQuitMessage(1);
Sleep(50);
}
return 1;
}
Found the solution myself:
Minimizing and restoring a borderless window
is undefined behaviour.
A workaround is to catch the WM_NCPAINT and draw the WHOLE
window yourself (even if its borderless it has a non-client area).

Redraw window using DirectX during move/resize

I've followed this tutorial and got it all working: http://www.braynzarsoft.net/index.php?p=InitDX11
The result is a window with a constantly changing background color. The trouble is that the color stops changing while the window is being dragged around. I've tried adding the following case statements (in various combinations) to the WndProc callback, but to no avail:
case WM_ENTERSIZEMOVE:
SetTimer(hwnd, 1, USER_TIMER_MINIMUM, NULL);
return 0;
case WM_EXITSIZEMOVE:
KillTimer(hwnd, 1);
return 0;
case WM_TIMER:
RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT);
return 0;
case WM_PAINT:
UpdateScene();
DrawScene();
return 0;
The above causes an exception at d3d11DevCon->ClearRenderTargetView(renderTargetView, bgColor), but I've also tried merging the WM_PAINT case into the WM_TIMER case, and all I got was flickering between the natural window background color and the current color of the DX scene (the color of the DX portion of the flicker never evolved, it stayed constant no matter for how long I dragged the window).
Any tips?
A better option is to just not draw while in a resize. There's not usually a lot of value in having the backbuffer resized over and over again. Just wait until the resize is complete to resize the buffer.
static bool s_in_sizemove = false;
static bool s_in_suspend = false;
static bool s_minimized = false;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps);
break;
case WM_SIZE:
if (wParam == SIZE_MINIMIZED)
{
if (!s_minimized)
{
s_minimized = true;
if (!s_in_suspend)
OnSuspending();
s_in_suspend = true;
}
}
else if (s_minimized)
{
s_minimized = false;
if (s_in_suspend)
OnResuming();
s_in_suspend = false;
}
else if ( !s_in_sizemove )
OnWindowSizeChanged();
break;
case WM_ENTERSIZEMOVE:
s_in_sizemove = true;
break;
case WM_EXITSIZEMOVE:
s_in_sizemove = false;
OnWindowSizeChanged();
break;
case WM_GETMINMAXINFO:
{
auto info = reinterpret_cast<MINMAXINFO*>(lParam);
info->ptMinTrackSize.x = 320;
info->ptMinTrackSize.y = 200;
}
break;
You have to release all the backbuffer and depth-buffer references and recreate them in OnWindowSizedChange.
The actual rendering is done as part of the message pump for most 'real-time' graphics apps:
// Main message loop
MSG msg = { 0 };
while (WM_QUIT != msg.message)
{
if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
Tick();
}
}
Here Tick handles a timer update and the render.
See the Direct3D Win32 Game Visual Studio template for a complete example.
Update: If the 'blank window' bothers you during the resize, but you are fine with the default behavior of DXGI_SCALING_STRETCH during the resize, you can replace the WM_PAINT above with:
case WM_PAINT:
if (s_in_sizemove)
{
game->Tick();
}
else
{
hdc = BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps);
}
break;
I had same problem. I thought solution would be complicated. However, no. That is about mesage pool. DX should use same thread and indeed you use your rendering (Ex: myRender(){..} ) in that loop In my case Frame(); is the bool returnable I use for rendering that contains all operatios :
MSG msg;
bool done, result;
// Initialize the message structure.
ZeroMemory(&msg, sizeof(MSG));
// Loop until there is a quit message from the window or the user.
done = false;
while (!done)
{
// Handle the windows messages.
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
// If windows signals to end the application then exit out.
if (msg.message == WM_QUIT)
{
done = true;
}
else
{
// Otherwise do the frame processing.
result = Frame();
if (!result)
{
done = true;
}
}
}
When you resize you can handle some messages WM_SIZE or WM_MOVE message. In your LRESULT CALLBACK handle:
LRESULT CALLBACK WndProc(HWND hwnd, UINT umessage, WPARAM wparam, LPARAM lparam) {
//...OTHERS...
if (umessage == WM_MOVE) {
/*Dont be confused ApplicationHandle is pointer of my SystemClass
which set ApplicationHandle = this in SystemClass.
to create a window/s and Graphics (contains all DirectX related operations).
Here GraphicsClass (contains all DX calls) initialized in
SystemClass as new class and SystemClass initialized as
new class at main.cpp in WINAPI. That makes a lot easier
for handling this kind of issues for me
In your case you will call your rendering loop instead Frame();*/
if (ApplicationHandle -> m_Graphics) {
RECT r;
GetClientRect(ApplicationHandle -> m_hwnd, & r);
ApplicationHandle -> m_Graphics -> clientSize = {
r.right - r.left,
r.bottom - r.top
};
//frame processing.
ApplicationHandle -> m_Graphics -> Frame();
}
if (umessage == WM_SIZING) {
if ((wparam == WMSZ_BOTTOM || wparam == WMSZ_RIGHT || wparam == WMSZ_BOTTOMRIGHT) && ApplicationHandle -> m_Graphics) {
/*IF WE DO NOT HANDLE wparam resize will be very laggy.*/
GetClientRect(ApplicationHandle -> m_hwndOWNER, & clientRect);
ApplicationHandle -> m_Graphics -> clientSize = {
clientRect.right - clientRect.left,
clientRect.bottom - clientRect.top
};
ApplicationHandle -> m_Graphics -> Frame();
}
}
}
//...OTHERS...
}
HERE IS A VIDEO OF RESULT: https://www.youtube.com/watch?v=vN_XPVRHuiw&feature=youtu.be
even if you are drawing custom window using Desktop Window Manager (WDM) you can handle WM_NCHITTEST for other click situations as that will only update if you resize and move but not if you click and hold caption or hold border only.
additionally, I did not get that why you handle WM_PAINT if you are using DirectX already.

How to enable buttons when scroll bar hits bottom with Win32?

I'm writing a license agreement dialog box with Win32 and I'm stumped. As usual with these things I want the "accept/don't accept" buttons to become enabled when the slider of the scroll bar of the richedit control hits bottom, but I can't find a way to get notified of that event. The earliest I've been able to learn about it is when the user releases the left mouse button.
Is there a way to do this?
Here's what I tried so far:
WM_VSCROLL and WM_LBUTTONUP in richedit's wndproc
EN_MSGFILTER notification in dlgproc (yes the filter mask is getting set)
WM_VSCROLL and WM_LBUTTONUP in dlgproc.
EN_VSCROLL notification in dlgproc
I got so desperate I tried polling but that didn't work either because apparently timer messages stop arriving while the mouse button is down on the slider. I tried both:
timer callback (to poll) in dlgproc
timer callback (to poll) in richedit's wndproc
You need to sub-class the edit box and intercept the messages to the edit box itself. Here's an artical on MSDN about subclassing controls.
EDIT: Some code to demonstrate the scroll bar enabling a button:
#include <windows.h>
#include <richedit.h>
LRESULT __stdcall RichEditSubclass
(
HWND window,
UINT message,
WPARAM w_param,
LPARAM l_param
)
{
HWND
parent = reinterpret_cast <HWND> (GetWindowLong (window, GWL_HWNDPARENT));
WNDPROC
proc = reinterpret_cast <WNDPROC> (GetWindowLong (parent, GWL_USERDATA));
switch (message)
{
case WM_VSCROLL:
{
SCROLLINFO
scroll_info =
{
sizeof scroll_info,
SIF_ALL
};
GetScrollInfo (window, SB_VERT, &scroll_info);
if (scroll_info.nPos + static_cast <int> (scroll_info.nPage) >= scroll_info.nMax ||
scroll_info.nTrackPos + static_cast <int> (scroll_info.nPage) >= scroll_info.nMax)
{
HWND
button = reinterpret_cast <HWND> (GetWindowLong (parent, 0));
EnableWindow (button, TRUE);
}
}
break;
}
return CallWindowProc (proc, window, message, w_param, l_param);
}
LRESULT __stdcall ApplicationWindowProc
(
HWND window,
UINT message,
WPARAM w_param,
LPARAM l_param
)
{
bool
use_default_proc = false;
LRESULT
result = 0;
switch (message)
{
case WM_CREATE:
{
CREATESTRUCT
*creation_data = reinterpret_cast <CREATESTRUCT *> (l_param);
RECT
client;
GetClientRect (window, &client);
HWND
child = CreateWindow (RICHEDIT_CLASS,
TEXT ("The\nQuick\nBrown\nFox\nJumped\nOver\nThe\nLazy\nDog\nThe\nQuick\nBrown\nFox\nJumped\nOver\nThe\nLazy\nDog"),
WS_CHILD | WS_VISIBLE | ES_MULTILINE | ES_AUTOVSCROLL | WS_VSCROLL | ES_DISABLENOSCROLL,
0, 0, client.right, client.bottom - 30,
window,
0,
creation_data->hInstance,
0);
SetWindowLong (window, GWL_USERDATA, GetWindowLong (child, GWL_WNDPROC));
SetWindowLong (child, GWL_WNDPROC, reinterpret_cast <LONG> (RichEditSubclass));
SetWindowLong (child, GWL_ID, 0);
child = CreateWindow (TEXT ("BUTTON"), TEXT ("Go Ahead!"), WS_CHILD | WS_VISIBLE | WS_DISABLED, 0, client.bottom - 30, client.right, 30, window, 0, creation_data->hInstance, 0);
SetWindowLong (window, 0, reinterpret_cast <LONG> (child));
SetWindowLong (child, GWL_ID, 1);
}
break;
case WM_COMMAND:
if (HIWORD (w_param) == BN_CLICKED && LOWORD (w_param) == 1)
{
DestroyWindow (window);
}
break;
default:
use_default_proc = true;
break;
}
return use_default_proc ? DefWindowProc (window, message, w_param, l_param) : result;
}
int __stdcall WinMain
(
HINSTANCE instance,
HINSTANCE unused,
LPSTR command_line,
int show
)
{
LoadLibrary (TEXT ("riched20.dll"));
WNDCLASS
window_class =
{
0,
ApplicationWindowProc,
0,
4,
instance,
0,
LoadCursor (0, IDC_ARROW),
reinterpret_cast <HBRUSH> (COLOR_BACKGROUND + 1),
0,
TEXT ("ApplicationWindowClass")
};
RegisterClass (&window_class);
HWND
window = CreateWindow (TEXT ("ApplicationWindowClass"),
TEXT ("Application"),
WS_VISIBLE | WS_OVERLAPPED | WS_SYSMENU,
CW_USEDEFAULT,
CW_USEDEFAULT,
400, 300, 0, 0,
instance,
0);
MSG
message;
int
success;
while (success = GetMessage (&message, window, 0, 0))
{
if (success == -1)
{
break;
}
else
{
TranslateMessage (&message);
DispatchMessage (&message);
}
}
return 0;
}
The above doesn't handle the user moving the cursor in the edit box.
I would recommend starting up Spy++ and seeing which windows messages are getting sent to where.
http://msdn.microsoft.com/en-us/library/aa264396(VS.60).aspx
Why not use the EM_GETTHUMB message. (Assuming Rich Edit 2.0 or later).
If you are lucky this bottom position will match EM_GETLINECOUNT.
Even though it is possible, I don't think you should do it that way - the user will have no clue why the buttons are disabled. This can be very confusing, and confusing the user should be avoided at all costs ;-)
That's why most license dialogs have radio buttons for accept/decline with decline enabled by default, so you actively have to enable accept.

Resources