Win32: plein écran et le masquage de la barre des tâches

Edit 2. Il y a même une meilleure façon de faire le plein écran, le chrome manière, source de prises à partir d'ici:

http://src.chromium.org/viewvc/chrome/trunk/src/ui/views/win/fullscreen_handler.cc?revision=HEAD&view=markup

void FullscreenHandler::SetFullscreenImpl(bool fullscreen, bool for_metro) {
ScopedFullscreenVisibility visibility(hwnd_);
//Save current window state if not already fullscreen.
if (!fullscreen_) {
//Save current window information.  We force the window into restored mode
//before going fullscreen because Windows doesn't seem to hide the
//taskbar if the window is in the maximized state.
saved_window_info_.maximized = !!::IsZoomed(hwnd_);
if (saved_window_info_.maximized)
::SendMessage(hwnd_, WM_SYSCOMMAND, SC_RESTORE, 0);
saved_window_info_.style = GetWindowLong(hwnd_, GWL_STYLE);
saved_window_info_.ex_style = GetWindowLong(hwnd_, GWL_EXSTYLE);
GetWindowRect(hwnd_, &saved_window_info_.window_rect);
}
fullscreen_ = fullscreen;
if (fullscreen_) {
//Set new window style and size.
SetWindowLong(hwnd_, GWL_STYLE,
saved_window_info_.style & ~(WS_CAPTION | WS_THICKFRAME));
SetWindowLong(hwnd_, GWL_EXSTYLE,
saved_window_info_.ex_style & ~(WS_EX_DLGMODALFRAME |
WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE | WS_EX_STATICEDGE));
//On expand, if we're given a window_rect, grow to it, otherwise do
//not resize.
if (!for_metro) {
MONITORINFO monitor_info;
monitor_info.cbSize = sizeof(monitor_info);
GetMonitorInfo(MonitorFromWindow(hwnd_, MONITOR_DEFAULTTONEAREST),
&monitor_info);
gfx::Rect window_rect(monitor_info.rcMonitor);
SetWindowPos(hwnd_, NULL, window_rect.x(), window_rect.y(),
window_rect.width(), window_rect.height(),
SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
}
} else {
//Reset original window style and size.  The multiple window size/moves
//here are ugly, but if SetWindowPos() doesn't redraw, the taskbar won't be
//repainted.  Better-looking methods welcome.
SetWindowLong(hwnd_, GWL_STYLE, saved_window_info_.style);
SetWindowLong(hwnd_, GWL_EXSTYLE, saved_window_info_.ex_style);
if (!for_metro) {
//On restore, resize to the previous saved rect size.
gfx::Rect new_rect(saved_window_info_.window_rect);
SetWindowPos(hwnd_, NULL, new_rect.x(), new_rect.y(),
new_rect.width(), new_rect.height(),
SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
}
if (saved_window_info_.maximized)
::SendMessage(hwnd_, WM_SYSCOMMAND, SC_MAXIMIZE, 0);
}
}

Modifier.
Il est probablement préférable de créer une fenêtre plein écran comme BrendanMcK l'a fait remarquer dans un commentaire à cette réponse, voir ce lien: http://blogs.msdn.com/b/oldnewthing/archive/2005/05/05/414910.aspx ("Comment puis-je couvrir la barre des tâches avec une fenêtre plein écran?")

Le nouveau code à l'aide du lien ci-dessus serait:

HWND CreateFullscreenWindow(HWND hwnd)
{
HMONITOR hmon = MonitorFromWindow(hwnd,
MONITOR_DEFAULTTONEAREST);
MONITORINFO mi = { sizeof(mi) };
if (!GetMonitorInfo(hmon, &mi)) return NULL;
return CreateWindow(TEXT("static"),
TEXT("something interesting might go here"),
WS_POPUP | WS_VISIBLE,
mi.rcMonitor.left,
mi.rcMonitor.top,
mi.rcMonitor.right - mi.rcMonitor.left,
mi.rcMonitor.bottom - mi.rcMonitor.top,
hwnd, NULL, g_hinst, 0);
}

---

Vieille réponse ci-dessous - ne l'utilisez pas, reste que pour l'enregistrement sur la façon de ne PAS le faire.

Vous avez à cacher la barre des tâches et la barre de menu pour voir en plein écran immédiatement.

Voici le code (utilise WTL), appel SetFullScreen(true) pour passer en mode plein écran:

template <class T, bool t_bHasSip = true>
class CFullScreenFrame
{
public:
bool m_fullscreen;
LONG m_windowstyles;
WINDOWPLACEMENT m_windowplacement;
CFullScreenFrame() 
:
m_fullscreen(false),
m_windowstyles(0)
{ }
void SetFullScreen(bool fullscreen)
{
ShowTaskBar(!fullscreen);
T* pT = static_cast<T*>(this);
if (fullscreen) {
if (!m_fullscreen) {
m_windowstyles = pT->GetWindowLongW(GWL_STYLE);
pT->GetWindowPlacement(&m_windowplacement);
}
}
//SM_CXSCREEN gives primary monitor, for multiple monitors use SM_CXVIRTUALSCREEN.
RECT fullrect = { 0 };              
SetRect(&fullrect, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
WINDOWPLACEMENT newplacement = m_windowplacement;
newplacement.showCmd = SW_SHOWNORMAL;
newplacement.rcNormalPosition = fullrect;
if (fullscreen) {
pT->SetWindowPlacement(&newplacement);
pT->SetWindowLongW(GWL_STYLE,  WS_VISIBLE);
pT->UpdateWindow();
} else {
if (m_fullscreen) {
pT->SetWindowPlacement(&m_windowplacement);
pT->SetWindowLongW(GWL_STYLE, m_windowstyles);
pT->UpdateWindow();
}
}
m_fullscreen = fullscreen;
}
void ShowTaskBar(bool show)
{
HWND taskbar = FindWindow(_T("Shell_TrayWnd"), NULL);
HWND start = FindWindow(_T("Button"), NULL);
if (taskbar != NULL) {
ShowWindow(taskbar, show ? SW_SHOW : SW_HIDE);
UpdateWindow(taskbar);
}
if (start != NULL) { 
//Vista
ShowWindow(start, show ? SW_SHOW : SW_HIDE);
UpdateWindow(start);
}       
}
};

Vous devez également ajouter un peu de code de message WM_CLOSE:

case WM_CLOSE:
ShowTaskBar(true);

Il y a un problème avec cette solution, si votre application se bloque ou est tué par le gestionnaire de tâches, puis l'utilisateur pertes de la barre des tâches sur son système de façon permanente! (à moins qu'il exécute votre application à nouveau, passe en plein écran et sort, puis il va voir la barre des tâches de nouveau).

Plus haut dans ma réponse je l'ai fait à "atlwince.h", mais cette fonction a travaillé uniquement sur Windows CE, celui que j'ai collé ci-dessus fonctionne très bien avec windows XP, Vista et 7.

Raymond Chen décrit la "bonne" façon de faire cela à son blog:

http://blogs.msdn.com/b/oldnewthing/archive/2005/05/05/414910.aspx

De se tripoter la barre des tâches de la fenêtre est expressément pas recommandé de comportement.

1. Clic droit sur la barre des tâches
2. choisir Propriétés
3. décochez la case "Conserver la barre des tâches au-dessus des autres fenêtres".

La barre des tâches appartient à la utilisateur, C'est à eux de se préoccuper d'avoir un il prendre 1/2 seconde pour masquer automatiquement lorsque vous application passe en mode plein écran. Si ils veulent changer ce comportement alors qu'ils peuvent changer.

Si vous travaillez dans un système embarqué, alors vous pourriez avoir un motif légitime pour masquer la barre des tâches. Mais dans ce cas, il n'y a aucune raison de ne pas simplement configurer la barre des tâches de ne pas toujours être au top. Vous pourriez aussi avoir un coup d'oeil à SystemParametersInfo si vous souhaitez modifier certains de ces paramètres dans votre code.