Input Method Editor implementation?

[Unit2Ed]

It appears that the plugin drops support for IME, which ImGui has rudimentary support for. Unreal seems to conflict with ImGui's use of ::ImmGetContext, causing it to be deactivated, except when using a slate text widget.

It looks like the engine would want us to implement ITextInputMethodContext for SImGuiWidget, but it seems to be quite involved - requiring a much more complex interaction with ImGui to pull out the active document, render the composition etc.

Has anyone tried doing this, or found a way for Unreal's TextInputService to co-exist with the simple ::ImmGetContext API?

[Unit2Ed]

We've worked around this temporarily by stopping FWindowsApplication() from creating the TextInputMethodSystem and adding a subsequently missing call to DefWindowProc in FWindowsApplication::ProcessDeferredMessage. Not pretty, but we don't rely on Unreal for any other text fields, and the IME still triggers anyway for Slate controls (but is positioned incorrectly).

[raytaylorlin]

@Unit2Ed I tried to implement ITextInputMethodContext and it works well. I disable the default ContextProxy (used in PIE runtime) and create a new one, because I need the ImGui to run in EDITOR only.

// ImGuiTextInputMethodContext.h

#pragma once

class SImGuiWidgetEd;

class FImGuiTextInputMethodContext : public ITextInputMethodContext
{
public:
    static TSharedRef<FImGuiTextInputMethodContext> Create(const TSharedRef<SImGuiWidgetEd>& Widget);
    void CacheWindow();

    virtual bool IsComposing() override;
    virtual bool IsReadOnly() override;
    virtual uint32 GetTextLength() override;
    virtual void GetSelectionRange(uint32& BeginIndex, uint32& Length, ECaretPosition& CaretPosition) override;
    virtual void SetSelectionRange(const uint32 BeginIndex, const uint32 Length, const ECaretPosition CaretPosition) override;
    virtual void GetTextInRange(const uint32 BeginIndex, const uint32 Length, FString& OutString) override;
    virtual void SetTextInRange(const uint32 BeginIndex, const uint32 Length, const FString& InString) override;
    virtual int32 GetCharacterIndexFromPoint(const FVector2D& Point) override;
    virtual bool GetTextBounds(const uint32 BeginIndex, const uint32 Length, FVector2D& Position, FVector2D& Size) override;
    virtual void GetScreenBounds(FVector2D& Position, FVector2D& Size) override;
    virtual TSharedPtr<FGenericWindow> GetWindow() override;
    virtual void BeginComposition() override;
    virtual void UpdateCompositionRange(const int32 InBeginIndex, const uint32 InLength) override;
    virtual void EndComposition() override;

private:
    FImGuiTextInputMethodContext(const TSharedRef<SImGuiWidgetEd>& Widget);
    TWeakPtr<SImGuiWidgetEd> OwnerWidget;
    TWeakPtr<SWindow> CachedParentWindow;

    bool bIsComposing;
    int32 CompositionBeginIndex;
    uint32 CompositionLength;
    uint32 SelectionRangeBeginIndex;
    uint32 SelectionRangeLength;
    ECaretPosition SelectionCaretPosition;
    FString CompositionString;
};

// ImGuiTextInputMethodContext.cpp

#include "ImGuiTextInputMethodContext.h"
#include "imgui_internal.h"

TSharedRef<FImGuiTextInputMethodContext> FImGuiTextInputMethodContext::Create(const TSharedRef<SImGuiWidgetEd>& Widget)
{
    return MakeShareable(new FImGuiTextInputMethodContext(Widget));
}

void FImGuiTextInputMethodContext::CacheWindow()
{
    const TSharedRef<const SWidget> OwningSlateWidgetPtr = OwnerWidget.Pin().ToSharedRef();
    CachedParentWindow = FSlateApplication::Get().FindWidgetWindow(OwningSlateWidgetPtr);
}

bool FImGuiTextInputMethodContext::IsComposing()
{
    return bIsComposing;
}

bool FImGuiTextInputMethodContext::IsReadOnly()
{
    return false;
}

uint32 FImGuiTextInputMethodContext::GetTextLength()
{
    return CompositionString.Len();
}

void FImGuiTextInputMethodContext::GetSelectionRange(uint32& BeginIndex, uint32& Length, ECaretPosition& CaretPosition)
{
    BeginIndex = SelectionRangeBeginIndex;
    Length = SelectionRangeLength;
    CaretPosition = SelectionCaretPosition;
}

void FImGuiTextInputMethodContext::SetSelectionRange(const uint32 BeginIndex, const uint32 Length,
    const ECaretPosition CaretPosition)
{
    SelectionRangeBeginIndex = BeginIndex;
    SelectionRangeLength = Length;
    SelectionCaretPosition = CaretPosition;
}

void FImGuiTextInputMethodContext::GetTextInRange(const uint32 BeginIndex, const uint32 Length, FString& OutString)
{
    OutString = CompositionString.Mid(BeginIndex, Length);
}

