Partage

Api Windows/ fenêtres en premier plan...

Fenêtre toujours en premier plan, même devant la barre des tâches.

1 2 >>

Sujet résolu

22 octobre 2018 à 21:11:48

Bonjour à tous,

je programme depuis plusieurs mois en c++, et particulièrement avec l'API Windows. Je me suis penché sur la question du maintient au premier plan des fenêtres; après quelque recherches, j'ai réussi à créer un programme maintenant une fenêtre au premier plan:

#include <windows.h>

LRESULT WINAPI fenProc(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
	switch(Msg){
		case WM_CREATE:
			{
				ShowWindow(hwnd, SW_SHOW);
				SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
			}
			return 0;
        case WM_CLOSE:
		    {
		        DestroyWindow(hwnd);
		    }
		    return 0;
		case WM_DESTROY:
		    {
		        PostQuitMessage(0);
		    }
			return 0;
	}
	return DefWindowProc(hwnd, Msg, wParam, lParam);
}

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrev, LPSTR lpCmdLine, int nShowCmd)
{
	WNDCLASS wndClass = { 0, fenProc, 0, 0, hInstance, NULL, LoadCursor(NULL, IDC_ARROW), 0, NULL, "fenetre" };
	wndClass.hbrBackground = (HBRUSH) 7;
        if(!RegisterClass(&wndClass)) return False;
	HWND hwnd = CreateWindow("fenetre", NULL, WS_OVERLAPPEDWINDOW, 50, 500, 100, 100, HWND_DESKTOP, NULL, hInstance, NULL);
        if(!hwnd) return False;
	MSG Msg;
	while(GetMessage(&Msg, NULL, 0, 0))
        {
			TranslateMessage(&Msg);
			DispatchMessage(&Msg);
	}
	return 0;
}

Mais je me suis rendu compte que mon programme ne restait pas devant la barre des tâches, ni devant le menu qui s'ouvre quand on appuie sur la touche windows, ou encore devant les applications plein écran comme le scanneur:

Pourtant il est possible d'y arriver puisque le gestionnaire des tâches (en mode toujours visible) est capable de rester devant toute fenêtre, qu'elle soit en plein écran ou pas, que ce la soit barre des tâches... ou tout autre fenêtre:

je voulais donc savoir si quelqu'un connaissait une option encore plus forte que HWND_TOPMOST dans la commande

SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);

