Discussion :

[AlchiGits]

Bonjour à tous!

Je travaille actuellement sur un petit projet utilisant l'api Win32 avec le c++ et je me trouve confronté à un problème;
Je dois afficher un rectangle translucide sur le bureau et pouvoir lancer des applications avec le clique de souris
même si ce rectangle se trouve par dessus. Jusque là tout vas bien, j'ai réussi à dessiner directement sur le bureau
avec GDI+ donc le clique de la souris fonctionne normalement. Cependant je souhaiterais que mon rectangle puisse
bouger, donc pour cela il faudrait que je force le bureau windows à se redessiner.

J'ai déjà essayé de nombreuse fonctions de l'api, par exemple InvalideRect() suivie de UpdateWindows() ou RedrawWindow mais rien ne marche...
Je vous met le code que j'ai fait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <windows.h>
#include <objidl.h>
#include <gdiplus.h>
using namespace Gdiplus;
#pragma comment (lib,"Gdiplus.lib")
 
 
void drawRect(HWND hinstance_window, int x)
{
	/*****bout de code qui doit redessiner l'affichage d'une fenêtre****
        *************mais ne fonctionne pas pour le bureau..*******************/
	InvalidateRect(hinstance_window, NULL, TRUE);
	UpdateWindow(hinstance_window);
	/***************************************/
 
	SolidBrush brush(Color(100, 10, 30, 215));
	Graphics graphics(GetDC(hinstance_window));
	graphics.FillRectangle(&brush, x, 0, 200, 200);
 
	Sleep(100);
}
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, PSTR, INT iCmdShow)
{
	GdiplusStartupInput gdiplusStartupInput;
	ULONG_PTR           gdiplusToken;
	PAINTSTRUCT  ps;
 
	HWND hwnd_win = GetDesktopWindow();
	//HDC hdc = GetDC(hwnd_win);
	GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 
	drawRect(hwnd_win, 20);
        //Le premier rectangle dessiné devrait s'effacer quand on rappel la fonction
	drawRect(hwnd_win, 200);
 
	//GdiplusShutdown(gdiplusToken); //plante si on dé-commente
	return 0;
}

Lorsque que j'utilise ma fonction drawRect pour une fenêtre que j'ai créé et non pas pour le bureau la fenêtre s'efface bien avant
de redessiner dedans. Une solution serait de créer une fenêtre transparente en plain écran et de dessiner dessus mais le clique de
la souris ne traverserait plus l'écran et quand je met ma fenêtre transparente c'est tous se que je dessine dessus qui devient aussi
transparent donc dessiner sur le bureau reste une meilleure solution pour l'instant.

Voilà donc si vous avez une idée de comment redessinez ce bureau je suis preneur!

[bacelar]

par exemple InvalideRect() suivie de UpdateWindows() ou RedrawWindow mais rien ne marche

Vous n'avez pas du tout compris comment ces API fonctionnent.

Win32 ou en .NET, c'est les mêmes tambouilles :
http://stackoverflow.com/questions/2...n-desktop-in-c

[Médinoc]

Mon conseil: Fais-toi une fenêtre translucide quand même, et fais-lui répondre au message WM_NCHITTEXT avec la valeur HTTRANSPARENT quand la souris est dans la partie transparente de ta fenêtre (le contenu, très probablement -- ce qui signifie que tu peux juste appeler DefWindowProc() puis remplacer HTCLIENT par HTTRANSPARENT).

[AlchiGits]

Effectivement je ne maîtrise pas du tout cette API, j'ai aussi oublié de vous préciser j'aurais à dessiner plusieurs rectangles translucides sur le bureau.

