Show touch keyboard (TabTip.exe) in Windows 10 Anniversary edition

Question

In Windows 8 and Windows 10 before Anniversary update it was possible to show touch keyboard by starting

C:\Program Files\Common Files\microsoft shared\ink\TabTip.exe

It no longer works in Windows 10 Anniversary update; the TabTip.exe process is running, but the keyboard is not shown.

Is there a way to show it programmatically?

UPDATE

I found a workaround - fake mouse click on touch keyboard icon in system tray. Here is code in Delphi

// Find tray icon window
function FindTrayButtonWindow: THandle;
var
  ShellTrayWnd: THandle;
  TrayNotifyWnd: THandle;
begin
  Result := 0;
  ShellTrayWnd := FindWindow('Shell_TrayWnd', nil);
  if ShellTrayWnd > 0 then
  begin
    TrayNotifyWnd := FindWindowEx(ShellTrayWnd, 0, 'TrayNotifyWnd', nil);
    if TrayNotifyWnd > 0 then
    begin
      Result := FindWindowEx(TrayNotifyWnd, 0, 'TIPBand', nil);
    end;
  end;
end;

// Post mouse click messages to it
TrayButtonWindow := FindTrayButtonWindow;
if TrayButtonWindow > 0 then
begin
  PostMessage(TrayButtonWindow, WM_LBUTTONDOWN, MK_LBUTTON, $00010001);
  PostMessage(TrayButtonWindow, WM_LBUTTONUP, 0, $00010001);
end;

UPDATE 2

Another thing I found is that setting this registry key restores old functionality when starting TabTip.exe shows touch keyboard

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\TabletTip\1.7\EnableDesktopModeAutoInvoke=1

Solution 1

OK, I reverse engineered what explorer does when the user presses that button in the system tray.

Basically it creates an instance of an undocumented interface ITipInvocation and calls its Toggle(HWND) method, passing desktop window as an argument. As the name suggests, the method either shows or hides the keyboard depending on its current state.

Please note that explorer creates an instance of ITipInvocation on every button click. So I believe the instance should not be cached. I also noticed that explorer never calls Release() on the obtained instance. I'm not too familiar with COM, but this looks like a bug.

I tested this in Windows 8.1, Windows 10 & Windows 10 Anniversary Edition and it works perfectly. Here's a minimal example in C that obviously lacks some error checks.

#include <initguid.h>
#include <Objbase.h>
#pragma hdrstop

// 4ce576fa-83dc-4F88-951c-9d0782b4e376
DEFINE_GUID(CLSID_UIHostNoLaunch,
    0x4CE576FA, 0x83DC, 0x4f88, 0x95, 0x1C, 0x9D, 0x07, 0x82, 0xB4, 0xE3, 0x76);

// 37c994e7_432b_4834_a2f7_dce1f13b834b
DEFINE_GUID(IID_ITipInvocation,
    0x37c994e7, 0x432b, 0x4834, 0xa2, 0xf7, 0xdc, 0xe1, 0xf1, 0x3b, 0x83, 0x4b);

struct ITipInvocation : IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Toggle(HWND wnd) = 0;
};

int WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    HRESULT hr;
    hr = CoInitialize(0);

    ITipInvocation* tip;
    hr = CoCreateInstance(CLSID_UIHostNoLaunch, 0, CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER, IID_ITipInvocation, (void**)&tip);
    tip->Toggle(GetDesktopWindow());
    tip->Release();
    return 0;
}

Here's the C# version as well:

class Program
{
    static void Main(string[] args)
    {
        var uiHostNoLaunch = new UIHostNoLaunch();
        var tipInvocation = (ITipInvocation)uiHostNoLaunch;
        tipInvocation.Toggle(GetDesktopWindow());
        Marshal.ReleaseComObject(uiHostNoLaunch);
    }

    [ComImport, Guid("4ce576fa-83dc-4F88-951c-9d0782b4e376")]
    class UIHostNoLaunch
    {
    }

    [ComImport, Guid("37c994e7-432b-4834-a2f7-dce1f13b834b")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    interface ITipInvocation
    {
        void Toggle(IntPtr hwnd);
    }

    [DllImport("user32.dll", SetLastError = false)]
    static extern IntPtr GetDesktopWindow();
}

Update: per @EugeneK comments, I believe that tabtip.exe is the COM server for the COM component in question, so if your code gets REGDB_E_CLASSNOTREG, it should probably run tabtip.exe and try again.

Solution 2

I had the same problem too. It took me much time and headache, but Thanks to Alexei and Torvin I finally got it working on Win 10 1709. Visibility check was the difficulty. Maybe The OSKlib Nuget could be updated. Let me sum up the complete sulotion (For sure my code has some unnecessary lines now):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.ComponentModel;

using Osklib.Interop;
using System.Runtime.InteropServices;
using System.Threading;

namespace OSK
{
    public static class OnScreenKeyboard
    {
        static OnScreenKeyboard()
        {
            var version = Environment.OSVersion.Version;
            switch (version.Major)
            {
                case 6:
                    switch (version.Minor)
                    {
                        case 2:
                            // Windows 10 (ok)
                            break;
                    }
                    break;
                default:
                    break;
            }
        }

