Un-Antialiased Hand Cursor in Windows Forms Apps

Question

Okay, so you know how in Windows Vista and Windows 7 MS changed the Hand Cursor (the one that shows up when you hover over a hyperlink), and added more detail to it so it's antialiased and nice and smooth around the edges?

Well, why isn't it like that in Windows Forms apps?

I'm sick off looking at a crappy hand cursor that looks like it was drawn by a caveman.

Is there a way to programmatically tell it to display the one that's actually installed in the system? I looked in the Cursors folder in my Windows directory, and the old hand cursor isn't even there! So why is WinForms still using the old one? How can I 'upgrade' it?

Cody Gray - on strike · Answer 1 · 2016-02-23T15:59:44.627

Yes, the WinForms controls still use the old-school hand cursor, as shipped with Windows 98/2000. It lacks the anti-aliasing effects that the one included with the Aero cursors does. This is because the .NET Framework includes its own hard-coded cursor, which it uses instead of the system default. I presume this is because early versions of .NET were targeting operating systems like Windows 95 that didn't come bundled with this cursor, but haven't done the archaeology to prove it.

Fortunately, it's easy enough to force it to use the right one. You just have to tell the operating system you want it to use the default hand cursor, and then it will be correct no matter what version of Windows the user runs your program on, and even if they've changed their mouse cursors from the default theme.

The simplest way of doing that is to subclass the existing control, override the WndProc function to intercept the WM_SETCURSOR message, and tell it to use the system IDC_HAND cursor. You just need a little bit of P/Invoke magic.

The following code is an example of how that might look using the LinkLabel control:

public class LinkLabelEx : LinkLabel
{
    private const int WM_SETCURSOR = 0x0020;
    private const int IDC_HAND = 32649;

    [DllImport("user32.dll", CharSet=CharSet.Auto, SetLastError=true)]
    private static extern IntPtr LoadCursor(IntPtr hInstance, int lpCursorName);

    [DllImport("user32.dll", CharSet=CharSet.Auto)]
    private static extern IntPtr SetCursor(IntPtr hCursor);

    protected override void WndProc(ref Message m)
    {
        if (m.Msg == WM_SETCURSOR)
        {
            // Set the cursor to use the system hand cursor
            SetCursor(LoadCursor(IntPtr.Zero, IDC_HAND));

            // Indicate that the message has been handled
            m.Result = IntPtr.Zero;
            return;
        }

        base.WndProc(ref m);
    }
}

Um. I'm... shocked. Horrified. Confused. Relieved. So, I should sub-class every control in my app that I want to have an antialiased cursor for? Isn't that a little bit overkill? - btw, thanks for the code, it fixed it! :) — βӔḺṪẶⱫŌŔ, May 16 '11 at 12:26
@βӔḺṪẶⱫŌŔ: No. Every other cursor works perfectly. It's *very* rare that a Windows application would need to show a hand cursor. About the only time that's ever used is for a `LinkLabel`. So you only need to create a custom replacement `LinkLabel` control once, and then use it everywhere you want in your app. — Cody Gray - on strike, May 16 '11 at 12:27
yep that's what I meant. But I also have a PictureBox (Client's logo) which upon clicking takes them to their website, so I also display the hand cursor for that aswell — βӔḺṪẶⱫŌŔ, May 16 '11 at 12:32
@βӔḺṪẶⱫŌŔ: Okay, so you have two custom controls. A `CustomLinkLabel` and a `LinkPictureBox`. Doesn't seem that hard to me. I've written enhancements for virtually *all* of the standard controls and re-use them over and over again in all of my projects. — Cody Gray - on strike, May 16 '11 at 12:34

Hamid Sadeghian · Answer 2 · 2015-09-04T22:10:24.447

11

Excuse me for resurrecting a year-old thread!!!

After messing around with the original solution and taking a look at the reflected LinkLabel source code, I "finally" found a quick yet clean way of doing it :

using System.Runtime.InteropServices;

namespace System.Windows.Forms {
    public class LinkLabelEx : LinkLabel {
        private const int IDC_HAND = 32649;

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr LoadCursor(IntPtr hInstance, int lpCursorName);

        private static readonly Cursor SystemHandCursor = new Cursor(LoadCursor(IntPtr.Zero, IDC_HAND));

        protected override void OnMouseMove(MouseEventArgs e) {
            base.OnMouseMove(e);

            // If the base class decided to show the ugly hand cursor
            if(OverrideCursor == Cursors.Hand) {
                // Show the system hand cursor instead
                OverrideCursor = SystemHandCursor;
            }
        }
    }
}

This class actually does what we want: It shows the proper system hand cursor without flickering and does this only on the LinkArea of the control.

edited Sep 04 '15 at 22:10

answered Nov 18 '12 at 11:51