Si j'ai bien compris je dois:
-Créer une fenêtre transparente (ici elle sera en plein écran vu que je veux pouvoir dessiner sur l'ensemble du bureau)
-Dessiner dans cette fenêtre mes rectangles
-Pouvoir clear cette fenêtre pour redessiner dessus quand les positions de mes rectangles changent

Du coup pour clear la fenêtre c'est la fonction de callback de la fenêtre? Et si elle est en plein écran mon clique de souris ne la traversera pas...

[Médinoc]

Traiter le message WM_NCHITTEST dans la callback de ta fenêtre te permettra de faire traverser le clic.

[Médinoc]

J'ai fait un petit test de fenêtre transparente sous Visual Studio 2005. La souris traverse (la fenêtre peut être déplacée par son cadre).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
/* "Fenêtre transparente"
https://www.developpez.net/forums/d1645255/c-cpp/cpp/api-win32-redessiner-bureau-windows/#post8994319
 
Résultat du test: WS_EX_TRANSPARENT ne suffit pas car il ne s'applique qu'aux fenêtres du même thread.
*/
#define _WIN32_WINNT 0x501 /*Windows XP ou supérieur (pour ICC_STANDARD_CLASSES)*/
#include <windows.h>
#pragma warning(push)
#pragma warning(disable: 4201) /*Supprime un warning inutile sous Visual 2005*/
#include <commctrl.h>
#pragma warning(pop)
/*#pragma comment(lib, "comctl32.lib")*/
 
/*#define HMENU_FROM_CONTROLID(x) ((HMENU)(INT_PTR)(x))*/
 
/*Pour avoir un affichage moderne, il faut compiler en UNICODE et utiliser Common Controls v6 ou supérieur*/
#ifdef UNICODE
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
#endif
 
/*This style is from the Vista SDK, Visual Studio 2008.*/
#ifndef WS_EX_LAYERED
#define WS_EX_LAYERED 0x00080000
BOOL WINAPI SetLayeredWindowAttributes(
  _In_ HWND     hwnd,
  _In_ COLORREF crKey,
  _In_ BYTE     bAlpha,
  _In_ DWORD    dwFlags
);
#define LWA_COLORKEY 0x00000001
#endif
 
/*Procédure de fenêtre*/
LRESULT CALLBACK transparent_WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	LRESULT ret = 0;
	switch(uMsg)
	{
	case WM_CREATE:
		{
			SetLayeredWindowAttributes(hWnd, RGB(0,255,0), 255, LWA_COLORKEY);
		}
		break;
 
	/*Finir la boucle de messages quand cette fenêtre est détruite*/
	/*Note: Pour bien faire, je devrais aussi re-changer la police des contrôles et la détruire.
	  Mais j'ai la flemme et le processus est sur le point de se terminer de toute façon.*/
	case WM_DESTROY: PostQuitMessage(0); break;
 
	case WM_NCHITTEST:
		ret = DefWindowProc(hWnd, uMsg, wParam, lParam);
		if(ret == HTCLIENT)
			ret = HTTRANSPARENT;
		break;
 
	case WM_ERASEBKGND:
		{
		RECT r;
		HBRUSH hbr = CreateSolidBrush(RGB(0,255,0));
		GetClientRect(hWnd, &r);
		FillRect((HDC)wParam, &r, hbr);
		DeleteObject(hbr);
		ret = TRUE;
		}
		break;
 
	default:
		ret = DefWindowProc(hWnd, uMsg, wParam, lParam);
		break;
	}
	return ret;
}
 
int APIENTRY transparent_WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
	HWND hWnd = NULL;
	WNDCLASSEX wcx={0};
	/*INITCOMMONCONTROLSEX icex = { sizeof icex, ICC_STANDARD_CLASSES };*/
 
	(void)hPrevInstance;
	(void)lpCmdLine;
	(void)nShowCmd;
 
	/*Initialisation des Common Controls et des Visual Styles*/
	/*InitCommonControlsEx(&icex);*/
 
	/*Définir la classe de fenêtre*/
	wcx.cbSize = sizeof wcx;
	wcx.hbrBackground = NULL;
	wcx.hInstance = hInstance;
	wcx.lpfnWndProc = transparent_WindowProc;
	wcx.lpszClassName = TEXT("Transparent Window");
	wcx.hCursor = LoadCursor(NULL, IDC_ARROW);
	wcx.style = CS_HREDRAW|CS_VREDRAW; /*Ils semblent être nécessaires en fait, sinon les contrôles se redessinent mal (j'ai l'impression qu'ils se redessinent trop tôt)...*/
	if(RegisterClassEx(&wcx) == 0)
		return EXIT_FAILURE;
 
	hWnd = CreateWindowEx(WS_EX_LAYERED, wcx.lpszClassName, TEXT("Fenêtre Transparente"), WS_OVERLAPPEDWINDOW|WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL);
	if(hWnd != NULL)
	{
		/*Boucle de messages*/
		MSG msg = {0};
		while(GetMessage(&msg, NULL, 0, 0)>0) /*Attente bloquante, dispatche tous les messages 'envoyés' et récupère le premier message 'posté' de la file du thread courant*/
		{
			TranslateMessage(&msg); /*Génère les WM_CHAR à partir des WM_KEYDOWN (les insère en tête de file)*/
			DispatchMessage(&msg); /*Dispatche message récupéré vers la bonne procédure de fenêtre*/
		}
	}
 
	return 0;
}