I'm writing application in raw WinApi using C++. I'm writing my own controls from begining. I need to get information when mouse button is click outside specific HWND. Is there any build in mechanism in WinApi to do such things or maybe I need to write my own logic?
#define IDM_FILE_NEW 21
#define IDM_FILE_OPEN 44
#define IDM_FILE_QUIT 88
case WM_RBUTTONUP:
{
HNENU hMenu;
POINT point;
point.x = LOWORD(lParam);
point.y = HIWORD(lParam);
hMenu = CreatePopupMenu();
ClientToScreen(hwnd, &point);
AppendMenuW(hMenu, MF_STRING, IDM_FILE_NEW,
L"&New");
AppendMenuW(hMenu, MF_STRING, IDM_FILE_OPEN,
L"&Open");
AppendMenuW(hMenu, MF_SEPARATOR, 0, NULL);
AppendMenuW(hMenu, MF_STRING, IDM_FILE_QUIT,
L"&Quit");
TrackPopupMenu(hMenu, TPM_RIGHTBUTTON,
point.x, point.y, 0, hwnd, NULL);
DestroyMenu(hMenu);
}
break;
Related
I created a lsitbox this way:
HWND hLstBx = CreateWindowEx(WS_EX_CLIENTEDGE, "Listbox", NULL, WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL, 10, 10, 300, 500, hWnd, (HMENU)ID_LSTBX, (HINSTANCE)GetWindowLong(GWL_HINSTANCE, hWnd), NULL;
//SendMessage(hLstBx, LB_SETHORIZONTALEXTENT, (WPARAM)1000, 0);
Above It creates successfully a horizontal scroll bar but what I want:
How to set the value at runtime depending on the item with the longest length?
Please don't say something like in MFC but only win32.
Thank you in advance.
There is no free lunch here, if you want to call LB_SETHORIZONTALEXTENT or LB_SETCOLUMNWIDTH you have to measure the text of each item yourself to figure out the correct pixel size.
Each time an item is added/deleted or the controls font is changed you need to measure each item. Select the controls font (WM_GETFONT) into a HDC and use GetTextExtentPoint32 or DrawText(..., DT_CALCRECT) to measure the text. You probably also want to add some padding, (2 * GetSystemMetrics(SM_CXEDGE)) perhaps and account for the vertical scrollbar (if it is visible). You can optimize this by using LB_SETITEMDATA/LB_GETITEMDATA to cache the widths so you only have to calculate the size of a new item when it is added.
Once you know the widths of all items you can set the extent to the largest item.
UINT CalcLBItemWidth(HWND hLB, LPCTSTR Text)
{
RECT r;
HDC hLBDC = GetDC(hLB);
HDC hDC = CreateCompatibleDC(hLBDC);
HFONT hFont = (HFONT) SendMessage(hLB, WM_GETFONT, 0, 0);
HGDIOBJ hOrgFont = SelectObject(hDC, hFont);
ZeroMemory(&r, sizeof(r));
DrawText(hDC, Text, -1, &r, DT_CALCRECT|DT_SINGLELINE|DT_NOCLIP);
SelectObject(hDC, hOrgFont);
DeleteDC(hDC);
ReleaseDC(hLB, hLBDC);
return (r.right - r.left) + (2 * GetSystemMetrics(SM_CXEDGE));
}
static LRESULT CALLBACK MainWndProc(HWND hWnd, UINT Msg, WPARAM wp, LPARAM lp)
{
switch(Msg)
{
case WM_CREATE:
{
HWND hLB = CreateWindowEx(WS_EX_CLIENTEDGE, WC_LISTBOX, NULL, WS_CHILD|WS_VISIBLE|WS_HSCROLL|WS_VSCROLL|LBS_NOINTEGRALHEIGHT|LBS_DISABLENOSCROLL, 10, 10, 200, 100, hWnd, (HMENU)666, g_hInst, NULL);
static const LPCTSTR strings[] = { TEXT("Foo"), TEXT("Foo bar"), TEXT("Foo bar baaaaaaaaaaaaaaaz") };
UINT largest = 0;
for (UINT i = 0; i < 33; ++i)
{
UINT temp = CalcLBItemWidth(hLB, strings[i%3]);
if (temp > largest) largest = temp;
SendMessage(hLB, LB_ADDSTRING, 0, (LPARAM) strings[i%3]);
}
SendMessage(hLB, LB_SETHORIZONTALEXTENT, largest, 0);
}
break;
...
There is a MFC example of this here that subclasses the control and does all of it for you but there is nothing MFC specific that prevents you from doing the same in plain win32...
It seems like both size (x, y) and position (nWidth, nHeight) arguments are ignored when using CreateWindow. For example:
CreateWindow(L"MDICLIENT", L"", WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE,
150, 10, 400, 300, hWnd, NULL, hInst, (LPVOID)&ccs);
It's always aligned to the top-left corner and takes the parent's size, as shown below.
(We could see the difference since the window background is COLOR_WINDOW).
The coordinates for MDICLIENT have no effect on start up. Instead you have to handle client-size in WM_SIZE as follows:
LRESULT CALLBACK FrameWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HWND hwndClient;
switch (message)
{
case WM_CREATE:
{
hwndClient = CreateWindow(L"MDICLIENT", L"", WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE,
0, 0, 0, 0, hWnd, NULL, hInst, (LPVOID)&ccs);
...
return 0;
}
case WM_SIZE:
{
RECT rc;
GetClientRect(hwnd, &rc);
SetWindowPos(hwndToolbar, 0, 0, 0, rc.right, 30, SWP_SHOWWINDOW);
int x = 50; //right-edge of another toolbar...
int y = 30;
int w = rc.right - x;
int h = rc.bottom - y;
MoveWindow(hwndClient, x, y, w, h, 0);
return 0;
}
...
}
By the way, you won't really see any difference on the screen unless you add MDI child. The MDI child will limit its movements to the new area, it won't go over the toolbar.
I want to calculate the full size of a window before opening it. I'm using AdjustWindowRectEx() to achieve this. My code looks like this for a window with a client size of 640x480:
wrect.left = 0;
wrect.top = 0;
wrect.right = 640;
wrect.bottom = 480;
AdjustWindowRectEx(&wrect, WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX, FALSE, 0);
This returns the following values:
left: -3
top: -22
right: 643
bottom: 483
However, when opening the window using CreateWindowEx() and passing
wrect.right - wrect.left
wrect.bottom - wrect.top
as the window size, the window's size physical size actually turns out to be 656x515 pixels. Still, GetWindowRect() returns 646x505, i.e. the same dimensions as returned by AdjustWindowRectEx() but as I said, when I take a screenshot of the desktop and measure the window's size using a paint program, its physical size is actually 656x515 pixels. Does anybody have an explanation for this?
The client size is alright, it's 640x480 but it looks like the border size is calculated wrongly because the border uses more pixels than calculated by AdjustWindowRectEx() and GetWindowRect().
I'm on Windows 7.
EDIT:
Is this downvoted because the title of the question is misleading? As stated in the MSDN autodocs, WS_OVERLAPPED is not supported by AdjustWindowRectEx(). So is there any other way to calculate the dimensions of a WS_OVERLAPPED window? Using WS_OVERLAPPEDWINDOW instead is not a solution because it sets the WS_THICKFRAME and WS_MAXIMIZEBOX which I don't want.
Here is some test code now which shows the problem. You can see that the client size is alright but the window's physical size is larger than what is returned by GetWindowRect().
#include <stdio.h>
#include <windows.h>
#define CLASSNAME "Test"
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
WNDCLASSEX wcx;
RECT wrect;
HWND hWnd;
char tmpstr[256];
memset(&wcx, 0, sizeof(WNDCLASSEX));
wcx.cbSize = sizeof(WNDCLASSEX);
wcx.style = CS_HREDRAW|CS_VREDRAW;
wcx.lpfnWndProc = WindowProc;
wcx.hInstance = hInstance;
wcx.hCursor = LoadCursor(NULL, IDC_ARROW);
wcx.hbrBackground = GetStockObject(BLACK_BRUSH); // important! otherwise a borderless window resize will not be drawn correctly
wcx.lpszClassName = CLASSNAME;
RegisterClassEx(&wcx);
wrect.left = 0;
wrect.top = 0;
wrect.right = 640;
wrect.bottom = 480;
AdjustWindowRectEx(&wrect, WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX, FALSE, 0);
hWnd = CreateWindowEx(0, CLASSNAME, "Test", WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_OVERLAPPED, 0, 0, wrect.right - wrect.left, wrect.bottom - wrect.top, NULL, NULL, hInstance, NULL);
ShowWindow(hWnd, SW_SHOWNORMAL);
GetWindowRect(hWnd, &wrect);
sprintf(tmpstr, "%d %d %d %d\n", wrect.left, wrect.top, wrect.right, wrect.bottom);
AllocConsole();
WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), tmpstr, strlen(tmpstr), NULL, NULL);
GetClientRect(hWnd, &wrect);
sprintf(tmpstr, "%d %d %d %d\n", wrect.left, wrect.top, wrect.right, wrect.bottom);
WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), tmpstr, strlen(tmpstr), NULL, NULL);
Sleep(10000);
DestroyWindow(hWnd);
UnregisterClass(CLASSNAME, hInstance);
return 0;
}
GetWindowRect api doesn't give the correct size:
Due to compatability requirements, certain metrics are reported in such a way that they're not consistent with what is actually drawn on the screen when Aero Glass (more accurately, "Windows Vista Aero") is enabled. This sort of approach is needed in order to change the look of the system for the vast majority of apps for which this isn't an issue.However, there's been a recent change in the system which will be coming out in Vista RC1 that will return the correct rendered value from GetWindowRect() for executables that are linked with "winver = 6.0". This allows new and newly-linked applications to get the "correct" values from GetWindowRect().
GetWindowRect on non-resizable windows under Aero Glass
Use instead DwmGetWindowAttribute to get the correct size:
DwmGetWindowAttribute(hWnd, DWMWA_EXTENDED_FRAME_BOUNDS, &wrect, sizeof(wrect));
If AdjustWindowRect doesn't work, just try to create the Window and adjust the size after the window is created.
// Create the window with a nearly correct size
RECT rect;
rect.left = 0;
rect.top = 0;
rect.right = 640;
rect.bottom = 480;
AdjustWindowRectEx(&rect, WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX, FALSE, 0);
// try
hWnd = CreateWindowEx(0, CLASSNAME, "Test", WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_OVERLAPPED, 0, 0, rect.right - rect.left, rect.bottom - rect.top, NULL, NULL, hInstance, NULL);
// Get the size that is really required and adjust
RECT rectCreated;
GetWindowRect(hWnd, &rectCreated);
rect.right += rectCreated.right-rectcreated.left;
rect.bottom += rectCreated.bottom-rectcreated.top;
// Resize to let the window fir the inner client aea
SetWindowPos(hWnd,NULL,0,0,rect.right-rect.left,rect.bottom-rect.top,SWP_NOMOVE|SWP_NOZORDER);
// Show it.
ShowWindow(hWnd, SW_SHOWNORMAL);
Code is not tested. Hopefully I have no bugs or syntax errors in it.
My application is dll which is injected into 3rd party GUI application. There dll creates child window containing few controls on the main window of the application. The problem is that my window and its controls blink when the main window is redrawn. I've already read many articles about similar problems but could not fix it. Here is some code
hwndContainer = CreateWindowEx( WS_EX_TOPMOST, PANEL_CLASS_NAME, "", WS_CHILD | WS_VISIBLE, 0, 0, width, height, hwnd, 0, g_hInstance, cd );
CreateWindowEx( WS_EX_TOPMOST, "button", "Click me", WS_CHILD | WS_VISIBLE | WS_TABSTOP, x, y, w, h, hwndContainer, 0, 0, 0 );
...
case WM_PAINT:
PAINTSTRUCT ps;
HDC hdc = BeginPaint( hwndPanel, &ps );
RECT r;
GetClientRect( hwndPanel, &r );
SelectObject( hdc, hpenBorder );
SelectObject( hdc, GetStockObject( NULL_BRUSH ) );
RoundRect( hdc, 0, 0, r.right, r.bottom, 5, 5 );
EndPaint( hwndPanel, &ps );
return 0;
I tried adding WS_CLIPCHILDREN to the main window style, processed WM_PAINT of the main window etc. Any thoughts?
You may give WS_CLIPSIBLINGS a try... It's been a long time since I've done anything with window styles directly but I seem to remember this style required to help reduce redraw flicker in non-top level windows. Good luck.
Here is how the window was created. But when I GetClientRect, the rcClient is much bigger than 32x32.
int nDefaultWidth = 32;
int nDefaultHeight = 32;
UINT32 winStyle = 0;
RECT rc;
SetRect( &rc, 0, 0, nDefaultWidth, nDefaultHeight );
AdjustWindowRect( &rc, winStyle, ( hMenu != NULL ) ? true : false );
// Create the render window
HWND hWnd = CreateWindow( L"Direct3DWindowClass", NULL, winStyle,
x, y, ( rc.right - rc.left ), ( rc.bottom - rc.top ), 0,
hMenu, hInstance, 0 );
RECT rcClient;
GetClientRect( hWnd, &rcClient );
You are passing 0 as the dwStyle parameter to AdjustWindowRect. That value is equal to WS_OVERLAPPED, and AdjustWindowRect explicitly forbids you to pass that specific value.
Since you want to create a 32x32 window (i.e. with no chrome at all, pure client area) you should lose the AdjustWindowRect call as it serves no purpose at all and pass WS_POPUP as the window style to CreateWindow.