Cas quand une fenêtre obtient agrandie/onu maximisée

Est-il un événement qui est déclenché lorsque vous agrandissez une Forme ou de l'onu-l'optimiser?

Avant de vous dire Resize ou SizeChanged: Ceux qui sont seulement déclenché si l' Size change réellement. Si votre fenêtre se trouve être égale à la taille de la fenêtre agrandie, ils ne se déclenche pas. Emplacement ressemble le prochain meilleur pari, mais qui se sent de nouveau comme les jeux de hasard sur une coïncidence.

Vous pouvez tester l'emplacement, mais qui pose la question de savoir quel serait le feu de votre test...
Serait de tester le windowstate dans la forme de l'événement activate aider?
Par les nations unies "maximisée", tu veux sans doute dire "restaurée".

InformationsquelleAutor Michael Stum | 2009-08-18

c#winforms

43

Vous pouvez le faire en remplaçant WndProc:
```
protected override void WndProc( ref Message m )
{
    if( m.Msg == 0x0112 ) //WM_SYSCOMMAND
    {
        //Check your window state here
        if (m.WParam == new IntPtr( 0xF030 ) ) //Maximize event - SC_MAXIMIZE from Winuser.h
        {
              //THe window is being maximized
        }
    }
    base.WndProc(ref m);
}
```
Cela devrait gérer l'événement dans une fenêtre. SC_RESTORE est 0xF120, et SC_MINIMIZE est 0XF020, si vous avez besoin de ces constantes, trop.
- Vous remarquerez peut-être que cela ne fonctionne pas lors de l'agrandissement en double-cliquant sur la barre de titre. Selon MSDN, "Dans WM_SYSCOMMAND les messages, les quatre bits du paramètre wParam sont utilisés en interne par le système. Pour obtenir le bon résultat lors du test de la valeur de wParam, une application doit combiner la valeur 0xFFF0 avec la valeur wParam en utilisant le bit à bit ET de l'opérateur." (msdn.microsoft.com/en-us/library/windows/desktop/...) Donc, la comparaison devrait être "(m.WParam.ToInt32() & 0xFFF0) == 0xF030" ou quelque chose de similaire.
- int wParam = (m.WParam.ToInt32() & 0xFFF0); if (wParam == 0xF030 || wParam == 0xF020 || wParam == 0xF120) { DoUpdate(); } a fonctionné pour moi. Aussi, j'ai appelé la base.WndProc(ref m); avant d'être en mesure d'utiliser des mises à jour de la fenêtre paramètres
- Voir Lorenzo réponse à une modification qui s'occupe également de la restauration de l'événement. (Je pense qu'il est utile d'avoir explicitement dans le code de l'échantillon).
- 0xF120 est lors de l'agrandissement de la barre de windows
- fonctionne correctement, quand il est modifié selon la suggestion de Gorkem
InformationsquelleAutor Reed Copsey
59

Surprenant que personne n'a mentionné l'intégré .Méthode NETTE.

De cette façon, vous n'avez pas besoin de remplacer la Fenêtre de Traitement d'un Message de gestionnaire.

Il capture même les agrandir/restaurer les événements causés par des double-cliquant sur la barre de titre de la fenêtre, dont la méthode WndProc ne pas.

Copier ce dans et de le lier à la "Redimensionner" gestionnaire d'événement sur le formulaire.
```
    FormWindowState LastWindowState = FormWindowState.Minimized;
    private void Form1_Resize(object sender, EventArgs e) {

        //When window state changes
        if (WindowState != LastWindowState) {
            LastWindowState = WindowState;


            if (WindowState == FormWindowState.Maximized) {

                //Maximized!
            }
            if (WindowState == FormWindowState.Normal) {

                //Restored!
            }
        }

    }
```
- Merci. Cette solution est tellement plus joli que de descendre à la WinAPI niveau. A beaucoup plus de chances de travailler sur Mono.
- Cette réponse ne traite pas de la question, qui portait sur le fait que l'événement resize n'a même pas de feu dans certaines circonstances.
InformationsquelleAutor Robinicks

Un autre petit plus, afin de vérifier pour la restauration de l'original de la dimension et de la position après la maximisation:

protected override void WndProc(ref Message m)
{
    base.WndProc(ref m);

    //WM_SYSCOMMAND
    if (m.Msg == 0x0112)
    {
        if (m.WParam == new IntPtr(0xF030) //Maximize event - SC_MAXIMIZE from Winuser.h
            || m.WParam == new IntPtr(0xF120)) //Restore event - SC_RESTORE from Winuser.h
        {
            UpdateYourUI();
        }
    }
}

Espérons que cette aide.

InformationsquelleAutor Lorenzo Melato

4

J'ai eu le même problème, et j'ai pu le résoudre sans écraser.
Parce que j'ai un PictureBox dans le dock en mode "Remplissage" je pourrais l'utiliser c'est SizeChanged événement, qui a mis le feu sur la maximisation de la fenêtre.

InformationsquelleAutor 816-8055

Je crois que le code est encore plus simple que cela. Vous n'avez pas besoin d'enregistrer le lastState parce que la WindowState est vérifié à tout moment lorsque l'événement est déclenché.

 private void MainForm_Resize(object sender, EventArgs e)
    {
        if (WindowState == FormWindowState.Maximized)
        {
            spContainer.SplitterDistance = 1000;
        }
        if (WindowState == FormWindowState.Normal)
            spContainer.SplitterDistance = 500;
    }

InformationsquelleAutor Gabriel Marius Popescu

1

Si il n'y a pas de façon évidente de l'événement pour écouter, vous allez probablement avoir besoin de s'accrocher dans l'API Windows et attraper le message approprié (Google tourne jusqu'à ce que vous aurez envie d'intercepter le message WM_SYSCOMMAND: http://www.codeguru.com/forum/archive/index.php/t-234554.html).

InformationsquelleAutor Matt

J'espère que cette partie de code sera utile.

            if (m.Msg == User32.WM_WINDOWPOSCHANGING && IsHandleCreated)
{
User32.WINDOWPLACEMENT wp = new User32.WINDOWPLACEMENT();
wp.length = Marshal.SizeOf(typeof(User32.WINDOWPLACEMENT));
User32.GetWindowPlacement(Handle, ref wp);
switch (wp.showCmd)
{
case User32.SW_RESTORE:
case User32.SW_NORMAL:
case User32.SW_SHOW:
case User32.SW_SHOWNA:
case User32.SW_SHOWNOACTIVATE:
_windState = FormWindowState.Normal;
if (wp.showCmd == User32.SW_RESTORE)
Update();
break;
case User32.SW_SHOWMAXIMIZED:
_windState = FormWindowState.Maximized;
SetMaximumSize();
break;
case User32.SW_SHOWMINIMIZED:
case User32.SW_MINIMIZE:
case User32.SW_SHOWMINNOACTIVE:
_windState = FormWindowState.Minimized;
break;
}
}
private void SetMaximumSize()
{
Screen screen = Screen.FromControl(this);
if (screen != null && !screen.WorkingArea.IsEmpty)
{
int sizeDiff = this.Size.Width - this.ClientSize.Width;
var maxSize = new Size(screen.WorkingArea.Width + sizeDiff, screen.WorkingArea.Height + sizeDiff);
this.MaximumSize = maxSize;
}
}
#region Window State
public const int SW_NORMAL = 1,
SW_SHOWMINIMIZED = 2,
SW_SHOWMAXIMIZED = 3,
SW_SHOWNOACTIVATE = 4,
SW_SHOW = 5,
SW_MINIMIZE = 6,
SW_SHOWMINNOACTIVE = 7,
SW_SHOWNA = 8,
SW_RESTORE = 9;
#endregion Window State

InformationsquelleAutor Track

' Great tip. So if it helps to VisualBasic In Code
Private Const WM_SYSCOMMAND As Integer = &H112
Private Const SC_MAXIMIZE As Integer = &HF030
' # WndProcess 루프함수
Protected Overrides Sub WndProc(ByRef m As Message)
If m.Msg.Equals(WM_SYSCOMMAND) Then
If (m.WParam.ToInt32.Equals(SC_MAXIMIZE)) Then
Me.p_FullScreen()
Return
End If
End If
MyBase.WndProc(m)
End Sub

InformationsquelleAutor Hobis

0

Je suis un newbie donc les commentaires ne sont pas autorisés, mais c'EST un commentaire à la propre réponse par Ciblage géographique:

La première ligne DEVRAIT être légèrement modifié pour accepter les valeurs null, attraper si le formulaire est commencé Réduite:
```
FormWindowState? LastWindowState = null;
```
Et un banal suggestion: Déplacer la cession de LastWindowState à après le "si"s, de sorte que l'utilisateur peut facilement vérifier non seulement ce que vous allez, mais aussi ce qu'il est venu à partir de:
```
FormWindowState? LastWindowState = null;
private void Form1_Resize(object sender, EventArgs e) {
//When window state changes
if (WindowState != LastWindowState) {
if (WindowState == FormWindowState.Maximized) {
//Maximized!
}
if (WindowState == FormWindowState.Normal) {
//Restored!
}
LastWindowState = WindowState;
}
}
```
InformationsquelleAutor Eske Rahn

Vous devez vous connecter pour publier un commentaire.