How to programmatic disable C# Console Application's Quick Edit mode?

Question

I've tried several solutions found, like the one ->

http://www.pcreview.co.uk/forums/console-writeline-hangs-if-user-click-into-console-window-t1412701.html

But, I observed that mode in GetConsoleMode(IntPtr hConsoleHandle, out int mode) will be different for different console app. It is not constant.

Can I disable mouse clicks (right/left buttons) on a console application to achieve the same scenario. I found that it can be done with IMessageFilter but only for Window Form Application and not for console application.

It's off by default from what I know, if the user wants to enable it then who are you to tell them differently? — M.Babcock, Dec 01 '12 at 06:04
Actually, the same scenario happened yesterday, when one of our console based C# application that act as a server goes LIVE. Some one from implementation team may has mistakenly turn on quick edit mode & than click on window too unintentionally. That freezes the UI thread. It took 2 hours of hustle before actually finding out that problem wasn't technical. :) — Himanshu, Dec 01 '12 at 07:06

Patrick from NDepend team · Answer 1 · 2016-04-19T14:24:07.797

For those like me that like no-brainer code to copy/paste, here is the code inspired from the accepted answer:

using System;
using System.Runtime.InteropServices;

static class DisableConsoleQuickEdit {

   const uint ENABLE_QUICK_EDIT = 0x0040;

   // STD_INPUT_HANDLE (DWORD): -10 is the standard input device.
   const int STD_INPUT_HANDLE = -10;

   [DllImport("kernel32.dll", SetLastError = true)]
   static extern IntPtr GetStdHandle(int nStdHandle);

   [DllImport("kernel32.dll")]
   static extern bool GetConsoleMode(IntPtr hConsoleHandle, out uint lpMode);

   [DllImport("kernel32.dll")]
   static extern bool SetConsoleMode(IntPtr hConsoleHandle, uint dwMode);

   internal static bool Go() {

      IntPtr consoleHandle = GetStdHandle(STD_INPUT_HANDLE);

      // get current console mode
      uint consoleMode;
      if (!GetConsoleMode(consoleHandle, out consoleMode)) {
         // ERROR: Unable to get console mode.
         return false;
      }

      // Clear the quick edit bit in the mode flags
      consoleMode &= ~ENABLE_QUICK_EDIT;

      // set the new mode
      if (!SetConsoleMode(consoleHandle, consoleMode)) {
         // ERROR: Unable to set console mode
         return false;
      }

      return true;
   }
}

Here's a Python equivalent if one needs it: https://stackoverflow.com/a/76855923/15016163 — Maicon Mauricio, Aug 08 '23 at 01:15

Jim Mischel · Accepted Answer · 2012-12-01T06:37:16.380

18

If you want to disable quick edit mode, you need to call GetConsoleMode to get the current mode. Then clear the bit that enables quick edit, and call SetConsoleMode. Assuming you have the managed prototypes for the unmanaged functions, you would write:

const int ENABLE_QUICK_EDIT = 0x0040;

IntPtr consoleHandle = GetConsoleWindow();
UInt32 consoleMode;

// get current console mode
if (!GetConsoleMode(consoleHandle, out consoleMode))
{
    // Error: Unable to get console mode.
    return;
}

// Clear the quick edit bit in the mode flags
mode &= ~ENABLE_QUICK_EDIT;

// set the new mode
if (!SetConsoleMode(consoleHandle, consoleMode))
{
    // ERROR: Unable to set console mode
}

If you want to disable mouse input, you want to clear the mouse input bit.

const int ENABLE_MOUSE_INPUT = 0x0010;

mode &= ~ENABLE_MOUSE_INPUT;

edited Dec 01 '12 at 06:37

answered Dec 01 '12 at 06:09

Jim Mischel

131,090
20
188
351

