Comment suspendre le dessin pour un contrôle et ses enfants?

Question

J'ai un contrôle sur lequel je dois apporter de grandes modifications. J'aimerais complètement l'empêcher de se redessiner pendant que je le fais - SuspendLayout et ResumeLayout ne suffisent pas. Comment suspendre le dessin pour un contrôle et ses enfants?

Answer 1

À mon ancien travail, nous avons eu du mal à faire en sorte que notre application riche en UI se peigne instantanément et en douceur. Nous utilisions des contrôles standard .Net, des contrôles personnalisés et des contrôles devexpress.

Après beaucoup de recherches sur Google et l'utilisation de Reflector, j'ai découvert le message WM_SETREDRAW de win32. Cela arrête vraiment le dessin des contrôles pendant que vous les mettez à jour et peut être appliqué, si je me souviens bien, au panneau parent/conteneur.

Il s'agit d'une classe très simple montrant comment utiliser ce message :

class DrawingControl
{
    [DllImport("user32.dll")]
    public static extern int SendMessage(IntPtr hWnd, Int32 wMsg, bool wParam, Int32 lParam);

    private const int WM_SETREDRAW = 11; 

    public static void SuspendDrawing( Control parent )
    {
        SendMessage(parent.Handle, WM_SETREDRAW, false, 0);
    }

    public static void ResumeDrawing( Control parent )
    {
        SendMessage(parent.Handle, WM_SETREDRAW, true, 0);
        parent.Refresh();
    }
}

Il y a des discussions plus détaillées à ce sujet - cherchez sur Google "C# and WM_SETREDRAW", par exemple.

C# Jitter

Suspension des mises en page

Et pour ceux que cela intéresse, voici un exemple similaire en VB :

Public Module Extensions

    Private Function SendMessage(ByVal hWnd As IntPtr, ByVal Msg As Integer, ByVal wParam As Boolean, ByVal lParam As IntPtr) As Integer
    End Function

    Private Const WM_SETREDRAW As Integer = 11

    ' Méthodes d'extension pour Control

    Public Sub ResumeDrawing(ByVal Target As Control, ByVal Redraw As Boolean)
        SendMessage(Target.Handle, WM_SETREDRAW, True, IntPtr.Zero)
        If Redraw Then
            Target.Refresh()
        End If
    End Sub

    Public Sub SuspendDrawing(ByVal Target As Control)
        SendMessage(Target.Handle, WM_SETREDRAW, False, IntPtr.Zero)
    End Sub

    Public Sub ResumeDrawing(ByVal Target As Control)
        ResumeDrawing(Target, True)
    End Sub
End Module

Answer 2

La solution suivante est la même que ng5000 mais ne utilise pas P/Invoke.

public static class SuspendUpdate
{
    private const int WM_SETREDRAW = 0x000B;

    public static void Suspend(Control control)
    {
        Message msgSuspendUpdate = Message.Create(control.Handle, WM_SETREDRAW, IntPtr.Zero,
            IntPtr.Zero);

        NativeWindow window = NativeWindow.FromHandle(control.Handle);
        window.DefWndProc(ref msgSuspendUpdate);
    }

    public static void Resume(Control control)
    {
        // Créer un boolean "true" en C comme un IntPtr
        IntPtr wparam = new IntPtr(1);
        Message msgResumeUpdate = Message.Create(control.Handle, WM_SETREDRAW, wparam,
            IntPtr.Zero);

        NativeWindow window = NativeWindow.FromHandle(control.Handle);
        window.DefWndProc(ref msgResumeUpdate);

        control.Invalidate();
    }
}

Answer 3

J'utilise généralement une version légèrement modifiée de la réponse de ngLink.

public class MyControl : Control
{
    private int suspendCounter = 0;

    private void SuspendDrawing()
    {
        if(suspendCounter == 0) 
            SendMessage(this.Handle, WM_SETREDRAW, false, 0);
        suspendCounter++;
    }

    private void ResumeDrawing()
    {
        suspendCounter--; 
        if(suspendCounter == 0) 
        {
            SendMessage(this.Handle, WM_SETREDRAW, true, 0);
            this.Refresh();
        }
    }
}

Cela permet d'emboîter les appels de suspension/reprise. Vous devez vous assurer de faire correspondre chaque SuspendDrawing avec un ResumeDrawing. Par conséquent, il ne serait probablement pas une bonne idée de les rendre publics.

Answer 4

Une belle solution sans utiliser l'interop :

Comme toujours, il suffit d'activer DoubleBuffered=true sur votre CustomControl. Ensuite, si vous avez des conteneurs comme FlowLayoutPanel ou TableLayoutPanel, dérivez une classe de chacun de ces types et, dans les constructeurs, activez le double buffering. Maintenant, utilisez simplement vos Conteneurs dérivés au lieu des Conteneurs Windows.Forms.

class TableLayoutPanel : System.Windows.Forms.TableLayoutPanel
{
    public TableLayoutPanel()
    {
        DoubleBuffered = true;
    }
}

class FlowLayoutPanel : System.Windows.Forms.FlowLayoutPanel
{
    public FlowLayoutPanel()
    {
        DoubleBuffered = true;
    }
}

Answer 5

Voici une combinaison des contributions de ceztko et ng5000 pour apporter une version des extensions VB qui n'utilise pas pinvoke

Imports System.Runtime.CompilerServices

Module ControlExtensions

Dim WM_SETREDRAW As Integer = 11

''' 
''' Un "SuspendLayout" plus fort qui bloque complètement le dessin des contrôles jusqu'à ce que ResumePaint soit appelé
''' 
''' 
''' 

Public Sub SuspendPaint(ByVal ctrl As Windows.Forms.Control)

    Dim msgSuspendUpdate As Windows.Forms.Message = Windows.Forms.Message.Create(ctrl.Handle, WM_SETREDRAW, System.IntPtr.Zero, System.IntPtr.Zero)

    Dim window As Windows.Forms.NativeWindow = Windows.Forms.NativeWindow.FromHandle(ctrl.Handle)

    window.DefWndProc(msgSuspendUpdate)

End Sub

''' 
''' Reprendre à partir de la méthode SuspendPaint
''' 
''' 
''' 

Public Sub ResumePaint(ByVal ctrl As Windows.Forms.Control)

    Dim wparam As New System.IntPtr(1)
    Dim msgResumeUpdate As Windows.Forms.Message = Windows.Forms.Message.Create(ctrl.Handle, WM_SETREDRAW, wparam, System.IntPtr.Zero)

    Dim window As Windows.Forms.NativeWindow = Windows.Forms.NativeWindow.FromHandle(ctrl.Handle)

    window.DefWndProc(msgResumeUpdate)

    ctrl.Invalidate()

End Sub

End Module