Przezroczyste okienka z WinAPI

pejotr — Sat, 10 Oct 2009 12:24:08 +0000

Wraz z pojawieniem się systemu Windows 2000, pojawiły się nowe funkcje systemowego API. Jedną z nich jest możliwość tworzenia okien o dowolnym stopniu przezroczystości. Efekt jest dość ciekawy i sporo programów ma możliwość ustawienia przezroczystości własnego okienka. Moim celem było umożliwienie sterowania przezroczystością okien centralnie z jednego programu i to nie zależnie od tego czy okno takie zostało do tego przystosowane czy też nie. Po przeczytaniu tego wpisu, każdy samodzielnie będzie mógł napisać podobną aplikację

Aby istniała możliwość ustawiania przezroczystości dla okna, musi być ono utworzone w sposób do tego przystosowany. Wystarczy skorzystać z innej funkcji tworzącej okno, nie CreateWindow, a CreateWindowEx

1
2
3
4
5
6
7
8
9
10
11
12
13
14

HWND CreateWindowEx(
DWORD dwExStyle,
LPCTSTR lpClassName,
LPCTSTR lpWindowName,
DWORD dwStyle,
int x,
int y,
int nWidth,
int nHeight,
HWND hWndParent,
HMENU hMenu,
HINSTANCE hInstance,
LPVOID lpParam
);

To co umożliwia później modyfikacje przezroczystości jest ukryte w ramach dodatkowego stylu okna, podawanego poprzez argument dwExStyle. Lista dopuszczalnych wartości jest długa, ale warto się z nią zapoznać. W tym konkretnym przypadku należy zainteresować się wartością WS_EX_LAYERED, utworzone wtedy okno będzie tzw. Layered Window, które obsługuje modyfikacje przezroczystości. Do ustawienia nowej wartości kanału alpha służy SetLayeredWindowAttributes(HWND hwnd, COLORREF crKey, BYTE bAlpha, DWROD dwFlags) – szczegóły w dokumentacji.
Pełny kod tworzący przykładowe, półprzezroczyste okno:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

#include

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
MSG msg;
HWND hwnd;
WNDCLASSEX wcx;

wcx.cbSize = sizeof(wcx);
wcx.style = CS_HREDRAW | CS_VREDRAW;
wcx.lpfnWndProc = WndProc;
wcx.cbClsExtra = 0;
wcx.cbWndExtra = 0;
wcx.hInstance = hInstance;
wcx.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wcx.hCursor = LoadCursor(NULL, IDC_ARROW);
wcx.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
wcx.lpszMenuName = (LPCSTR)"MainMenu";
wcx.lpszClassName = (LPCSTR)"MainWClass";
wcx.hIconSm = (HICON)LoadImage(hInstance, MAKEINTRESOURCE(5), IMAGE_ICON,
GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), (UINT)LR_DEFAULTCOLOR);

RegisterClassEx(&wcx);

hwnd = CreateWindowEx(WS_EX_LAYERED, (LPCSTR)"MainWClass", (LPCSTR)"Sample", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, (HWND)NULL, (HMENU)NULL, hInstance, (LPVOID) NULL);

ShowWindow(hwnd, nCmdShow);
SetLayeredWindowAttributes(hwnd, 0, 180, LWA_ALPHA);
UpdateWindow(hwnd);

while(GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}

return msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_CREATE:
return 0;

case WM_PAINT:
return 0;

case WM_DESTROY:
PostQuitMessage(0);
return 0;

default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}

To co należy zrobić, aby kontrolować przezroczystość okien innych niż własne przedstawia się następująco:

1. Pobrać wszystkie otwarte okna typu top-level
2. Nadać oknom styl dwExStyle
3. Zmienić wartość kanału alpha

1. Pobrać wszystkie otwarte okna typu top-level
Dobrym pomysłem wydaje się pobranie uchwytu do rodzica wszystkich okien(Desktop/Pulpit) i przejście w pętli po liście jego dzieci (jak wiadomo każde okno ma kilka przydatnych wskaźników, między innymi do okna-brata). Mogłoby to wyglądać tak:

1
2
3
4
5
6
7
8
9

HWND hDesktop = GetDesktopWindow();
HWND hChild = GetWindow(hDesktop, GW_CHILD);
HWND hTemp;
/* ... */
while(hTemp != GetWindow(hChild, GW_HWNDLAST))
{
/* ... */
hTemp = GetWindow(hChild, GW_HWNDNEXT);
}

Pomysł zły ! Okazuje się że taka pętla może działać w nieskończoność. Wzmianaka na temat takiego przypadku znajduje się nawet w dokumentacji. Dlatego należy wykorzystać inny sposób, polegający na użyciu funkcji BOOL EnumWindows(WNDENUMPROC lpEnumFunc, LPARAM lParam):

1
2
3
4
5
6
7
8
9
10
11
12
13

EnumWindows(EnumWindowsProc, NULL);
/* ... */
BOOL CALLBACK EnumWindowsProc(HWND hwndChild, LPARAM lParam)
{
char buffer[100];

int count = GetWindowText(hwndChild, buffer, 100);
if(count && IsWindowVisible(hwndChild))
{
/* ... */
}
return TRUE;
}

2. Nadać oknom styl dwExStyle
Wydaje się najtrudniejsze, przecież dodatkowy styl należy podać przy tworzeniu okna, a okna które widzimy zostały już przecież utworzone. Na szczęście z pomocą przychodzi funkcja LONG SetWindowLong(HWND hWnd, int iIndex, LONG dwNewLong):

1	SetWindowLong(hwndChild, GWL_EXSTYLE, WS_EX_LAYERED);