(ou carrément une autre fonction, car à priori il n'y a que les options HWND_BOTTOM, HWND_NOTOPMOST, HWND_TOP, et HWND_TOPMOST qui existent, et aucune ne convient) afin que ma fenêtre soit vraiment au premier plan (de la même manière que le gestionnaire des tâches).

Merci d'avance !

-
Edité par PaulLenoir1 22 octobre 2018 à 21:48:30

pseudo-simple

22 octobre 2018 à 21:24:11

Salut, pour comprendre à quoi sert ton en-tête windows.h :

est-ce ce programme , quand tu l'exécutes, interagit avec ta distribution de windows (i;e. ton OS installé sur ton PC ) ?

Car si c'est le cas, alors oui, c'est bon à savoir.

-
Edité par pseudo-simple 22 octobre 2018 à 21:25:01

PaulLenoir1

22 octobre 2018 à 21:52:02

Mon programme n'interragit pas spécifiquement avec l'OS (pas plus qu'une fenêtre toute simple) mais windows.h permet justement d'utiliser les fonctions de l'API windows.

(sans windows.h ça ne compile pas puisque le compilateur ne connait pas toutes ces fonctions comme setwindowpos, showWindow,...)

-
Edité par PaulLenoir1 22 octobre 2018 à 21:56:27

bacelar

23 octobre 2018 à 11:16:13

L'include "windows.h", c'est plutôt la solution de facilité pour avoir une très grosse partie de Win32 en un seul include.

Il est tout à possible de n'inclure qu'une partie de Win32, mais c'est beaucoup de travail pour pas grand-chose.

Exemple ShowWindow :

https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-showwindow

Dans la doc, c'est "winuser.h".

Mais bon, on va pas couper les cheveux en quatre.

Cette course à l'armement du "topmost", est-ce vraiment raisonnable ?

A ce petit jeu, vous trouverez toujours plus malin que vous, et vous comparer à des composants directement intégrés dans le système d'exploitation (la bar des tâche qui est affiché par le processus père de toute la session, ou le gestionnaire des tâches qui est un composant très intégrer au Kernel), vous jouer pas dans la même catégorie.

C'est quoi votre besoin réel et pas totalement disproportionné d'être "toujours" au-dessus ?

Juste un topmost devrait servir à tous les usages "raisonnables".

Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.

PaulLenoir1

23 octobre 2018 à 11:23:58

En fait je voulais juste savoir comment c'est possible que le gestionnaire des tâches puisse le faire, et pas un .exe que l'on crée soit même.

Surtout que ça peut être très pratique d'avoir une fenêtre qui reste devant les applications plein écran, ce que ne peut pas faire "topmost"; donc si quelqu'un sait comment faire pour rester devant les appli plein écran (et accessoirement devant labarre des tâches), ça m'intéresse; sinon tant pis pour moi !!!

Et sinon, je n'ai inclus que winuser.h, comme il est précisé dans le lien que vous m'avez donné (Header winuser.h (include Windows.h)), et voilà ce que j'ai obtenu comme erreurs:

c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:41:39: error: typedef 'WNDPROC' is initialized (use decltype instead)
   typedef LRESULT (CALLBACK *WNDPROC)(HWND,UINT,WPARAM,LPARAM);
                                       ^~~~
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:41:39: error: 'HWND' was not declared in this scope
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:41:48: error: expected primary-expression before ',' token
   typedef LRESULT (CALLBACK *WNDPROC)(HWND,UINT,WPARAM,LPARAM);
                                                ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:41:55: error: expected primary-expression before ',' token
   typedef LRESULT (CALLBACK *WNDPROC)(HWND,UINT,WPARAM,LPARAM);
                                                       ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:41:62: error: expected primary-expression before ')' token
   typedef LRESULT (CALLBACK *WNDPROC)(HWND,UINT,WPARAM,LPARAM);
                                                              ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:46:40: error: typedef 'DLGPROC' is initialized (use decltype instead)
   typedef INT_PTR (CALLBACK *DLGPROC) (HWND, UINT, WPARAM, LPARAM);
                                        ^~~~
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:46:40: error: 'HWND' was not declared in this scope
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:46:50: error: expected primary-expression before ',' token
   typedef INT_PTR (CALLBACK *DLGPROC) (HWND, UINT, WPARAM, LPARAM);
                                                  ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:46:58: error: expected primary-expression before ',' token
   typedef INT_PTR (CALLBACK *DLGPROC) (HWND, UINT, WPARAM, LPARAM);
                                                          ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:46:66: error: expected primary-expression before ')' token
   typedef INT_PTR (CALLBACK *DLGPROC) (HWND, UINT, WPARAM, LPARAM);
                                                                  ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:50:39: error: typedef 'TIMERPROC' is initialized (use decltype instead)
   typedef VOID (CALLBACK *TIMERPROC) (HWND, UINT, UINT_PTR, DWORD);
                                       ^~~~
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:50:39: error: 'HWND' was not declared in this scope
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:50:49: error: expected primary-expression before ',' token
   typedef VOID (CALLBACK *TIMERPROC) (HWND, UINT, UINT_PTR, DWORD);
                                                 ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:50:59: error: expected primary-expression before ',' token
   typedef VOID (CALLBACK *TIMERPROC) (HWND, UINT, UINT_PTR, DWORD);
                                                           ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:50:66: error: expected primary-expression before ')' token
   typedef VOID (CALLBACK *TIMERPROC) (HWND, UINT, UINT_PTR, DWORD);
                                                                  ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:51:47: error: typedef 'GRAYSTRINGPROC' is initialized (use decltype instead)
   typedef WINBOOL (CALLBACK *GRAYSTRINGPROC) (HDC, LPARAM, int);
                                               ^~~
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:51:47: error: 'HDC' was not declared in this scope
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:51:58: error: expected primary-expression before ',' token
   typedef WINBOOL (CALLBACK *GRAYSTRINGPROC) (HDC, LPARAM, int);
                                                          ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:51:60: error: expected primary-expression before 'int'
   typedef WINBOOL (CALLBACK *GRAYSTRINGPROC) (HDC, LPARAM, int);
                                                            ^~~
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:52:44: error: typedef 'WNDENUMPROC' is initialized (use decltype instead)
   typedef WINBOOL (CALLBACK *WNDENUMPROC) (HWND, LPARAM);
                                            ^~~~
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:52:44: error: 'HWND' was not declared in this scope
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:52:56: error: expected primary-expression before ')' token
   typedef WINBOOL (CALLBACK *WNDENUMPROC) (HWND, LPARAM);
                                                        ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:54:43: error: typedef 'SENDASYNCPROC' is initialized (use decltype instead)
   typedef VOID (CALLBACK *SENDASYNCPROC) (HWND, UINT, ULONG_PTR, LRESULT);
                                           ^~~~
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:54:43: error: 'HWND' was not declared in this scope
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:54:53: error: expected primary-expression before ',' token
   typedef VOID (CALLBACK *SENDASYNCPROC) (HWND, UINT, ULONG_PTR, LRESULT);
                                                     ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:54:64: error: expected primary-expression before ',' token
   typedef VOID (CALLBACK *SENDASYNCPROC) (HWND, UINT, ULONG_PTR, LRESULT);
                                                                ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:54:73: error: expected primary-expression before ')' token
   typedef VOID (CALLBACK *SENDASYNCPROC) (HWND, UINT, ULONG_PTR, LRESULT);
                                                                         ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:56:46: error: typedef 'PROPENUMPROCA' is initialized (use decltype instead)
   typedef WINBOOL (CALLBACK *PROPENUMPROCA) (HWND, LPCSTR, HANDLE);
                                              ^~~~
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:56:46: error: 'HWND' was not declared in this scope
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:56:58: error: expected primary-expression before ',' token
   typedef WINBOOL (CALLBACK *PROPENUMPROCA) (HWND, LPCSTR, HANDLE);
                                                          ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:56:66: error: expected primary-expression before ')' token
   typedef WINBOOL (CALLBACK *PROPENUMPROCA) (HWND, LPCSTR, HANDLE);
                                                                  ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:57:46: error: typedef 'PROPENUMPROCW' is initialized (use decltype instead)
   typedef WINBOOL (CALLBACK *PROPENUMPROCW) (HWND, LPCWSTR, HANDLE);
                                              ^~~~
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:57:46: error: 'HWND' was not declared in this scope
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:57:59: error: expected primary-expression before ',' token
   typedef WINBOOL (CALLBACK *PROPENUMPROCW) (HWND, LPCWSTR, HANDLE);
                                                           ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:57:67: error: expected primary-expression before ')' token
   typedef WINBOOL (CALLBACK *PROPENUMPROCW) (HWND, LPCWSTR, HANDLE);
                                                                   ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:59:48: error: typedef 'PROPENUMPROCEXA' is initialized (use decltype instead)
   typedef WINBOOL (CALLBACK *PROPENUMPROCEXA) (HWND, LPSTR, HANDLE, ULONG_PTR);
                                                ^~~~
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:59:48: error: 'HWND' was not declared in this scope
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:59:59: error: expected primary-expression before ',' token
   typedef WINBOOL (CALLBACK *PROPENUMPROCEXA) (HWND, LPSTR, HANDLE, ULONG_PTR);
                                                           ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:59:67: error: expected primary-expression before ',' token
   typedef WINBOOL (CALLBACK *PROPENUMPROCEXA) (HWND, LPSTR, HANDLE, ULONG_PTR);
                                                                   ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:59:78: error: expected primary-expression before ')' token
   typedef WINBOOL (CALLBACK *PROPENUMPROCEXA) (HWND, LPSTR, HANDLE, ULONG_PTR);
                                                                              ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:60:48: error: typedef 'PROPENUMPROCEXW' is initialized (use decltype instead)
   typedef WINBOOL (CALLBACK *PROPENUMPROCEXW) (HWND, LPWSTR, HANDLE, ULONG_PTR);
                                                ^~~~
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:60:48: error: 'HWND' was not declared in this scope
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:60:60: error: expected primary-expression before ',' token
   typedef WINBOOL (CALLBACK *PROPENUMPROCEXW) (HWND, LPWSTR, HANDLE, ULONG_PTR);
                                                            ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:60:68: error: expected primary-expression before ',' token
   typedef WINBOOL (CALLBACK *PROPENUMPROCEXW) (HWND, LPWSTR, HANDLE, ULONG_PTR);
                                                                    ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:60:79: error: expected primary-expression before ')' token
   typedef WINBOOL (CALLBACK *PROPENUMPROCEXW) (HWND, LPWSTR, HANDLE, ULONG_PTR);
                                                                               ^
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:65:46: error: typedef 'DRAWSTATEPROC' is initialized (use decltype instead)
   typedef WINBOOL (CALLBACK *DRAWSTATEPROC) (HDC hdc, LPARAM lData, WPARAM wData, int cx, int cy);
                                              ^~~
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:65:46: error: 'HDC' was not declared in this scope
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:65:62: error: expected primary-expression before 'lData'
   typedef WINBOOL (CALLBACK *DRAWSTATEPROC) (HDC hdc, LPARAM lData, WPARAM wData, int cx, int cy);
                                                              ^~~~~
c:\compilateurs\mingw64\x86_64-w64-mingw32\include\winuser.h:65:76: error: expected primary-expression before 'wData'
   typedef WINBOOL (CALLBACK *DRAWSTATEPROC) (HDC hdc, LPARAM lData, WPARAM wData, int cx, int cy);
                                                                            ^~~~~

-
Edité par PaulLenoir1 23 octobre 2018 à 11:34:50

romantik

23 octobre 2018 à 11:41:51

Salut,

PaulLenoir1 a écrit:

Surtout que ça peut être très pratique d'avoir une fenêtre qui reste devant les applications plein écran, ce que ne peut pas faire "topmost"; donc si quelqu'un sait comment faire pour rester devant les appli plein écran (et accessoirement devant labarre des tâches), ça m'intéresse; sinon tant pis pour moi !!!

Tu souhaites faire un overlay, comme on trouve sur les logiciels de chat vocal (Discord/TS/Mumble ...) ?

Dream on, Dream on, Dream until your dream comes true

PaulLenoir1

23 octobre 2018 à 11:59:39

Oui par exemple; je voudrais faire un petit utilitaire qui puisse rester au premier plan, même devant les applications plein écran comme les jeux vidéos ou les appli du windows store (exemple le scanneur).

bacelar

23 octobre 2018 à 12:22:15

Mon gestionnaire des tâches n'est pas topmost par défaut et le passage devant la barre de tâches est plus lié au flag "WS_POPUP" qu'à autre chose.

Utilisez "Spy++" (compris dans VS) si vous voulez fureter les types/flags de fenêtres, mais vous allez être dessus.

> que le gestionnaire des tâches puisse le faire, et pas un .exe que l'on crée soit même.

Mais quoi au juste ? Il s'affiche comme les autres fenêtres ayant les mêmes flags de fenêtres (cf. Spy++).

>Surtout que ça peut être très pratique d'avoir une fenêtre qui reste devant les applications plein écran

Heu, vous plaisantez ???

>ce que ne peut pas faire "topmost";

Heu, si c'est une application DirectX et consort, c'est normal, c'est pas fait pour.

Franchement, j'ai l'impression que vous cherchez le dahu, et aussi à cesser les pieds du pauvre utilisateur qui veut jouir d'une utilisation pas trop casse-couille de son IHM.

EDIT : Pour ce qui est des erreurs de compilation, il faut ajouter toutes une ribambelle d'include, mais on s'en fout, c'est juste pour signaler que "windows.h" n'a rien de spécial (contrairement à StdAfx.h) et que c'est juste un simple fichier .h pour simplifier l'usage de Win32 et que ce n'est pas Win32.

-
Edité par bacelar 23 octobre 2018 à 12:30:15

Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.

PaulLenoir1

23 octobre 2018 à 13:46:22

>Mon gestionnaire des tâches n'est pas topmost par défaut et le passage devant la barre de tâches est plus lié au flag "WS_POPUP" qu'à autre chose.

Si je remplace WS_OVERLAPPEDWINDOW par WS_POPUP, j’obtiens juste une fenêtre sans bordure, mais qui a toujours la même priorité pour le premier plan.

>Utilisez "Spy++" (compris dans VS) si vous voulez fureter les types/flags de fenêtres, mais vous allez être dessus.

je n'utilise pas visual studio mais codeblocks; mais je pense qu'on doit pouvoir télécharger et utiliser spy++ sans VS.

>Mais quoi au juste ? Il s'affiche comme les autres fenêtres ayant les mêmes flags de fenêtres.

Mais s'il s'affiche comme les autres fenêtre, pourquoi la mienne ne pourrait-elle pas faire comme lui ?

>Heu, vous plaisantez ???

je suis d'accord que dans certain cas c'est gênant une fenêtre qui reste en premier plan, mais ici c'est pour faire un petit utilitaire qu'on lance quand on a besoin seulement. Donc si on choisit de le lancer c'est que ça ne nous gêne pas!

(par exemple, les petits logiciels de chat dans certain jeux vidéos ne serviraient à rien s'il ne restaient pas par dessus la fenêtre plein écran)

>Franchement, j'ai l'impression que vous cherchez le dahu, et aussi à cesser les pieds du pauvre utilisateur qui veut jouir d'une utilisation pas trop casse-couille de son IHM.

Non je ne cherche pas à embêter l'utilisateur, je lui donne juste la possibilité de laisser cette fenêtre toujours en premier plan s'il le souhaite, de la même manière que l'on peut choisir que le gestionnaire des tâches soit toujours visible (et puis à l'origine, c'est plutôt pour moi que je crée ce programme)

-
Edité par PaulLenoir1 23 octobre 2018 à 13:50:36

bacelar

23 octobre 2018 à 14:16:11

Vous, vous n'avez jamais programmer un jeu avec DirectX ou OpenGL et en avoir chier pour avoir des performances potables, sinon vous êtes un schizophrène sévère.

Ce que vous cherchez à faire est une hérésie en terme de performance.

Sur des applications "Desktop" on s'en fout mais pas sur des applications plaine-écran.

Franchement, si j'ai besoin d'un utilitaire de ce type pour un jeu, c'est clairement sur un second moniteur que je le docke et pas sur mon putain de rendu.

Si vous cherchez toujours le dahu, utilisez Spy++ qui vous montrera les 12 styles et 5 styles étendu que la fenêtre principale, ainsi que les classes de fenêtre et les envois et les réceptions de message, etc...

Vous pourrez toujours jouer au jeu des 7 différences avec celle de votre application.

Tant que vous n'êtes pas précis dans votre demande, on ne pourra pas répondre précisément. Quel est le comportement précis vous cherchez à avoir (et pas juste "comme Mme Michu").

Bon, c'est quoi comme application qui peut justifier de saloper une IHM fait par quelqu'un d'autre ? (parce que les plug-ins, c'est un peu fait pour).

Vous avez déjà essayé le topmost du gestionnaire de tâche sur un programme DirectX ?

Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.

PaulLenoir1

23 octobre 2018 à 14:49:50

J'ai comparé les styles et styles étendus du gestionnaire des tâches quand il est en mode toujours visible et quand il ne l'est pas, et la seule différence est la présence du style étendu WS_EX_TOPMOST. J'ai donc essayé de créer ma fenêtre avec exactement les mêmes styles et styles étendus que le gestionnaire des tâches... et je n'ai rien obtenu de concluant (toujours une fenêtre comme avant, qui se pas derrière la barre des tâches dès qu'on clique sur celle ci).

#include <windows.h>

LRESULT WINAPI fenProc(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
	switch(Msg){
		case WM_CREATE:
			{
				ShowWindow(hwnd, SW_SHOW);
			}
			return 0;
                case WM_CLOSE:
		    {
		        DestroyWindow(hwnd);
		    }
		    return 0;
		case WM_DESTROY:
		    {
		        PostQuitMessage(0);
		    }
			return 0;
	}
	return DefWindowProc(hwnd, Msg, wParam, lParam);
}

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrev, LPSTR lpCmdLine, int nShowCmd)
{
	WNDCLASS wndClass = { 0, fenProc, 0, 0, hInstance, NULL, LoadCursor(NULL, IDC_ARROW), 0, NULL, "fenetre" };
	wndClass.hbrBackground = (HBRUSH) 7;
        if(!RegisterClass(&wndClass)) return false;
	HWND hwnd=CreateWindowEx(WS_EX_LEFT|WS_EX_LTRREADING|WS_EX_RIGHTSCROLLBAR|WS_EX_TOPMOST|WS_EX_WINDOWEDGE,
"fenetre", NULL, 
WS_CAPTION|WS_VISIBLE|WS_CLIPSIBLINGS|WS_SYSMENU|WS_THICKFRAME|WS_OVERLAPPED|WS_MINIMIZEBOX|WS_MAXIMIZEBOX,
200, 500, 100, 100, HWND_DESKTOP, NULL, hInstance, NULL); 
        if(!hwnd) return false;
	MSG Msg;
	while(GetMessage(&Msg, NULL, 0, 0))
        {
			TranslateMessage(&Msg);
			DispatchMessage(&Msg);
	}
	return 0;
}

Il y a pourtant forcément un moyen que ma fenêtre ne passe pas derrière la barre des tâches à chaque fois que je clique sur cette dernière ?

-
Edité par PaulLenoir1 23 octobre 2018 à 17:14:16

romantik

23 octobre 2018 à 15:00:11

PaulLenoir1 a écrit:

Il y a pourtant forcément un moyen que ma fenêtre ne passe pas derrière la barre des tâches à chaque fois que je clique sur cette dernière ?

Pourquoi ?

Dream on, Dream on, Dream until your dream comes true

PaulLenoir1

23 octobre 2018 à 15:08:31

Parce qu'il existe des fenêtres capables de le faire !!! (taskmgr.exe en est un exemple...)

pseudo-simple

23 octobre 2018 à 17:03:26

Bonjour

je viens de compiler ton programme pour chercher à comprendre ce que tu fais :

J'ai trouvé 3 erreurs dedans : tes False déjà , c'est sans masjuscule.

De plus, ta balise <br> doit être retirée

Après cela, oui, effectivement, j'ai une fenêtre qui reste au premier plan. Elle est toute petite en effet.

Peux-tu m'expliquer , étape par étape, ce que fait ton programme ?

Merci

PaulLenoir1

23 octobre 2018 à 17:42:56

En fait les erreurs viennent du fait que j'ai simplifié un peu le programme que j'ai mis sur le forum, et la balise <br> vient probablement d'un bug dû au html (je modifie donc ça dans mon message précédent).

Explications:

#include <windows.h>

sert à inclure win32 dans mon programme.

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrev, LPSTR lpCmdLine, int nShowCmd)
{

est la fonction d'entrée (APIENTRY) c'est à dire celle que va appeler le système d'exploitation lors qu'on lance le programme.

WNDCLASS wndClass = { 0, fenProc, 0, 0, hInstance, NULL, LoadCursor(NULL, IDC_ARROW), 0, NULL, "fenetre" };
wndClass.hbrBackground = (HBRUSH) 7;   
if(!RegisterClass(&wndClass)) return false;

déclaration de la classe dans laquelle on va créer notre fenêtre (c'est probablement très mal dit). En particulier on indique au système quelle fonction il faudra appeler pour gérer les événements (fenProc), on indique quelle curseur utiliser (ici la flèche: IDC_ARROW), la couleur du fond d'ecran (hbrBackground),..., puis on registre cette classe (et si il y a une erreur on retourne false)

     HWND hwnd = CreateWindowEx(WS_EX_LEFT|WS_EX_LTRREADING|WS_EX_RIGHTSCROLLBAR|WS_EX_TOPMOST|WS_EX_WINDOWEDGE,
                "fenetre", NULL,
                WS_CAPTION|WS_VISIBLE|WS_CLIPSIBLINGS|WS_SYSMENU|WS_THICKFRAME|WS_OVERLAPPED|WS_MINIMIZEBOX|WS_MAXIMIZEBOX,
                200, 500, 100, 100, HWND_DESKTOP, NULL, hInstance, NULL);
     if(!hwnd) return false;

on crée la fenêtre à partir de la fonction CreateWindowEx dans laquelle on met les styles étendus (en premier argument) et les styles (en quatrième argument) identiques à ceux du gestionnaire des tâches, dont WS_EX_TOPMOST qui met la fenête au premier plan; on y met aussi les coordonnées (200,500) et la taille de la fenêtre (100,100) la fenêtre "parente" (HWND_DESKTOP) qui ici est le bureau.

    MSG Msg;
        while(GetMessage(&Msg, NULL, 0, 0))
        {
            TranslateMessage(&Msg);
            DispatchMessage(&Msg);
        }
    return 0;
}

On crée la boucle "infinie" qui va capter les messages reçu par la fenêtre (GetMessage) et les transmettres à la fonction fenProc (TranslateMessage et DispatchMessage) qui va gérer ces messages (fermeture de la fenêtre,...)

Voilà pour la fonction principale; voyons maintenant la fonction fenProc qui s'occupe de gérer les messages:

LRESULT WINAPI fenProc(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
    switch(Msg){

cette fonction est appelée à chaque fois que la fenêtre reçoit un message (j'imagine que vous savez déjà tous ça, mais ça me permet d'être sûr que je ne dis pas d'énormité!). On ouvre un switch qui va exécuter différentes fonctions selon le message reçu.

        case WM_CREATE:
            {
                ShowWindow(hwnd, SW_SHOW);
            }
            return 0;

lorsque la fenêtre est créée, un message de création (WM_CREATE) est transmis, et la fonction fenProc se charge d'afficher la fenêtre (ShowWindow).

                case WM_CLOSE:
            {
                DestroyWindow(hwnd);
            }

lorsque l'utilisateur tente de fermer la fenêtre (alt+f4, ou clic sur la croix) le message WM_CLOSE est transmis à fenProc, et la fenêtre est détruite (DestroyWindow).

        case WM_DESTROY:
            {
                PostQuitMessage(0);
            }
            return 0;
    }

Lorsque le message de destruction (WM_DESTROY) de la fenêtre est envoyé à fenProc, un message (PostQuitMessage(0)) est transmis (au système d'exploitation ?) indiquant que le programme a fini de s'exécuter.

    return DefWindowProc(hwnd, Msg, wParam, lParam);
}

Pour tous les autres messages transmis (pressions de touches, clic de souris,...) on exécute la fonction par défaut de l'api windows.

Voilà, j'espère que j'ai été assez clair et que je n'ai pas dit trop d'énormité !!!

-
Edité par PaulLenoir1 23 octobre 2018 à 17:54:18

pseudo-simple

23 octobre 2018 à 17:48:14

Personnellement, je progresse aussi en lisant les messages patiemment et en compilant pour aller plus loin.

Donc je n'ai pas la prétention de tout maîtriser.

C'est pour cela que je t'ai posé la queestion.

Ton code est assez technique.

Si tu veux, tu peux mettre ton code dans son intégralité afin que les intervenants puissent le compiler complètement

LilyKianii

23 octobre 2018 à 18:00:07

Hola !

As-tu essayé : WS_EX_APPWINDOW ?

PaulLenoir1

23 octobre 2018 à 18:19:58

>Si tu veux, tu peux mettre ton code dans son intégralité afin que les intervenants puissent le compiler complètement.

En fait mon code entier ne comporte que quelques ajouts supplémentaires pour le moment (qui vont changer au fur et à mesure que je vais faire mon programme et que je vais progresser) et qui ne sont pas utiles à la compréhension du problème de mise en premier plan de la fenêtre.

Puisqu'ici je ne traite les messages que de la manière par défaut (ex: clic sur la croix= fermer la fenêtre), il y a moyen de laisser faire l'api windows en simplifiant ainsi le programme:

#include <windows.h>

LRESULT WINAPI fenProc(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
    if (Msg==WM_DESTROY)
    {
        PostQuitMessage(0);
    }
    return DefWindowProc(hwnd, Msg, wParam, lParam);
}

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrev, LPSTR lpCmdLine, int nShowCmd)
{
    WNDCLASS wndClass = { 0, fenProc, 0, 0, hInstance, NULL, LoadCursor(NULL, IDC_ARROW), 0, NULL, "fenetre" };
    wndClass.hbrBackground = (HBRUSH) 7;
        if(!RegisterClass(&wndClass)) return false;
    HWND hwnd = CreateWindowEx(WS_EX_LEFT|WS_EX_LTRREADING|WS_EX_RIGHTSCROLLBAR|WS_EX_TOPMOST|WS_EX_WINDOWEDGE,
"fenetre", NULL,
WS_CAPTION|WS_VISIBLE|WS_CLIPSIBLINGS|WS_SYSMENU|WS_THICKFRAME|WS_OVERLAPPED|WS_MINIMIZEBOX|WS_MAXIMIZEBOX,
200, 500, 100, 100, HWND_DESKTOP, NULL, hInstance, NULL);
        if(!hwnd) return false;
    MSG Msg;
    while(GetMessage(&Msg, NULL, 0, 0))
        {
            TranslateMessage(&Msg);
            DispatchMessage(&Msg);
    }
    return 0;
}

Par contre, dès qu'on veut répondre aux messages d'une manière autre que celle par défaut (par exemple demander à l'utilisateur s'il veut enregistrer le travail en cours, au lieu de directement fermer la fenêtre, quand il clic sur la croix), on est obligé de définir soit même la manière de répondre aux messages. exemple de code:

#include <windows.h>

LRESULT WINAPI fenProc(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
    switch(Msg){
        case WM_CLOSE:
		    return MessageBox(HWND_DESKTOP, "enregistrer votre travail", NULL, MB_OKCANCEL);
        case WM_LBUTTONDOWN:
            {
                DestroyWindow(hwnd);
            }
            return 0;
        case WM_DESTROY:
            {
                PostQuitMessage(0);
            }
            return 0;
    }
    return DefWindowProc(hwnd, Msg, wParam, lParam);
}

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrev, LPSTR lpCmdLine, int nShowCmd)
{
    WNDCLASS wndClass = { 0, fenProc, 0, 0, hInstance, NULL, LoadCursor(NULL, IDC_ARROW), 0, NULL, "fenetre" };
    wndClass.hbrBackground = (HBRUSH) 7;
        if(!RegisterClass(&wndClass)) return false;
    HWND hwnd = CreateWindowEx(WS_EX_LEFT|WS_EX_LTRREADING|WS_EX_RIGHTSCROLLBAR|WS_EX_TOPMOST|WS_EX_WINDOWEDGE,
"fenetre", NULL,
WS_CAPTION|WS_VISIBLE|WS_CLIPSIBLINGS|WS_SYSMENU|WS_THICKFRAME|WS_OVERLAPPED|WS_MINIMIZEBOX|WS_MAXIMIZEBOX,
200, 500, 100, 100, HWND_DESKTOP, NULL, hInstance, NULL);
        if(!hwnd) return false;
    MSG Msg;
    while(GetMessage(&Msg, NULL, 0, 0))
        {
            TranslateMessage(&Msg);
            DispatchMessage(&Msg);
    }
    return 0;
}

Ce code sert juste à comprendre (pour fermer la fenêtre, il faut cliquer dedans, et si on clique sur la croix, on ouvre une boite de dialogue).

>As-tu essayé : WS_EX_APPWINDOW ?

Oui, j'ai essayé mais ça ne change rien ?

-
Edité par PaulLenoir1 23 octobre 2018 à 18:26:12

bacelar

23 octobre 2018 à 19:00:03

taskmgr.exe n'est pas un programme lambda.

Il est au minimum signer avec la clé M$, ce qui potentiellement change bien des comportements.

Mais bon, vous insistez à faire un truc super pas pratique, on va ramer.

Donc, le seul but du bidule, c'est de faire en sorte que la fenêtre soit au-dessus de la taskbar leur de ses déplacement, super.

Vous avez tenté de gérer vous-même les déplacements avec SetWindowPosition et en utilisant la valeur "HWND_TOP" en 2ème paramètre ?

https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-setwindowpos

Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.

PaulLenoir1

23 octobre 2018 à 20:51:55

C'est ce que j'ai fait dans le programme que j'ai mis dans le premier message de cette discussion:

...
case WM_CREATE:
            {
                ShowWindow(hwnd, SW_SHOW);
                SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
            }
            return 0;
...

mais justement, dans la description il est dit qu'elle reste devant toute les fenêtes qui sont "non-topmost", or la barre des tâches et le menu qui s'ouvre quand on appuie sur la touche windows sont des fenêtres "topmost", donc il faudrait un attribut encore plus fort (mais cet attribut n'existe pas comme le montre la doc). il y a donc une solution, autre que celle-ci que doit utiliser taskmgr.exe, à moins lque sa signature M$ ne le rende prioritaire.

>Vous avez tenté de gérer vous-même les déplacements avec SetWindowPosition... ?

En fait le problème ce n'est pas lors du déplacement de ma fenêtre (quand ma fenêtre est active elle reste par dessus la barre des tâches), mais c'est lorsqu'on clic sur la barre des tâches ou qu'on appuie sur la touche windows la barre des tâches s'active et ma fenêtre n'est plus active, donc elle passe en dessous de la barre des tâches, ce que je voudrais éviter.

-
Edité par PaulLenoir1 23 octobre 2018 à 20:55:46

LilyKianii

24 octobre 2018 à 10:23:26

PaulLenoir1 a écrit:

>As-tu essayé : WS_EX_APPWINDOW ? Oui, j'ai essayé mais ça ne change rien ?

Je ne sais pas si ça change quelque chose ou pas mais j'ai bêtement lu la doc.
WS_EX_APPWINDOW : Forces a top-level window onto the taskbar when the window is visible.
Les prérequis sont :

Que la fenêtre n'est pas de parent
Que tu utilises CreateWindowsEx pour la création de ta fenêtre

EDIT : Autant pour moi, le focus sur la taskbar se fait tout de même si elle est sollicitée après la création de la fenêtre.

-
Edité par LilyKianii 24 octobre 2018 à 13:16:39

bacelar

24 octobre 2018 à 14:05:50

>mais cet attribut n'existe pas comme le montre la doc

Où ça ???

Moi, j'ai HWND_TOP, comme je l'ai déjà indiqué dans mon message précédent.

>lorsqu'on clic sur la barre des tâches ..., ce que je voudrais éviter.

C'est exactement la même chose sur mon gestionnaire des tâches.

Vous voulez donc faire "mieux" que le gestionnaire des tâches ???

Trouvez un programme qui fait ce que vous voulez et regardez ces fenêtres avec Spy++.

Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.

romantik

24 octobre 2018 à 14:37:42

bacelar a écrit:

>lorsqu'on clic sur la barre des tâches ..., ce que je voudrais éviter.
C'est exactement la même chose sur mon gestionnaire des tâches.

De même, je me suis dis que je n'avais peut-être pas la même version de Windows, je suis sous seven et le gestionnaire de tâche passe derrière la barre de tâche quand je clique dessus alors que l'option "toujours visible" est activée

Dream on, Dream on, Dream until your dream comes true

PaulLenoir1

24 octobre 2018 à 14:45:00

> Où ça ???

la doc dit qu'il y a quatre valeurspossibles pour le deuxième argument (hWndInsertAfter)de la fonction setWindowPos:

HWND_BOTTOM, HWND_NOTOPMOST, HWND_TOP etHWND_TOPMOST et la valeur la plus " forte " des quatre en ce qui concerne la mise en premier plan est HWND_TOPMOST !

Sinon, pour le gestionnaire des tâches, il faut aller dans 'Options' et cliquer sur 'toujours visible', et avec cette option (au moins pour windows 8.1), non seulement il reste toujours devant les fenêtres "non topmost", mais aussi devant les fenêtre "topmost" qu'elles soient actives ou non. Si vous regardez la deuxième capture d'écran que j'ai mise dans mon premier message, vous voyezque le menu qui s'ouvre à l'appui de la touche windows (classic Shell pour moi), ainsi que la barre des tâches, sont tous les deux derrière le gestionnaire des tâches alors que ce dernier n'est pas actif (la fenêtre active est celle du menu). Alors que si vous regardez la première capture d'écran vous verrez que la petite fenêtre que j'ai créée avec mon programme se trouve derrière le menu classic shell (qui lui aussi est un topmost).

-
Edité par PaulLenoir1 24 octobre 2018 à 14:49:10

bacelar

24 octobre 2018 à 15:02:39

>et la valeur la plus " forte " des quatre en ce qui concerne

Et, on n'est pas à la chasse aux Pokemons, il n'y a pas d'échelle de "puissance".

Tester avec HWND_TOP, SVP.

Je suis sur Win7Pro actuellement, et j'ai le même comportement que @romantik et donc pas le vôtre, semble-t-il.

Cela renforce donc dans mon idée, vu que c'est une "feature" non portable, sur le fait que c'est un très mauvaise fausse bonne idée d'IHM 3.0 Poltergeist.

Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.

LilyKianii

24 octobre 2018 à 15:11:00

Windows 10, le task manager reste au dessus.

De mon côté, j'ai trouvé ce post .

La première réponse répète basiquement ce que Bacelar t'as dit jusqu'ici. C'est-à-dire, en résumant :

"C'est d'la merde ! De mon temps, on cherchait pas à détruire son OS comme ça!"
Arriveras à un moment où tu confrontes 2 top-most et à ce moment-ci... Undefined behavior ou quelque chose qui s'y apparente.
L'OS va arbitrer comme il l'entends (selon la version et/ou le cas) :
- probablement à la Rambo, en éliminant tout ce qui lui bloque le chemin
- ou en considérant que process1 > process2 (Luke, je suis ton parent. NOOOOOOOOOOOOOOOOON !!!)

La seconde réponse, plus courte et plus simple :

Le task manager est un cas un peu particulier. Pourquoi ? Parce que Microsoft.
Le task manager est créé à l'aide de la fonction CreateWindowInBand (non documentée)
Utiliser cette fonction te renvoie un énorme 0x5 - ACCESS_DENIED probablement dû au fait que c'est un component signé Microsoft.

-
Edité par LilyKianii 24 octobre 2018 à 15:33:57

PaulLenoir1

24 octobre 2018 à 15:34:17

Salut LilyKianii,

merci de cette réponse claire (enfin quelqu'un qui me comprend !!);

En fait je ne veux pas faire la course avec le gestionnaire des tâches (ce serait incensé), mais je voulais juste savoir pourquoi et comment il fait ça (il semble donc que ce soit grâce à CreateWindowInBand) et savoir comment créer une fenêtre qui reste devant les fenêtre plein écran, la barre des tâches,... sans pour autant qu'elle reste devant le gestionnaire des tâches lui-même (qu'elle soit un niveau 'supérieur' au simple fenêtre topmost ou ws_ex_topmost, sans pour autant être supérieur au gestionnaire des tâches).

Autre question que je me pose, comment a-t-on pu savoir que le gestionnaire des tâches utilise la fonction CreateWindowInBand ? quelqu'un a-t-il pu trouver son code source ? l'information viendrait-elle de quelqu'un qui travaille chez Microsoft ?

Voilà la seule chose que j'ai trouvée à ce propos !

-
Edité par PaulLenoir1 24 octobre 2018 à 15:43:17

LilyKianii

24 octobre 2018 à 16:09:43

PaulLenoir1 a écrit:

Salut LilyKianii,

merci de cette réponse claire (enfin quelqu'un qui me comprend !!);

Je pense que les autres vous ont parfaitement compris mais qu'il vous fallait juste un "Pourquoi taskmanager et pas moi ?" pour y prêter attention (ce que je peux comprendre).

PaulLenoir1 a écrit:

sans pour autant qu'elle reste devant le gestionnaire des tâches lui-même (qu'elle soit un niveau 'supérieur' au simple fenêtre topmost ou ws_ex_topmost, sans pour autant être supérieur au gestionnaire des tâches).

Quoi que...
Vous m'avez mal compris. Je voulais vous faire comprendre que le gestionnaire des tâches pouvait rester devant la barre des tâches PARCE QUE c'est un composant signé microsoft. Ce qui n'est pas le cas de votre fenêtre qui n'est donc pas capable de "faire la course" avec la barre des tâches... à moins que...

Recette du succès (boucle infinie - reset le focus sur une fenêtre tout les x temps) :

Une pincée de bidouille
Un zeste de chance
Touiller l'OS dans le sens du poil
Réfléchissez à l'inutilité de la chose : Quel délice !

PaulLenoir1 a écrit:

Autre question que je me pose, comment a-t-on pu savoir que le gestionnaire des tâches utilise la fonction CreateWindowInBand ? quelqu'un a-t-il pu trouver son code source ? l'information viendrait-elle de quelqu'un qui travaille chez Microsoft ?

Comment ? Aucune idée. Mais je pense que le nom de la fonction est déjà assez explicite.

C'est une fonction de user32.dll, je suppose que ça ne c'est pas généré comme par magie. Il doit bien y avoir des sources quelque part.

Par contre, retrouver la signature de la fonction est largement atteignable.

-
Edité par LilyKianii 24 octobre 2018 à 16:11:37

PaulLenoir1

24 octobre 2018 à 16:33:45

>Recette du succès (boucle infinie - reset le focus sur une fenêtre tout les x temps) :

Une pincée de bidouille
Un zeste de chance
Touiller l'OS dans le sens du poil

Sinon il y a la solution de s'auto "setforeground()" en continu:

#include <windows.h>

LRESULT WINAPI fenProc(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
	if(Msg==WM_DESTROY)
		        PostQuitMessage(0);
	return DefWindowProc(hwnd, Msg, wParam, lParam);
}

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrev, LPSTR lpCmdLine, int nShowCmd)
{
	WNDCLASS wndClass = { 0, fenProc, 0, 0, hInstance, NULL, LoadCursor(NULL, IDC_ARROW), 0, NULL, "fenetre" };
	wndClass.hbrBackground = (HBRUSH) 7;
        if(!RegisterClass(&wndClass)) return false;
	HWND hwnd = CreateWindow("fenetre", NULL, WS_POPUP, 0, 0, 100, 100, HWND_DESKTOP, NULL, hInstance, NULL);  //WS_POPUP,WS_OVERLAPPEDWINDOW
        if(!hwnd) return false;
	MSG Msg;
	ShowWindow(hwnd,SW_SHOW);
	while(Msg.message != WM_QUIT){
		if(PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE)){
			TranslateMessage(&Msg);
			DispatchMessage(&Msg);
		}
		DWORD foregroundThreadID = GetWindowThreadProcessId(GetForegroundWindow(), 0);   //ID du thread au premier plan
                DWORD ourThreadID = GetCurrentThreadId();   //ID de notre thread (thread de l'application)
                if (foregroundThreadID != ourThreadID)   //si notre application n'est pas à l'avant plan
                {
                    AttachThreadInput(foregroundThreadID, ourThreadID, TRUE);   //on attache le thread de notre application sur le thread de l'application qui est au premier plan
                    SetForegroundWindow(hwnd);   //maitenant on peut faire passer notre fenêtre au premier plan
                    AttachThreadInput(foregroundThreadID, ourThreadID, FALSE);   //on détache le thread
                }
		Sleep(1);
	}
	return 0;
}

(je précise que les 6 lignes commentées ne sont pas de moi .)

Le principe est d'utiliser la fenêtre au premier plan (si ce n'est pas la notre) pour se remettre au premier plan en lui attachant le thread de notre application.

