Windows 7触摸屏长按延迟求助：程序长按标签功能受系统延迟干扰

Hey Joe, let's tackle this touch delay issue you're facing. I've run into similar problems with Windows' built-in touch pre-processing before, so here's a breakdown of what's happening and actionable fixes:

Why the Delay Happens #

Even if you've disabled the touchscreen's native long-press feature, Windows has a system-level input delay built in to distinguish between a tap, drag, and long-press. This pre-processing can introduce lag that your Timer-based code can't bypass on its own.

Solutions to Try #

1. Fix Your Timer Logic First (Basic Improvement) #

Your current code starts the Timer on press, but doesn't stop it if the user lifts their finger early. This isn't the root cause of the delay, but it's a critical bug. Update your code to handle MouseUp/TouchUp events:

private Timer _timer;

private void ltitellongpress(object sender, MouseEventArgs e) 
{ 
    _timer = new Timer(); 
    _timer.Interval = 2500; 
    _timer.Tick += Do_Something; 
    _timer.Start(); 
}

// Add this event handler for MouseUp/TouchUp
private void ltitellongpress_Up(object sender, MouseEventArgs e)
{
    _timer?.Stop();
    _timer?.Dispose();
    _timer = null;
}

private void Do_Something(object sender, EventArgs e) 
{ 
    _timer.Stop();
    _timer.Dispose();
    _timer = null;
    // Execute your long-press logic here
    MessageBox.Show("Long press triggered!");
}

2. Bypass Windows Touch Pre-Processing with Raw Input #

To eliminate system-level delay, use Windows API to handle raw touch input directly. This skips Windows' built-in tap/long-press detection:

Step 1: Declare Required Native Methods

Add these to your form class (or a separate utility class):

[DllImport("user32.dll")]
private static extern bool RegisterTouchWindow(IntPtr hWnd, uint ulFlags);

private const int WM_TOUCH = 0x0240;
private const uint TOUCH_FEEDBACK_DEFAULT = 0x00000000;

protected override void OnHandleCreated(EventArgs e)
{
    base.OnHandleCreated(e);
    // Register the form for raw touch input
    RegisterTouchWindow(this.Handle, TOUCH_FEEDBACK_DEFAULT);
}

Step 2: Override WndProc to Handle Raw Touch Messages

protected override void WndProc(ref Message m)
{
    switch (m.Msg)
    {
        case WM_TOUCH:
            HandleTouchMessage(ref m);
            break;
        default:
            base.WndProc(ref m);
            break;
    }
}

private void HandleTouchMessage(ref Message m)
{
    // Parse touch input data (simplified example)
    int inputCount = m.WParam.ToInt32() & 0xFFFF;
    IntPtr touchInputs = m.LParam;
    
    // Track touch start/end times with Stopwatch instead of Timer
    // This gives you precise control without system delay
    for (int i = 0; i < inputCount; i++)
    {
        var touchInput = Marshal.PtrToStructure<TouchInput>(touchInputs);
        if ((touchInput.dwFlags & TouchInputFlags.TOUCHEVENTF_DOWN) != 0)
        {
            // Start tracking this touch point
            var stopwatch = new Stopwatch();
            stopwatch.Start();
            // Store stopwatch and touch ID in a dictionary for later
            _activeTouches.Add(touchInput.dwID, stopwatch);
        }
        else if ((touchInput.dwFlags & TouchInputFlags.TOUCHEVENTF_UP) != 0)
        {
            if (_activeTouches.TryGetValue(touchInput.dwID, out var stopwatch))
            {
                stopwatch.Stop();
                if (stopwatch.ElapsedMilliseconds >= 2500)
                {
                    Do_Something(null, EventArgs.Empty);
                }
                _activeTouches.Remove(touchInput.dwID);
            }
        }
        touchInputs = (IntPtr)(touchInputs.ToInt64() + Marshal.SizeOf<TouchInput>());
    }
    m.Result = (IntPtr)1; // Acknowledge the message
}

// Required structures/enums for touch input
[StructLayout(LayoutKind.Sequential)]
private struct TouchInput
{
    public int x;
    public int y;
    public IntPtr hSource;
    public int dwID;
    public int dwFlags;
    public int dwMask;
    public int dwTime;
    public IntPtr dwExtraInfo;
    public int cxContact;
    public int cyContact;
}

[Flags]
private enum TouchInputFlags
{
    TOUCHEVENTF_MOVE = 0x0001,
    TOUCHEVENTF_DOWN = 0x0002,
    TOUCHEVENTF_UP = 0x0004,
    TOUCHEVENTF_INRANGE = 0x0008,
    TOUCHEVENTF_PRIMARY = 0x0010,
    TOUCHEVENTF_NOCOALESCE = 0x0020,
    TOUCHEVENTF_PEN = 0x0040,
    TOUCHEVENTF_PALM = 0x0080
}

private Dictionary<int, Stopwatch> _activeTouches = new Dictionary<int, Stopwatch>();

3. Adjust System-Level Touch Settings #

If raw input feels too heavy-handed, tweak Windows touch settings to reduce delay:

• Go to Settings > Devices > Touch > Touch sensitivity and set it to "Most sensitive".
• Use Registry Editor to modify touch delay:
  1. Open regedit and navigate to HKEY_CURRENT_USER\Software\Microsoft\Wisp\Touch
  2. Create a new DWORD value named TouchDelay and set it to 0 (decimal)
  3. Restart your application (or the system) for changes to take effect.

4. Use a High-Precision Timer #

Instead of WinForms' Timer (which is tied to the UI message loop), use System.Diagnostics.Stopwatch for precise timing, or System.Timers.Timer (which runs on a separate thread) if your logic doesn't need to update the UI directly.

Let me know if you run into issues with any of these steps—happy to help refine the code!

内容的提问来源于stack exchange，提问作者Joe McNally