        private static void StartTabTip()
        {
            var p = Process.Start(@"C:\Program Files\Common Files\Microsoft Shared\ink\TabTip.exe");
            int handle = 0;
            while ((handle = NativeMethods.FindWindow("IPTIP_Main_Window", "")) <= 0)
            {
                Thread.Sleep(100);
            }
        }

        public static void ToggleVisibility()
        {
            var type = Type.GetTypeFromCLSID(Guid.Parse("4ce576fa-83dc-4F88-951c-9d0782b4e376"));
            var instance = (ITipInvocation)Activator.CreateInstance(type);
            instance.Toggle(NativeMethods.GetDesktopWindow());
            Marshal.ReleaseComObject(instance);
        }

        public static void Show()
        {
            int handle = NativeMethods.FindWindow("IPTIP_Main_Window", "");
            if (handle <= 0) // nothing found
            {
                StartTabTip();                
                Thread.Sleep(100);                
            }
            // on some devices starting TabTip don't show keyboard, on some does  ¯\_(ツ)_/¯
            if (!IsOpen())
            {
                ToggleVisibility();
            }
        }

        public static void Hide()
        {
            if (IsOpen())
            {
                ToggleVisibility();
            }
        }        


        public static bool Close()
        {
            // find it
            int handle = NativeMethods.FindWindow("IPTIP_Main_Window", "");
            bool active = handle > 0;
            if (active)
            {
                // don't check style - just close
                NativeMethods.SendMessage(handle, NativeMethods.WM_SYSCOMMAND, NativeMethods.SC_CLOSE, 0);
            }
            return active;
        }

        public static bool IsOpen()
        {
            return GetIsOpen1709() ?? GetIsOpenLegacy();
        }


        [DllImport("user32.dll", SetLastError = false)]
        private static extern IntPtr FindWindowEx(IntPtr parent, IntPtr after, string className, string title = null);

        [DllImport("user32.dll", SetLastError = false)]
        private static extern uint GetWindowLong(IntPtr wnd, int index);

        private static bool? GetIsOpen1709()
        {
            // if there is a top-level window - the keyboard is closed
            var wnd = FindWindowEx(IntPtr.Zero, IntPtr.Zero, WindowClass1709, WindowCaption1709);
            if (wnd != IntPtr.Zero)
                return false;

            var parent = IntPtr.Zero;
            for (;;)
            {
                parent = FindWindowEx(IntPtr.Zero, parent, WindowParentClass1709);
                if (parent == IntPtr.Zero)
                    return null; // no more windows, keyboard state is unknown

                // if it's a child of a WindowParentClass1709 window - the keyboard is open
                wnd = FindWindowEx(parent, IntPtr.Zero, WindowClass1709, WindowCaption1709);
                if (wnd != IntPtr.Zero)
                    return true;
            }
        }

        private static bool GetIsOpenLegacy()
        {
            var wnd = FindWindowEx(IntPtr.Zero, IntPtr.Zero, WindowClass);
            if (wnd == IntPtr.Zero)
                return false;

            var style = GetWindowStyle(wnd);
            return style.HasFlag(WindowStyle.Visible)
                && !style.HasFlag(WindowStyle.Disabled);
        }

        private const string WindowClass = "IPTip_Main_Window";
        private const string WindowParentClass1709 = "ApplicationFrameWindow";
        private const string WindowClass1709 = "Windows.UI.Core.CoreWindow";
        private const string WindowCaption1709 = "Microsoft Text Input Application";

        private enum WindowStyle : uint
        {
            Disabled = 0x08000000,
            Visible = 0x10000000,
        }

        private static WindowStyle GetWindowStyle(IntPtr wnd)
        {
            return (WindowStyle)GetWindowLong(wnd, -16);
        }

    }