@M.Babcock: Yes, that's what the linked code *attempts* to do. But the linked code is getting the standard input handle rather than the console window handle (might be different). It also hard-codes a console mode, which could change many different settings. This code changes only the one setting. – Jim Mischel Dec 01 '12 at 06:29
@Jim Mischel - using IntPtr consoleHandle = GetConsoleWindow() leads to fall under if condition and than returned. So i used public const int STD_INPUT_HANDLE = -10; IntPtr handle = GetStdHandle(STD_INPUT_HANDLE); GetConsoleMode(handle, out consoleMode) to get the mode. Is there any thing i am missing ? – Himanshu Dec 01 '12 at 07:12
It's a little bit ago, but some little additional hint: [Source](https://blogs.msdn.microsoft.com/oldnewthing/20130506-00/?p=4453/) has important information: for Disableing QuickEdit Mode, the Extended Flag MUST be set on SetConsole. If you call SetConsole without QUICK & without EXTENDED : the flag change, but quickedit is still enabled. To Disable: mode &= ~ENABLE_QUICK_EDIT; mode |= ENABLE_EXTENDED_FLAGS; – Gabor Oct 07 '17 at 08:34
@JimMischel I am not the one who down-voted this. But, I think there is a tiny typo in your code: the line `mode &= ~ENABLE_QUICK_EDIT;` I think should be `consoleMode &= ...`. You might want to correct that. – David I. McIntosh Aug 25 '23 at 22:15

Mirco Babin · Answer 3 · 2018-11-20T11:28:44.970

Having read above answers, GetConsoleWindow() can not be used. Instead GetStdHandle() must be used.

So here's a copy and paste class for enabling/disabling QuickEditMode. Call ConsoleWindow.QuickEditMode(false); to disable quick edit mode for the console window.

using System;
using System.Runtime.InteropServices;

public static class ConsoleWindow
{
    private static class NativeFunctions
    {
        public enum StdHandle : int
        {
            STD_INPUT_HANDLE = -10,
            STD_OUTPUT_HANDLE = -11,
            STD_ERROR_HANDLE = -12,
        }

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern IntPtr GetStdHandle(int nStdHandle); //returns Handle

        public enum ConsoleMode : uint
        {
            ENABLE_ECHO_INPUT = 0x0004,
            ENABLE_EXTENDED_FLAGS = 0x0080,
            ENABLE_INSERT_MODE = 0x0020,
            ENABLE_LINE_INPUT = 0x0002,
            ENABLE_MOUSE_INPUT = 0x0010,
            ENABLE_PROCESSED_INPUT = 0x0001,
            ENABLE_QUICK_EDIT_MODE = 0x0040,
            ENABLE_WINDOW_INPUT = 0x0008,
            ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200,

            //screen buffer handle
            ENABLE_PROCESSED_OUTPUT = 0x0001,
            ENABLE_WRAP_AT_EOL_OUTPUT = 0x0002,
            ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004,
            DISABLE_NEWLINE_AUTO_RETURN = 0x0008,
            ENABLE_LVB_GRID_WORLDWIDE = 0x0010
        }

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool GetConsoleMode(IntPtr hConsoleHandle, out uint lpMode);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool SetConsoleMode(IntPtr hConsoleHandle, uint dwMode);
    }

    public static void QuickEditMode(bool Enable)
    {
        //QuickEdit lets the user select text in the console window with the mouse, to copy to the windows clipboard.
        //But selecting text stops the console process (e.g. unzipping). This may not be always wanted.
        IntPtr consoleHandle = NativeFunctions.GetStdHandle((int)NativeFunctions.StdHandle.STD_INPUT_HANDLE);
        UInt32 consoleMode;

        NativeFunctions.GetConsoleMode(consoleHandle, out consoleMode);
        if (Enable)
            consoleMode |= ((uint)NativeFunctions.ConsoleMode.ENABLE_QUICK_EDIT_MODE);
        else
            consoleMode &= ~((uint)NativeFunctions.ConsoleMode.ENABLE_QUICK_EDIT_MODE);

        consoleMode |= ((uint)NativeFunctions.ConsoleMode.ENABLE_EXTENDED_FLAGS);

        NativeFunctions.SetConsoleMode(consoleHandle, consoleMode);
    }
}

score 1 · Answer 4 · answered Jul 12 '21 at 19:32

For those who use vb.net

Const ENABLE_QUICK_EDIT As UInteger = &H40
Const STD_INPUT_HANDLE As Integer = -10


   <DllImport("kernel32.dll", SetLastError:=True)>
Public Function GetStdHandle(ByVal nStdHandle As Integer) As IntPtr
End Function

<DllImport("kernel32.dll")>
Private Function GetConsoleMode(ByVal hConsoleHandle As IntPtr, <Out> ByRef lpMode As UInteger) As Boolean
End Function

