API Proposal: Add IDeviceContext to events that hold Graphics

[JeremyKuhne]

Proposal

Add IDeviceContext to all Windows Forms EventArgs that wrap a System.Drawing.Graphics.

• PaintEventArgs
• DrawItemEventArgs
• DataGridViewRowPostPaintEventArgs
• DrawListViewItemEventArgs
• DrawToolTipEventArgs
• DrawTreeNodeEventArgs
• ToolStripArrowRenderEventArgs
• ToolStripContentPanelRenderEventArgs
• ToolStripItemRenderEventArgs
• ToolStripPanelRenderEventArgs
• ToolStripRenderEventArgs

namespace System.Windows.Forms
{
    public class PaintEventArgs : EventArgs, IDisposable, IDeviceContext
    {
        IntPtr IDeviceContext.GetHdc() => Graphics?.GetHdc() ?? IntPtr.Zero;
        void IDeviceContext.ReleaseHdc() => Graphics?.ReleaseHdc();
    }

    public class DrawItemEventArgs: EventArgs, IDeviceContext
    {
        IntPtr IDeviceContext.GetHdc() => Graphics?.GetHdc() ?? IntPtr.Zero;
        void IDeviceContext.ReleaseHdc() => Graphics?.ReleaseHdc();

        void IDisposable.Dispose()
        {
            // IDeviceContext derives from IDisposable. We will not dispose of the contained Graphics
            // as we historically did not take ownership of it.
        }
    }
}

Justification

Windows Forms was designed around GDI+, which System.Drawing is a wrapper around. Graphics was the primary abstraction. Performance of GDI+ wasn't sufficient and internally a number of code paths were changed to utilize the GDI HDC. Graphics exposes the HDC via the IDeviceContext interface, which WinForms uses internally and also exposes on public APIs (see VisualStyleRenderer and TextRenderer).

Exposing IDeviceContext allows us to stop unwrapping event args and allows us to extract the HDC with internal optimizations:

• Internal state info on the event args allows us to know that we don't need to apply state or create a Graphics object if we haven't already.
• It also allows end users to pass event args back into IDeviceContext APIs without retrieving Graphics, which can create Graphics or force us to apply it's (likely unchanged) state.

Implementation Details

We'll explicitly implement IDeviceContext to avoid having the methods directly visible on the event args. The only real benefit is treating the event args as an IDeviceContext object.

On event args where we don't already have IDisposable we'll explicitly define IDisposable.Dispose() and we will not dispose passed in arguments (notably Graphics).

[JeremyKuhne]

How the smuggling works:

namespace System.Windows.Forms
{
    public class PaintEventArgs : EventArgs, IDeviceContext, IInternalInterface {}

    public class SomeControl : Control
    {
         protected override void OnPaint(PaintEventArgs e)
         {
              RendererHelper.DrawThing(e);
         }
    }

    internal static class RendererHelper
    {
        internal static void DrawThing(IDeviceContext context)
        {
             if (context is IInternalInterface internals) ...
        }
    }
}

[terrajobst]

Video

• We should implement IDisposable following the dispose pattern if (1) the type doesn't already implement IDisposable and (2) the type isn't sealed.
• IDeviceContext should be implemented explicitly.

namespace System.Windows.Forms
{
    public partial class PaintEventArgs : IDisposable, IDeviceContext
    { 
    }
    public partial class DrawItemEventArgs : IDisposable, IDeviceContext
    { 
    }
    public partial class DataGridViewRowPostPaintEventArgs : IDisposable, IDeviceContext
    { 
    }
    public partial class DrawListViewItemEventArgs : IDisposable, IDeviceContext
    { 
    }
    public partial class DrawToolTipEventArgs : IDisposable, IDeviceContext
    { 
    }
    public partial class DrawTreeNodeEventArgs : IDisposable, IDeviceContext
    { 
    }
    public partial class ToolStripArrowRenderEventArgs : IDisposable, IDeviceContext
    { 
    }
    public partial class ToolStripContentPanelRenderEventArgs : IDisposable, IDeviceContext
    { 
    }
    public partial class ToolStripItemRenderEventArgs : IDisposable, IDeviceContext
    { 
    }
    public partial class ToolStripPanelRenderEventArgs : IDisposable, IDeviceContext
    { 
    }
    public partial class ToolStripRenderEventArgs : IDisposable, IDeviceContext
    { 
    }
}

[weltkante]

We should implement IDisposable following the dispose pattern

Even if you make it public instead of explicit it still should not dispose the contained Graphics instance as the EventArgs instance doesn't own the Graphics instance.

[JeremyKuhne]

Even if you make it public instead of explicit it still should not dispose the contained Graphics instance as the EventArgs instance doesn't own the Graphics instance.

Yes, and I comment on that in the original description. We never dispose passed in Graphics objects.

[RussKie]

Resolved in #3553