Cependant le résultat n'est pas du tout ce que je cherche (et ça fait un effet de clignotement super moche quand notre fenêtre se remet au premier plan), car notre fenêtre ne fait pas que se remettre au premier plan, mais elle s'active en même temps et "pompe" le focus sur elle, donc impossible d'utiliser le clavier sur une autre fenêtre en même temps, ce qui n'est pas le cas avec le gestionnaire des tâches (et qui est super gênant !).

Ce que vous dites sur "reset le focus" ne doit pas avoir un résultat meilleur puisque le but est que la fenêtre soit au premier plan SANS avoir le focus, et SANS être active (comme le gestionnaire des tâches); mais c'est pas grave, si vous avez un bout de code expliquant comment "reset le focus" d'une fenêtre, ça m'intéresse...

bacelar

24 octobre 2018 à 17:03:16

Merci @LilyKianii pour cette recherche très approfondie.

Et, en résumé, M$ s'est octroyé le droit de faire en sorte que les développeurs qui font nimportnawake n'empêche pas l'utilisateur de travailler avec la machine (dommage que cela ne fonctionne pas encore bien contre les ransomwares).

>l'information viendrait-elle de quelqu'un qui travaille chez Microsoft ?

Tu penses que le fait qu'il y avait un "Bozo le Clown" dans l'API de Windows avait vraiment été "fuité" ? LOL