    [ComImport]
    [Guid("37c994e7-432b-4834-a2f7-dce1f13b834b")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    interface ITipInvocation
    {
        void Toggle(IntPtr hwnd);
    }

    internal static class NativeMethods
    {
        [DllImport("user32.dll", EntryPoint = "FindWindow")]
        internal static extern int FindWindow(string lpClassName, string lpWindowName);

        [DllImport("user32.dll", EntryPoint = "SendMessage")]
        internal static extern int SendMessage(int hWnd, uint Msg, int wParam, int lParam);

        [DllImport("user32.dll", EntryPoint = "GetDesktopWindow", SetLastError = false)]
        internal static extern IntPtr GetDesktopWindow();

        [DllImport("user32.dll", EntryPoint = "GetWindowLong")]
        internal static extern int GetWindowLong(int hWnd, int nIndex);

        internal const int GWL_STYLE = -16;
        internal const int GWL_EXSTYLE = -20;        
        internal const int WM_SYSCOMMAND = 0x0112;
        internal const int SC_CLOSE = 0xF060;

        internal const int WS_DISABLED = 0x08000000;

        internal const int WS_VISIBLE = 0x10000000;

    }
}

Solution 3

I detect 4 situations when trying to open Touch Keyboard on Windows 10 Anniversary Update

1. Keyboard is Visible - when "IPTIP_Main_Window" is present, NOT disabled and IS visible
2. Keyboard is not visible - when "IPTIP_Main_Window" is present but disabled
3. Keyboard is not visible - when "IPTIP_Main_Window" is present but NOT disabled and NOT visible
4. Keyboard is not visible - when "IPTIP_Main_Window" is NOT present

1 - nothing to do

2+3 - activating via COM

4 - most interesting scenario. In some devices starting TabTip process opens touch keyboard, on some - not. So we must start TabTip process, wait for appearing window "IPTIP_Main_Window", check it for visibility and activate it via COM if nessesary.

I make small library for my project, you can use it - osklib

Solution 4

The only solution I've found to work is by sending PostMessage as you've mentioned in answer 1. Here's the C# version of it in case someone needs it.

[DllImport("user32.dll", CharSet = CharSet.Unicode)]
    private static extern IntPtr FindWindow(string sClassName, string sAppName);

[DllImport("user32.dll", CharSet = CharSet.Unicode)]
    static extern IntPtr FindWindowEx(IntPtr parentHandle, IntPtr childAfter, string lclassName, string windowTitle); 

[DllImport("User32.Dll", EntryPoint = "PostMessageA")]
    static extern bool PostMessage(IntPtr hWnd, uint msg, int wParam, int lParam);

var trayWnd = FindWindow("Shell_TrayWnd", null);
var nullIntPtr = new IntPtr(0);

if (trayWnd != nullIntPtr)
{
    var trayNotifyWnd = FindWindowEx(trayWnd, nullIntPtr, "TrayNotifyWnd", null);
    if (trayNotifyWnd != nullIntPtr)
    {
        var tIPBandWnd = FindWindowEx(trayNotifyWnd, nullIntPtr, "TIPBand", null);

        if (tIPBandWnd != nullIntPtr)
        {
            PostMessage(tIPBandWnd, (UInt32)WMessages.WM_LBUTTONDOWN, 1, 65537);
            PostMessage(tIPBandWnd, (UInt32)WMessages.WM_LBUTTONUP, 1, 65537);
        }
    }
}


public enum WMessages : int
{
    WM_LBUTTONDOWN = 0x201,
    WM_LBUTTONUP = 0x202,
    WM_KEYDOWN = 0x100,
    WM_KEYUP = 0x101,
    WH_KEYBOARD_LL = 13,
    WH_MOUSE_LL = 14,
}

Solution 5

The following code will always work since it uses latest MS Api
I put it into a dll (Needed for a Delphi project) but it is a plain C
Also useful for obtaining the keyboard size and adjusting application layout

//*******************************************************************
//
// RETURNS KEYBOARD RECTANGLE OR EMPTY ONE IF KEYBOARD IS NOT VISIBLE
//
//*******************************************************************
RECT __stdcall  GetKeyboardRect()
{
    IFrameworkInputPane *inputPane = NULL;
    RECT prcInputPaneScreenLocation = { 0,0,0,0 };
    HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);    
    if (SUCCEEDED(hr))
    {
        hr = CoCreateInstance(CLSID_FrameworkInputPane, NULL, CLSCTX_INPROC_SERVER, IID_IFrameworkInputPane, (LPVOID*)&inputPane);
        if (SUCCEEDED(hr))
        {
            hr=inputPane->Location(&prcInputPaneScreenLocation);
            if (!SUCCEEDED(hr))
            {                   
            }
            inputPane->Release();
        }
    }       
    CoUninitialize();   
    return prcInputPaneScreenLocation;
}

View more solutions

Comments

[Water]

Thanks mikesl, worked perfectly. Just missing declaration for nullIntPtr which I instantiated with var nullIntPtr = IntPtr.Zero;

[JimmyBlu]

While this works, it requires the tray icon to be available. Unfortunately it can be hidden by the user.

[EugeneK]

This only works for me if TabTip.exe is running, without this process running it fails with 'Class not registered' error.

[andrey.s]

Thanks, it works very well. Is there a way to control it's visibility nicely?

[Greg]

Thanks. I'm now trying to find a way to determine and control visibility also. The old "hwnd = FindWindow("IPTip_Main_Window", NULL)" Is no longer completely effective. Testing the returned HWND for null / visibility always returns true. However "PostMessage(hwnd, WM_SYSCOMMAND, (int)SC_CLOSE, 0)" will still hide the OSK.

[torvin]

@Greg, to test if the keyboard is open I read the window's style. The keyboard is open if all those three conditions are true: 1) FindWindow returned a non-null value, 2) WS_VISIBLE is set, and 3) WS_DISABLED is NOT set. I might add a code example later

[Greg]

The WS_DISABLED check was what I was missing. Now your solution provides a complete work around! To show, I spawn tabtip.exe, then check if not visible and call your ITipInvocation::Toggle if needed.

[terix2k11]

Hi! Thanks for the solution. Is there a way to switch keyboard layout aswell? How did you reengineer this solution? I'm trying to press the "&123" Button for numeric Layout....

[torvin]

@terix2k11 I reverse-engineered explorer.exe. I don't have a good solution for pressing buttons on the keyboard itself. Please let me know if you find a way of doing that

[terix2k11]

@torvin Based on the answer in stackoverflow.com/questions/5094398/… I can spawn a click-event on the "&123" Button. Unfortunately this has two flaws 1) the obvious: my click coordinates are hard coded, but the onscreen keyboard could be moved 2) it only works if the click invoking runs on a process with elevated admin priviliges