<DllImport("kernel32.dll")>
Private Function SetConsoleMode(ByVal hConsoleHandle As IntPtr, ByVal dwMode As UInteger) As Boolean
End Function 

    Friend Function Go() As Boolean
    Dim consoleHandle As IntPtr = GetStdHandle(STD_INPUT_HANDLE)
    Dim consoleMode As UInteger

    If Not GetConsoleMode(consoleHandle, consoleMode) Then
        Return False
    End If

    consoleMode = consoleMode And Not ENABLE_QUICK_EDIT

    If Not SetConsoleMode(consoleHandle, consoleMode) Then
        Return False
    End If

    Return True
End Function

sub main()
go()
end sub

But the question is about C#. – Jeremy Caney Jul 13 '21 at 05:31 — Jeremy Caney, Jul 13 '21 at 05:31
But this answer is for those who use vb.net – Jan 13 '22 at 17:36 — , Jan 13 '22 at 17:36

score 0 · Answer 5 · answered Oct 30 '15 at 18:06

By used combination of codes on below, I'm be able to enable or disable the Quick Edit mode.

const int ENABLE_QUICK_EDIT = 0x0040;

// STD_INPUT_HANDLE (DWORD): -10 is the standard input device.
const int STD_INPUT_HANDLE = -10;

[DllImport("kernel32.dll", SetLastError = true)]
static extern IntPtr GetStdHandle(int nStdHandle);

[DllImport("kernel32.dll")]
static extern bool GetConsoleMode(IntPtr hConsoleHandle, out int lpMode);

[DllImport("kernel32.dll")]
static extern bool SetConsoleMode(IntPtr hConsoleHandle, int dwMode);

To enable, simple do currentConsoleMode &= ENABLE_QUICK_EDIT;

And to disable, do currentConsoleMode &= ~ENABLE_QUICK_EDIT

And then call SetConsoleMode.

score -1 · Answer 6 · answered Jan 22 '19 at 12:02

I just happened to stumble over the same problem with quick edit mode enabled in my console application, which is written in C, and has been working under windows 7 32 bit for ages. After porting (well not really porting, but adapting some code lines) it to windows 10 64 Bit (still being a 32 bit application), I observed the same behaviour. So I searched for a solution.

But for a reason unknown to me, the code works the other way round, i.e setting the bit ENABLE_QUICK_EDIT_MODE in the mode parameter actually disables quick edit mode. And resetting the bit enables the quick edit mode...???

Here is my code:

    /// <summary>
/// This flag enables the user to use the mouse to select and edit text. To enable
/// this option, you must also set the ExtendedFlags flag.
/// </summary>
const int QuickEditMode = 64;

// ExtendedFlags must be combined with
// InsertMode and QuickEditMode when setting
/// <summary>
/// ExtendedFlags must be enabled in order to enable InsertMode or QuickEditMode.
/// </summary>
const int ExtendedFlags = 128;

BOOLEAN EnableQuickEdit()
{
    HWND conHandle = GetStdHandle(STD_INPUT_HANDLE);
    int mode;
    DWORD dwLastError = GetLastError();
    if (!GetConsoleMode(conHandle, &mode))
    {
        // error getting the console mode. Exit.
        dwLastError = GetLastError();
        return (dwLastError == 0);
    }
    else 
        dwLastError = 0;
    mode = mode & ~QuickEditMode;

    if (!SetConsoleMode(conHandle, mode | ExtendedFlags))
    {
        // error setting console mode.
        dwLastError = GetLastError();
    }
    else
        dwLastError = 0;
    return (dwLastError == 0);
}

BOOLEAN DisableQuickEdit()
{
    HWND conHandle = GetStdHandle(STD_INPUT_HANDLE);
    int mode;
    DWORD dwLastError = GetLastError();

    if (!GetConsoleMode(conHandle, &mode))
    {
        // error getting the console mode. Exit.
        dwLastError = GetLastError();
        return (dwLastError == 0);
    }
    else
        dwLastError = 0;

    mode = mode | QuickEditMode;

    if (!SetConsoleMode(conHandle, mode))
    {
        // error getting the console mode. Exit.
        dwLastError = GetLastError();
    }
    else
        dwLastError = 0;
    return (dwLastError == 0);
}

Greetings Wolfgang

How to programmatic disable C# Console Application's Quick Edit mode?

6 Answers6

Linked