https://blogs.msdn.microsoft.com/oldnewthing/20031015-00/?p=42163

C'est pas vraiment une API "cachée/secrète", c'est une API non documentée, c'est tout et c'est déjà pas mal.

N'importe quel outil standard les montrera, exactement comme les fonctions documentées de l'API.

DUMPBIN ou "Dependency walker" sur l'exe du gestionnaire de tâche indique toutes les fonctions des dll utilisés par le programme, qu'elle soit documentée ou pas.

Et ils ont arrêté de nommer leur fonction avec des blagues internes (cf. Bozo) et les noms des fonctions correspondent à leurs actions.

Donc un "CreateWindowInBand", c'est pas trop déconnant, un coup de débogage du programme avec un point d'arrêt sur l'appel à cette fonction et on n'en a le cœur net.

Pas besoin de voler les sources ou de torturer un employé de M$.

Si tu veux plus d'information sur les Dll système, tu peux configurer ton IDE (non Code::Blocks, c'est pas un IDE, au mieux une blague) pour se connecter au server des symboles de M$ pour télécharger les symboles de vos Dll systèmes et ainsi connaitre les signatures et les noms des arguments de toutes les fonctions, documenté ou pas.

En résumé, non documenté, ça veut pas dire secret, ça veut dire que si M$ veut changer des trucs, tu peux faire l'avions et pleurer.

EDIT :

>Sinon il y a la solution de s'auto "setforeground()" en continu:

J'espère sincèrement que ce n'est qu'une blague, votre sombre bidouille toute moisis ?

Bon, si tu veux vraiment faire comme le gestionnaire des tâches, tu appelles les mêmes API que lui.

Le fait que l'API ne soit pas documentée, bin, tu ferras l'avion quand M$ la changera (ou, si tu fais du business avec ta cochonnerie, tu t'inscris au programme de Beta-Test de M$ et tu t'arranges pour patcher ton machin en même temps que les montés de version des Windows que t'es sensé supporter).

Mais, bon, "jouer à qui a la plus grosse 'top_most'" c'est complètement stérile.

-
Edité par bacelar 24 octobre 2018 à 17:22:25

Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.

1 2 >>