Hamid Sadeghian

494
1
7
11

2

I would suggest not creating a new cursor every time the mouse moves. It seems like an unnecessary memory leak. Instead I'd create a static field that sets a static readonly cursor variable, then reference that when needed. – test May 20 '15 at 21:16
1

You're right. Can't believe I didn't see that... Edited the code to fix it. – Hamid Sadeghian Sep 04 '15 at 22:11
A similar, but better, solution would be to set the cursor in response to the WM_SETCURSOR message. This is what [my answer](http://stackoverflow.com/a/6017174/366904) suggests. There is no reason to do this in response to WM_MOUSEMOVE (OnMouseMove) when there is a perfectly good message specifically for this purpose that the system will only send as needed. – Cody Gray - on strike Jun 02 '16 at 14:01
1

As Hamido-san says, his answer works correctly within the LinkArea of the control, and it also works correctly if the LinkLabel is not AutoSized. The WndProc solution fails both of these tests. – Michael Csikos Dec 09 '16 at 00:37

score 2 · Answer 3 · answered Jan 12 '19 at 18:41

This post solves problems of the other posts:

It respects to the link location and shows the hand just when cursor is on link

It doesn't flicker on mouse move

You need to change the cursor to system hand cursor. To do so, you need to handle WM_SETCURSOR and check if OverrideCursor is Cursors.Hand then change it to the system cursor by calling SetCursor:

using System;
using System.Runtime.InteropServices;
using System.Windows.Forms;
public class MyLinkLabel : LinkLabel
{
    const int IDC_HAND = 32649;
    const int WM_SETCURSOR = 0x0020;
    const int HTCLIENT = 1;
    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    static extern IntPtr LoadCursor(IntPtr hInstance, int lpCursorName);
    [DllImport("user32.dll", ExactSpelling = true, CharSet = CharSet.Auto)]
    static extern IntPtr SetCursor(HandleRef hcursor);
    static readonly Cursor SystemHandCursor = 
        new Cursor(LoadCursor(IntPtr.Zero, IDC_HAND));
    protected override void WndProc(ref Message msg)
    {
        if (msg.Msg == WM_SETCURSOR)
            WmSetCursor(ref msg);
        else
            base.WndProc(ref msg);
    }
    void WmSetCursor(ref Message m)
    {
        if (m.WParam == (IsHandleCreated ? Handle : IntPtr.Zero) &&
           (unchecked((int)(long)m.LParam) & 0xffff) == HTCLIENT) {
            if (OverrideCursor != null) {
                if (OverrideCursor == Cursors.Hand)
                    SetCursor(new HandleRef(SystemHandCursor, SystemHandCursor.Handle));
                else
                    SetCursor(new HandleRef(OverrideCursor, OverrideCursor.Handle));
            }
            else {
                SetCursor(new HandleRef(Cursor, Cursor.Handle));
            }
        }
        else {
            DefWndProc(ref m);
        }
    }
}

score 2 · Answer 4 · answered Jun 26 '19 at 08:36

Sorry for getting this old post back, but i also have some kind of solution for this. If you need to apply the systemcursor application wide without touching old controls, use this at applicationstart:

    private static void TrySetCursorsDotHandToSystemHandCursor()
    {
        try
        {
            typeof(Cursors).GetField("hand", BindingFlags.Static | BindingFlags.NonPublic)
                           .SetValue(null, SystemHandCursor);
        }
        catch { }
    }

    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    private static extern IntPtr LoadCursor(IntPtr hInstance, int lpCursorName);

    private static readonly Cursor SystemHandCursor = new Cursor(LoadCursor(IntPtr.Zero, 32649 /*IDC_HAND*/));

Great minimal code solution. For newbies that's in the `Program.cs` file in Visual Studio. — Jonas, Apr 05 '20 at 14:56

ProFoxyfy · Answer 5 · 2021-05-10T11:38:27.940

Doing that without creating a new control wee need to change the Control's Cursor AND create a custom linklabel or else it wouldn't work we create the custom linklabel by adding a label changing the font underline and changing it's fore color and add an click event

Private Const IDC_HAND As Integer = 32649

<DllImport("user32.dll", CharSet:=CharSet.Auto, SetLastError:=True)>
Private Shared Function LoadCursor(ByVal hInstance As IntPtr, ByVal lpCursorName As Integer) As IntPtr
End Function

Private Shared ReadOnly SystemHandCursor As Cursor = New Cursor(LoadCursor(IntPtr.Zero, IDC_HAND))
    
'add the cursor to custom linklabel
CustomLinkLabel1.Cursor = SystemHandCursor

sorry only have vb .net code you might use an online converter EDIT: some code was missing

Un-Antialiased Hand Cursor in Windows Forms Apps

5 Answers5

Linked

Related