void FImGuiTextInputMethodContext::SetTextInRange(const uint32 BeginIndex, const uint32 Length, const FString& InString)
{
    FString NewString;
    if (BeginIndex > 0)
    {
        NewString = CompositionString.Mid(0, BeginIndex);
    }

    NewString += InString;

    if ((int32)(BeginIndex + Length) < CompositionString.Len())
    {
        NewString += CompositionString.Mid(BeginIndex + Length, CompositionString.Len() - (BeginIndex + Length));
    }
    CompositionString = NewString;
    // UE_LOG(LogUnrealImGui, Log, TEXT("SetTextInRange BeginIndex = %d, Length = %d, InString = %s, newString = %s"), BeginIndex, Length, *InString, *CompositionString);
}

int32 FImGuiTextInputMethodContext::GetCharacterIndexFromPoint(const FVector2D& Point)
{
    int32 ResultIdx = INDEX_NONE;
    return ResultIdx;
}

bool FImGuiTextInputMethodContext::GetTextBounds(const uint32 BeginIndex, const uint32 Length, FVector2D& Position, FVector2D& Size)
{
    if (OwnerWidget.IsValid())
    {
        ImGuiContext* ImGuiContext = ImGui::GetCurrentContext();
        if (ImGuiContext)
        {
                        // Let the IME editor follow the cursor
            Position = FVector2D(CachedGeometry.AbsolutePosition.X + ImGuiContext->PlatformImeLastPos.x,
                CachedGeometry.AbsolutePosition.Y + ImGuiContext->PlatformImeLastPos.y + 20);
        }
    }
    return false;
}

void FImGuiTextInputMethodContext::GetScreenBounds(FVector2D& Position, FVector2D& Size)
{
}

TSharedPtr<FGenericWindow> FImGuiTextInputMethodContext::GetWindow()
{
    const TSharedPtr<SWindow> SlateWindow = CachedParentWindow.Pin();
    return SlateWindow.IsValid() ? SlateWindow->GetNativeWindow() : nullptr;
}

void FImGuiTextInputMethodContext::BeginComposition()
{
    if (!bIsComposing)
    {
        bIsComposing = true;
    }
}

void FImGuiTextInputMethodContext::UpdateCompositionRange(const int32 InBeginIndex, const uint32 InLength)
{
    CompositionBeginIndex = InBeginIndex;
    CompositionLength = InLength;
}

void FImGuiTextInputMethodContext::EndComposition()
{
    if (bIsComposing)
    {
        bIsComposing = false;

        if (OwnerWidget.IsValid())
        {
            ImGuiContext* ImGuiContext = ImGui::GetCurrentContext();
            ImGuiID ID = OwnerWidget.Pin()->CurrentActiveInputTextID;

            // UE_LOG(LogUnrealImGui, Log, TEXT("EndComposition, set ID = %d CompositionString = %s"), ID, *CompositionString);
            if (ImGuiContext->InputTextState.ID == ID)
            {
                auto CharArray = CompositionString.GetCharArray();
                for (int i = 0; i < CharArray.Num(); i++)
                {
                    OwnerWidget.Pin()->AddCharacter(CharArray[i]);
                }
                CompositionString.Empty();
                CompositionBeginIndex = 0;
                CompositionLength = 0;
                SelectionRangeBeginIndex = 0;
                SelectionRangeLength = 0;
            }
        }
    }
}

FImGuiTextInputMethodContext::FImGuiTextInputMethodContext(const TSharedRef<SImGuiWidgetEd>& Widget)
    : OwnerWidget(Widget)
    , bIsComposing(false)
    , CompositionBeginIndex(0)
    , CompositionLength(0)
    , SelectionRangeBeginIndex(0)
    , SelectionRangeLength(0)
    , SelectionCaretPosition(ECaretPosition::Beginning)
{
}

Register the context in your ImGuiWidget

ITextInputMethodSystem* const TextInputMethodSystem = FSlateApplication::Get().GetTextInputMethodSystem();
if (TextInputMethodSystem)
{
    if (!bHasRegisteredTextInputMethodContext)
    {
        bHasRegisteredTextInputMethodContext = true;
        TextInputMethodChangeNotifier = TextInputMethodSystem->RegisterContext(TextInputMethodContext.ToSharedRef());
        if (TextInputMethodChangeNotifier.IsValid())
        {
            TextInputMethodChangeNotifier->NotifyLayoutChanged(ITextInputMethodChangeNotifier::ELayoutChangeType::Created);
        }
    }
    TextInputMethodContext->CacheWindow();
    TextInputMethodSystem->ActivateContext(TextInputMethodContext.ToSharedRef());
}

Note that I use the AddCharacter API to convert TCHAR to ImGui character.

void SImGuiWidgetEd::AddCharacter(TCHAR ch)
{
    if (InputHandler.IsValid() && InputHandler->GetInputState())
    {
        InputHandler->GetInputState()->AddCharacter(ch);
    }
}

Result: