This question already has answers here:
Non client painting on aero glass window
(3 answers)
Closed 8 years ago.
how to draw custom border, Actually i'am trying to draw 1 pixels border but failed, how can we achieve this?
i had tried this.but failed.i tried like this it works fine when window does't have child window .. in my case on top of my window there are 3 child window on this case i'am getting flickering.
case WM_NCACTIVATE :
{
if(TRUE == wParam)
{
stateofWindow = true;
InvalidateRect(hwnd,NULL,true);
}
else if(FALSE == wParam )
{
stateofWindow = false;
InvalidateRect(hwnd,NULL,true);
}
}
break;
case WM_NCCALCSIZE :
{
if (true == wParam )
{
return 0;
}
}
break;
case WM_PAINT:
{
HDC hcd = NULL;
PAINTSTRUCT ps;
hcd = BeginPaint(hwnd,&ps);
HPEN hPen = CreatePen(PS_SOLID, 1, RGB(165,165,165));;
SelectObject(hcd, hPen);
RECT rcClientRect = {0};
GetClientRect(hwnd,&rcClientRect);
//GetWindowRect(hwnd,&rcClientRect);
if(FALSE == stateofWindow)
{
MoveToEx(hcd,rcClientRect.left,rcClientRect.top,NULL);
LineTo(hcd,rcClientRect.right-1,rcClientRect.top );
LineTo(hcd,rcClientRect.right-1,rcClientRect.bottom-1 );
LineTo(hcd,rcClientRect.left,rcClientRect.bottom-1 );
LineTo(hcd,rcClientRect.left,rcClientRect.top);
}
else
{
HPEN hPen1 = CreatePen(PS_SOLID, 1, RGB(255,0,0));;
SelectObject(hcd, hPen1);
MoveToEx(hcd,rcClientRect.left,rcClientRect.top,NULL);
LineTo(hcd,rcClientRect.right-1,rcClientRect.top );
LineTo(hcd,rcClientRect.right-1,rcClientRect.bottom-1 );
LineTo(hcd,rcClientRect.left,rcClientRect.bottom-1 );
LineTo(hcd,rcClientRect.left,rcClientRect.top);
}
EndPaint(hwnd,&ps);
}
break;
It's a bit complicated. It requires correctly handling WM_NCCALCSIZE, WM_NCPAINT and WM_NCHITTEST at least.
Also note that I haven't tried ever since Aero came by, and I know Aero changed a lot of things: Under Aero, instead of just resizing the actual border, you use a border-less window and then call Dwm* functions to add border-like appearance and behavior (there was an article on MSDN about that).
Related
I want to detect whether a program is full screen in the expand monitor. I have got the expand monitor position using EnumDisplayMonitors. So if I get the program's position, I can compare it with expand monitor's position and get the result.
So I get the HWND of the program, and then I use ::GetWindowRect(HWND, &rect); But the rect is not correct.
HWND g_HWND = NULL;
BOOL CALLBACK EnumWindowsProcMy(HWND hwnd, LPARAM lParam)
{
DWORD lpdwProcessId;
GetWindowThreadProcessId(hwnd, &lpdwProcessId);
if (lpdwProcessId == lParam)
{
g_HWND = hwnd;
return FALSE;
}
return TRUE;
}
DWORD GetProcessidFromName(CString strName)
{
PROCESSENTRY32 pe;
DWORD id = 0;
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
pe.dwSize = sizeof(PROCESSENTRY32);
if (!Process32First(hSnapshot, &pe))
{
return 0;
}
pe.dwSize = sizeof(PROCESSENTRY32);
while (Process32Next(hSnapshot, &pe) != FALSE)
{
CString strTmp = pe.szExeFile;
if (strName.CompareNoCase(strTmp) == 0)
{
id = pe.th32ProcessID;
break;
}
}
CloseHandle(hSnapshot);
return id;
}
CRect rect[2] = { (0,0,0,0),(0,0,0,0) }; //rect[1] stores the expand monitor's position
BOOL CALLBACK Monitorenumproc(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData)
{
static BOOL first = FALSE;
MONITORINFO monitorinfo;
monitorinfo.cbSize = sizeof(MONITORINFO);
GetMonitorInfo(hMonitor, &monitorinfo);
if (monitorinfo.dwFlags == MONITORINFOF_PRIMARY)
{
if (!first)
{
first = TRUE;
rect[0] = monitorinfo.rcMonitor;
return TRUE;
}
else
{
first = FALSE;
return FALSE;
}
}
else
{
rect[1] = monitorinfo.rcMonitor;
}
return TRUE;
}
...
//get the position of xxx.exe
EnumDisplayMonitors(NULL, NULL, Monitorenumproc, 0);
EnumWindows(EnumWindowsProcMy, GetProcessidFromName(_T("xxx.exe")));
RECT rect1;
::GetWindowRect(g_HWND, &rect1); //rect1 is not correct!
I'm not sure what exactly you mean by
But the rect is not correct.
but here is what I see may seem incorrect:
Negative values, which indicate the window position relative to the primary display. You have to do the [right-left, bottom-top] calculation to get the size.
Values larger than the display size which means the rect includes the area occupied by the drop shadow.
See the documentation of GetWindowRect
In Windows Vista and later, the Window Rect now includes the area
occupied by the drop shadow.
Calling GetWindowRect will have different behavior depending on
whether the window has ever been shown or not. If the window has not
been shown before, GetWindowRect will not include the area of the drop
shadow.
To get the window bounds excluding the drop shadow, use
DwmGetWindowAttribute, specifying DWMWA_EXTENDED_FRAME_BOUNDS. Note
that unlike the Window Rect, the DWM Extended Frame Bounds are not
adjusted for DPI. Getting the extended frame bounds can only be done
after the window has been shown at least once.
So use the snippet below to get the size without the drop shadow:
RECT dwmExtFrameBounds;
DwmGetWindowAttribute(g_HWND, DWMWINDOWATTRIBUTE::DWMWA_EXTENDED_FRAME_BOUNDS, &dwmExtFrameBounds, sizeof(RECT));
Bonus read: Why does a maximized window have the wrong window rectangle?
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.
I found on (at least) Win10 that calling ::GetClipboardData() on a CF_DIBV5 created via Alt-PrtScrn (may be a synthesized format) causes the image to be modified (and basically corrupted).
For example, on the handler for ON_WM_CLIPBOARDUPDATE() the simple loop below will cause the corruption (note that you need to use debug mode so the ::GetClipboardData() is not optimized out).
To test, first don't run your app that processes the clipboard, use Alt-PrntScrn to capture data, then paste it to Paint. Now run the app that process the clipboard (with below sample below). Repeat Alt-PrntScrn process and you'll see it's different where the right side of the captured window ends up on the left and not centered in the area.
void CMainFrame::OnClipboardUpdate()
if (::OpenClipboard(AfxGetMainWnd()->m_hWnd)) {
UINT uformat=0;
while ((uformat=::EnumClipboardFormats(uformat))!=0) {
if (uformat==CF_DIBV5) {
// get the data - run in debug mode so not optimized out
HGLOBAL hglobal=::GetClipboardData(uformat);
}
}
// clean up
::CloseClipboard();
}
}
To enable the handler you need to call AddClipboardFormatListener(GetSafeHwnd()); in something like int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) then RemoveClipboardFormatListener(GetSafeHwnd()); on void CMainFrame::OnDestroy()
So is this a bug in Win10 (and other Windows Versions) or should I be doing something else that the sample isn't doing? (I know other formats exist, but the CF_DBIV5 is what I wanted).
I'm on Version 1903 (OS Build 18362.838)
Note the sample pic has right side items on left and some garbage pixels in lower left. I alt-prtscrn while app running, pasted in paint.
My resolution is 2560x1600.
Here's a link to a project that will cause the problem:
Sample Project
You can find the following description in the documentation :
The red, green, and blue bitfield masks for BI_BITFIELD bitmaps
immediately follow the BITMAPINFOHEADER, BITMAPV4HEADER, and
BITMAPV5HEADER structures. The BITMAPV4HEADER and BITMAPV5HEADER
structures contain additional members for red, green, and blue masks
as follows.
When the biCompression member of BITMAPINFOHEADER is set to BI_BITFIELDS and the function receives an argument of type LPBITMAPINFO, the color masks will immediately follow the header. The color table, if present, will follow the color masks. BITMAPCOREHEADER bitmaps do not support color masks.
When you handle CF_DIBV5 correctly you will draw the image successfully. The following is an example of Win32 C++ you can refer to:
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static UINT uFormat = (UINT) -1;
HDC hdcMem = NULL;
RECT rc = {0};
BYTE * pData = NULL;
BITMAPV5HEADER *pDibv5Info = NULL;
switch (message)
{
case WM_CLIPBOARDUPDATE:
{
if (IsClipboardFormatAvailable(CF_DIBV5))
{
uFormat = CF_DIBV5;
::CloseClipboard();
GetClientRect(hWnd, &rc);
InvalidateRect(hWnd, &rc, TRUE);
}
}
break;
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hWnd, &ps);
switch (uFormat)
{
case CF_DIBV5:
hdcMem = CreateCompatibleDC(hdc);
if (hdcMem != NULL)
{
if (::OpenClipboard(hWnd)) {
HANDLE hglobal = ::GetClipboardData(uFormat);
pData = (BYTE*)GlobalLock(hglobal);
if (pData)
{
pDibv5Info = (BITMAPV5HEADER *)pData;
int offset = pDibv5Info->bV5Size + pDibv5Info->bV5ClrUsed * sizeof(RGBQUAD);
if (pDibv5Info->bV5Compression == BI_BITFIELDS)
offset += 3 * sizeof(DWORD); //three DWORD color masks that specify the red, green, and blue components
pData += offset;
SetDIBitsToDevice(hdc, 20, 20, pDibv5Info->bV5Width, pDibv5Info->bV5Height, 0, 0, 0, pDibv5Info->bV5Height, pData, (BITMAPINFO *)pDibv5Info, 0);
}
GlobalUnlock(hglobal);
::CloseClipboard();
}
}
break;
}
EndPaint(hWnd, &ps);
}
break;
}
The correct image drawn in my application window:
I can reproduce the same issue without code:
if (pDibv5Info->bV5Compression == BI_BITFIELDS)
offset += 3 * sizeof(DWORD);
The corrupted image:
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.
I am working on a open source project in VC++ and want to change the backcolor of a static control..
hwndRenderMessage = CreateWindow(TEXT("STATIC"), Str("MainWindow.BeginMessage"),
WS_CHILDWINDOW|WS_VISIBLE|WS_CLIPSIBLINGS|SS_CENTER,
0, 0, 0, 0, hwndRenderFrame, NULL, hinstMain, NULL);
SendMessage(hwndRenderMessage, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
and the parent control of this control is
hwndRenderFrame = CreateWindow(OBS_RENDERFRAME_CLASS, NULL,
WS_CHILDWINDOW | WS_VISIBLE | WS_CLIPCHILDREN,
0, 0, 0, 0,
hwndMain, NULL, hinstMain, NULL);
if(!hwndRenderFrame)
CrashError(TEXT("Could not create render frame"));
So how to change the Background color of Static Control..
I google it and getting tha same answer use
case WM_CTLCOLORSTATIC:
{
HDC hdcStatic = (HDC) wParam;
SetTextColor(hdcStatic, RGB(0,0,0));
SetBkColor(hdcStatic, RGB(230,230,230));
return (INT_PTR)CreateSolidBrush(RGB(230,230,230));
}
But there is no switch case in the file so what to do??
Acctually i worked on c# but this is the first time on vc++
I downloaded the OBS source code from sourceforge.
The Window Proc is OBS::RenderFrameProc located in WindowStuff.cpp
At the bottom of the proc (but before the "return"), add:
else if(message == WM_CTLCOLORSTATIC ) {
// HERE YOUR CODE
}
EDIT: Changing Button Background
First, an advice: "don't do that". Buttons are very important and common components of the windows GUI, and their look and feel should be consistent in all applications. Users have ways to customize things for their Desktop, as a whole, and this include "accessibility" issues and behavior. Applications that want do it in their "own special way"s only bring problems.
Second, try this code for changing the "Setting..." button background to an ugly green: Add a case in the WM_NOTIFY message processing in OBS::OBSProc, in the switch(wParam)
case ID_SETTINGS:
if(nmh.code == NM_CUSTOMDRAW)
{
LPNMCUSTOMDRAW lpcd = (LPNMCUSTOMDRAW)lParam;
if (lpcd->dwDrawStage == CDDS_PREPAINT )
{
SetDCBrushColor(lpcd->hdc, RGB(0, 255, 0));
SelectObject(lpcd->hdc, GetStockObject(DC_BRUSH));
LONG lBorders = 0;
LONG lElipse = 5;
RoundRect(lpcd->hdc, lpcd->rc.left + lBorders, lpcd- rc.top + lBorders,
lpcd->rc.right - lBorders, lpcd->rc.bottom - lBorders, lElipse, lElipse);
return CDRF_NOTIFYPOSTPAINT;
}
}
break;
An alternative, with more standard borders:
SetDCBrushColor(lpcd->hdc, RGB(0, 255, 0));
SetDCPenColor(lpcd->hdc, RGB(0, 255, 0));
SelectObject(lpcd->hdc, GetStockObject(DC_BRUSH));
SelectObject(lpcd->hdc, GetStockObject(DC_PEN));
LONG lBorders = 3;
To be complete, you may want to check the uItemState member of lpcd, for the CDIS_HOT flag, changing the color accordingly.
You need to put that code in a window procedure. The window procedure looks like this:
LRESULT CALLBACK RenderMessageWndProc(HWND hWnd, UINT message, WPARAM wParam,
LPARAM lParam)
{
switch (message)
{
case WM_CTLCOLORSTATIC:
// your code goes here
return ....
}
return DefWindowProc(hWnd, message, wParam, lParam);
}
And you need to sub-class your window so that it uses this WndProc. Like this:
SetWindowLongPtr(hwndRenderMessage, GWLP_WNDPROC, (LONG_PTR)RenderMessageWndProc);
If you don't know what a window procedure is, or what sub-classing is, then you really need to step back and learn some basics. For instance, Petzold's classic book Programming Windows is still an excellent starting point.