[surfmuggle]

For me it was Win+I then click on ease of access (hotkey Win+U) under keyboard switch Turns on the on-screen-keyboard to on.

[Admin]

I think the varied behaviour between not/opening the keyboard is connected to EnableDesktopModeAutoInvoke registy setting, too. Thanks for the research, and the library!

[kayleeFrye_onDeck]

If I wanted to re-purpose this code sample to toggle one of the other virtual input devices that shows up on Explorer's Taskbar, what steps would I need to take/start at? If I understand it correctly, I would need the value for the equivalent interface of ITipInvocation, right? I'm happy to tackle this myself but knowing how to start would help me a lot! :)

[kayleeFrye_onDeck]

I want to say that after reading the documentation, my main challenge would be finding out the IID. I wasn't able to discern how I would go about doing that tho.

[torvin]

@kayleeFrye_onDeck post a separate question

[mikesl]

@torvin, seeing issue where I see the keyboard but IPTip_Main_Window's style is set to 84000000. Did windows update change something?

[torvin]

@mikesl hard to tell. post a new question with a minimum code example that doesn't work.

[mikesl]

Added question, how do you determine if windows virtual keyboard is visible: stackoverflow.com/questions/47187216/…

[Rawat]

@mikesl how can use it to show only telephone keypad

[Jim Garrison]

When posting an answer that contains code, please include an explanation of what the code does and how it answers the user's question. Answers consisting of nothing but code are strongly discouraged.

[Jeff Relf]

The problem, asked at least three times, on three different pages, is that the keyboard toggle ( ITipInvocation.Toggle() ) does NOT ( N O T ) always work ( Win10 desktop Ver 1803 ). I, and only I, have provided the soltion. My solution is well tested, it works. I commented the code... did you read the comments, Jim ? !

[Ken White]

Rather than getting snippy, you should learn to accept constructive criticism from users that are experienced with the site. Code comments are not a substitute for providing a textual explanation. Your experience here will be vastly improved if you learn to accept advice that is intended to help you.

[Admin]

This is temporarily locked while it's being discussed on meta.

[Nasenbaer]

I tested and it did not detect that TapTip was open. Windows 10 Pro x64. ProcessExplorer: C:\Windows\SystemApps\InputApp_cw5n1h2txyewy\WindowsInternal‌​.ComposableShell.Exp‌​eriences.TextInput.I‌​nputApp.exe

[Anders]

This does not work on Windows 8.0. TIPBand is a child of ReBarWindow32, not TrayNotifyWnd.

[Brett Sanderson]

@torvin Can you explain how you reverse engineered explorer to find the Toggle command? I'm trying to do something similar but with the Dictation Toolbar that is opened with WIN+H and appears to be part of TextInputHost.exe "Text Input App". It also has identical window name and class name to the Touch Keyboard.

[Brett Sanderson]

Do you know if you can do this with the dictation toolbar? (WIN + H)

[torvin]

@BrettSanderson this is a very broad topic. Usually reverse-engineering a complied program requires knowledge of x86 Assembly and WinAPI. If you're stuck somewhere, post a separate question. Otherwise I'm not sure how I can help, sorry

[Brett Sanderson]

@torvin hi, my question is here: stackoverflow.com/questions/64084906/… the solution i have for the keyboard appears to work very well, it's just the dictation toolbar i do not like. Here's my current test application: cdn.discordapp.com/attachments/699577276571975760/…