3. Zmienić wartość kanału alpha
Bardziej uważni czytelnicy już na pewno wiedzą jak wygląda zestaw parametrów i jak skorzystać z SetLayeredWindowAttributes. Wykorzystanie pokazane 3 listingi wyżej, przy okazji tworzenia „własnego” przezroczystego okna.

I to tyle tym temacie, wypada jeszcze stworzyć GUI, może obsługę tray’a. Program wydaje się „magiczny” a korzysta raptem z 4 funkcji API systemowego.

Tworzenie okienka w asm

pejotr — Wed, 02 Sep 2009 12:08:45 +0000

Wiadomo że stworzenie okienka przy wykorzystaniu języka C i WinAPI nie jest zadaniem trudnym. Nawet w dokumentacji od MS można znaleźć gotowy przykład. Jest to natomiast zadanie bardzo żmudne i z reguły z pełnym zrozumieniem pól i dopuszczalnych wartości dla wymaganych struktur robi się to tylko raz. Potem albo się kopiuje gotowy standardowy kod wprowadzając tylko pewne czasami zmiany odbiegającego od typowego zastosowania, albo przyjmuje że „się umie” i „zna fundament” i przesiada na WindowsForms. Ale można pójść w drugą stronę, stworzyć okienko w assmeblerze i tym samym uzyskać miano rycerza hardcoru.

Może dziwić ale zbudowanie okna korzystając z języka maszynowego nie jest trudno. Objętość programu jest zbliżona do tego utworzonego standardowo z wykorzystaniem C. Ponadto korzystając z kompilatora dostarczonego przez Microsoft (MASM) istnieje możliwość bardzo łatwego dostępu do funkcji API systemu Windows. Ponad to kompilator dostarcza wiele ułatwiających życie makr.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

.386
.model flat,stdcall
option casemap:none
include c:\masm32\include\windows.inc
include c:\masm32\include\user32.inc
includelib c:\masm32\lib\user32.lib
include c:\masm32\include\kernel32.inc
includelib c:\masm32\lib\kernel32.lib

WinMain proto :DWORD,:DWORD,:DWORD,:DWORD

.data ; zainicjalizowanie zmienne
ClassName db "SimpleWinClass",0
AppName db "Our first Window",0
.data? ; niezainicjalizowane zmienne
hInstance HINSTANCE ?
CommandLine LPSTR ?
.code
start:
invoke GetModuleHandle,NULL
mov hInstance,eax
invoke WinMain,hInstance,NULL,CommandLine,SW_SHOWDEFAULT
invoke ExitProcess,0

WinMain proc hInst:HINSTANCE,hPrevInst:HINSTANCE,CmdLine:LPSTR,CmdShow:DWORD
LOCAL wc:WNDCLASSEX
LOCAL msg:MSG
LOCAL hwnd:HWND

mov wc.cbSize,SIZEOF WNDCLASSEX
mov wc.style,CS_HREDRAW or CS_VREDRAW
mov wc.lpfnWndProc,OFFSET WndProc
mov wc.cbClsExtra,NULL
mov wc.cbWndExtra,NULL
push hInstance
pop wc.hInstance
mov wc.hbrBackground,COLOR_WINDOW+1
mov wc.lpszMenuName,NULL
mov wc.lpszClassName, OFFSET ClassName
invoke LoadIcon,NULL,IDI_APPLICATION
mov wc.hIcon,eax
mov wc.hIconSm,eax
invoke LoadCursor,NULL,IDC_ARROW
mov wc.hCursor,eax
invoke RegisterClassEx,addr wc
invoke CreateWindowEx,NULL,\
ADDR ClassName,\
ADDR AppName,\
WS_OVERLAPPEDWINDOW,\
CW_USEDEFAULT,\
CW_USEDEFAULT,\
CW_USEDEFAULT,\
CW_USEDEFAULT,\
NULL,\
NULL,\
hInst,\
NULL
mov hwnd,eax
invoke ShowWindow,hwnd,CmdShow
invoke UpdateWindow,hwnd

.WHILE TRUE
invoke GetMessage,ADDR msg,NULL,0,0
.BREAK .IF(!eax)
invoke TranslateMessage,ADDR msg
invoke DispatchMessage,ADDR msg
.ENDW

mov eax,msg.wParam
ret

WinMain endp

WndProc proc hWnd:HWND,uMsg:UINT,wParam:WPARAM,lParam:LPARAM

.IF uMsg==WM_DESTROY
invoke PostQuitMessage,NULL
.ELSE
invoke DefWindowProc,hWnd,uMsg,wParam,lParam
ret
.ENDIF
xor eax,eax
ret

WndProc endp

end start

Nie ma co wiele tłumaczyć. Kod jaki jest interpretowany przez MASM wygląda już niemalże jak język wysokiego poziomu(niektórzy mówią że C to język niskiego poziomu, ale to dlatego że nie umieli znaleźć określenia dla Javy, C# itp.) Bardzo fajnym makrem jest invoke uruchamiające zadaną procedurę i umożliwiające podanie listy argumentów poprzez rozdzielenie przecinkiem. Bardzo przyjemna alternatywa dla push’owania w odwrotnej kolejności.
Jedyny wniosek jaki można wysnuć to to że jeżeli ktoś umie programować z wykorzystaniem WinAPI w C, to i bez problemu zastosuje go w assemblerze. Oczywiście nie ma obowiązku korzystania z MASM, do API można się także dostać korzystać z innych assemblerów np. NASM ( polacam zapoznanie się z nasmx).

pamiętnik programisty » winapi

Przezroczyste okienka z WinAPI

Tworzenie okienka w asm