Ensure a terminal requesting FG rights actually has them

src/cascadia/TerminalControl/ControlCore.cpp

@@ -1696,6 +1696,27 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         }
     }
 
+    // Method Description:
+    // - When the control gains focus, it needs to tell ConPTY about this.
+    //   Usually, these sequences are reserved for applications that
+    //   specifically request SET_FOCUS_EVENT_MOUSE, ?1004h. ConPTY uses this
+    //   sequence REGARDLESS to communicate if the control was focused or not.
+    // - Even if a client application disables this mode, the Terminal & conpty
+    //   should always request this from the hosting terminal (and just ignore
+    //   internally to ConPTY).
+    // - Full support for this sequence is tracked in GH#11682.
+    // - This is related to work done for GH#2988.
+    void ControlCore::GotFocus()
+    {
+        _connection.WriteInput(L"\x1b[I");
+    }
+
+    // See GotFocus.
+    void ControlCore::LostFocus()
+    {
+        _connection.WriteInput(L"\x1b[O");
+    }
+
     bool ControlCore::_isBackgroundTransparent()
     {
         // If we're:

src/cascadia/TerminalControl/ControlCore.h

@@ -81,6 +81,9 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         void PasteText(const winrt::hstring& hstr);
         bool CopySelectionToClipboard(bool singleLine, const Windows::Foundation::IReference<CopyFormat>& formats);
 
+        void GotFocus();
+        void LostFocus();
+
         void ToggleShaderEffects();
         void AdjustOpacity(const double adjustment);
         void ResumeRendering();

src/cascadia/TerminalControl/ControlInteractivity.cpp

@@ -111,6 +111,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             THROW_IF_FAILED(_uiaEngine->Enable());
         }
 
+        _core->GotFocus();
+
         _updateSystemParameterSettings();
     }
 
@@ -120,6 +122,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         {
             THROW_IF_FAILED(_uiaEngine->Disable());
         }
+
+        _core->LostFocus();
     }
 
     // Method Description

src/host/CursorBlinker.cpp

@@ -82,8 +82,10 @@ void CursorBlinker::TimerRoutine(SCREEN_INFORMATION& ScreenInfo) const noexcept
     auto& cursor = buffer.GetCursor();
     auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();
     auto* const pAccessibilityNotifier = ServiceLocator::LocateAccessibilityNotifier();
+    const bool inConpty{ gci.IsInVtIoMode() };
 
-    if (!WI_IsFlagSet(gci.Flags, CONSOLE_HAS_FOCUS))
+    // GH#2988: ConPTY can now be focused, but it doesn't need to do any of this work either.
+    if (inConpty || !WI_IsFlagSet(gci.Flags, CONSOLE_HAS_FOCUS))
     {
         goto DoScroll;
     }

src/host/outputStream.cpp

@@ -893,6 +893,75 @@ void ConhostInternalGetSet::UpdateSoftFont(const gsl::span<const uint16_t> bitPa
     }
 }
 
+// Method Description:
+// - Inform the console that the window is focused. This is used by ConPTY.
+//   Terminals can send ConPTY a FocusIn/FocusOut sequence on the input pipe,
+//   which will end up here. This will update the console's internal tracker if
+//   it's focused or not, as to match the end-terminal's state.
+// - Used to call ConsoleControl(ConsoleSetForeground,...).
+// - Full support for this sequence is tracked in GH#11682.
+// Arguments:
+// - bitPattern - An array of scanlines representing all the glyphs in the font.
+// - cellSize - The cell size for an individual glyph.
+// - centeringHint - The horizontal extent that glyphs are offset from center.
+// Return Value:
+// - <none>
+void ConhostInternalGetSet::FocusChanged(const bool focused)
+{
+    auto& g = ServiceLocator::LocateGlobals();
+    auto& gci = g.getConsoleInformation();
+
+    if (gci.IsInVtIoMode())
+    {
+        bool shouldActuallyFocus = false;
+
+        // From https://github.com/microsoft/terminal/pull/12799#issuecomment-1086289552
+        // Make sure that the process that's telling us it's focused, actually
+        // _is_ in the FG. We don't want to allow malicious.exe to say "yep I'm
+        // in the foreground, also, here's a popup" if it isn't actually in the
+        // FG.
+        if (focused)
+        {
+            if (const auto psuedoHwnd{ ServiceLocator::LocatePseudoWindow() })
+            {
+                // They want focus, we found a pseudo hwnd.
+
+                // Note: ::GetParent(psuedoHwnd) will return 0. GetAncestor works though.
+                if (const auto ownerHwnd{ ::GetAncestor(psuedoHwnd, GA_PARENT) })
+                {
+                    // We have an owner from a previous call to ReparentWindow
+
+                    if (const auto currentFgWindow{ ::GetForegroundWindow() })
+                    {
+                        // There is a window in the foreground (it's possible there
+                        // isn't one)
+
+                        // Get the PID of the current FG window, and compare with our owner's PID.
+                        DWORD currentFgPid{ 0 };
+                        DWORD ownerPid{ 0 };
+                        GetWindowThreadProcessId(currentFgWindow, &currentFgPid);
+                        GetWindowThreadProcessId(ownerHwnd, &ownerPid);
+
+                        if (ownerPid == currentFgPid)
+                        {
+                            // Huzzah, the app that owns us is actually the FG
+                            // process. They're allowed to grand FG rights.
+                            shouldActuallyFocus = true;
+                        }
+                    }
+                }
+            }
+        }
+
+        WI_UpdateFlag(gci.Flags, CONSOLE_HAS_FOCUS, shouldActuallyFocus);
+        gci.ProcessHandleList.ModifyConsoleProcessFocus(shouldActuallyFocus);
+    }
+    // Does nothing outside of ConPTY. If there's a real HWND, then the HWND is solely in charge.
+
+    // Theoretically, this could be propagated as a focus event as well, to the
+    // input buffer. That should be considered when implementing GH#11682.
+}
+
 void ConhostInternalGetSet::ReparentWindow(const uint64_t handle)
 {
     // This will initialize s_interactivityFactory for us. It will also

src/host/outputStream.hpp

@@ -116,6 +116,8 @@ class ConhostInternalGetSet final : public Microsoft::Console::VirtualTerminal::
                         const SIZE cellSize,
                         const size_t centeringHint) override;
 
+    void FocusChanged(const bool focused) override;
+
     void ReparentWindow(const uint64_t handle);
 
 private:

src/server/IoDispatchers.cpp

@@ -456,7 +456,22 @@ PCONSOLE_API_MSG IoDispatchers::ConsoleHandleConnectionRequest(_In_ PCONSOLE_API
         return pReceiveMsg;
     }
 
-    gci.ProcessHandleList.ModifyConsoleProcessFocus(WI_IsFlagSet(gci.Flags, CONSOLE_HAS_FOCUS));
+    // For future code archeologists: GH#2988
+    //
+    // Here, the console calls ConsoleControl(ConsoleSetForeground,...) with a
+    // flag depending on if the console is focused or not. This is surprisingly
+    // load bearing. This allows windows spawned by console processes to bring
+    // themselves to the foreground _when the console is focused_.
+    // (Historically, this is also called in the WndProc, when focus changes).
+    //
+    // Notably, before 2022, ConPTY was _never_ focused, so windows could never
+    // bring themselves to the foreground when run from a ConPTY console. We're
+    // not blanket granting the SetForeground right to all console apps when run
+    // in ConPTY. It's the responsibility of the hosting terminal emulator to
+    // always tell ConPTY when a particular instance is focused.
+    const bool hasFocus{ WI_IsFlagSet(gci.Flags, CONSOLE_HAS_FOCUS) };
+    const auto grantSetForeground{ hasFocus };
+    gci.ProcessHandleList.ModifyConsoleProcessFocus(grantSetForeground);
 
     // Create the handles.
 

src/terminal/adapter/IInteractDispatch.hpp

@@ -42,5 +42,7 @@ namespace Microsoft::Console::VirtualTerminal
                                 const size_t col) = 0;
 
         virtual bool IsVtInputEnabled() const = 0;
+
+        virtual bool FocusChanged(const bool focused) const = 0;
     };
 }

src/terminal/adapter/InteractDispatch.cpp

@@ -168,3 +168,19 @@ bool InteractDispatch::IsVtInputEnabled() const
 {
     return _pConApi->IsVtInputEnabled();
 }
+
+// Method Description:
+// - Plumbs through to ConGetSet::FocusChanged. See that method for details.
+// Arguments:
+// - focused: if the terminal is now focused
+// Return Value:
+// - true always.
+bool InteractDispatch::FocusChanged(const bool focused) const
+{
+    // When we do GH#11682, we should make sure that ConPTY requests this mode
+    // from the terminal when it starts up, and ConPTY never unsets that flag.
+    // It should only ever internally disable the events from flowing to the
+    // client application.
+    _pConApi->FocusChanged(focused);
+    return true;
+}

src/terminal/adapter/InteractDispatch.hpp

@@ -35,6 +35,8 @@ namespace Microsoft::Console::VirtualTerminal
 
         bool IsVtInputEnabled() const override;
 
+        bool FocusChanged(const bool focused) const override;
+
     private:
         std::unique_ptr<ConGetSet> _pConApi;
     };

src/terminal/adapter/conGetSet.hpp

@@ -112,6 +112,8 @@ namespace Microsoft::Console::VirtualTerminal
                                     const SIZE cellSize,
                                     const size_t centeringHint) = 0;
 
+        virtual void FocusChanged(const bool focused) = 0;
+
         virtual void ReparentWindow(const uint64_t handle) = 0;
     };
 }

src/terminal/parser/InputStateMachineEngine.cpp

@@ -364,7 +364,9 @@ bool InputStateMachineEngine::ActionCsiDispatch(const VTID id, const VTParameter
     // client reads it.
     if (_pDispatch->IsVtInputEnabled() &&
         _pfnFlushToInputQueue &&
-        id != CsiActionCodes::Win32KeyboardInput)
+        id != CsiActionCodes::Win32KeyboardInput &&
+        id != CsiActionCodes::FocusIn &&
+        id != CsiActionCodes::FocusOut)
     {
         return _pfnFlushToInputQueue();
     }
@@ -426,6 +428,12 @@ bool InputStateMachineEngine::ActionCsiDispatch(const VTID id, const VTParameter
     case CsiActionCodes::DTTERM_WindowManipulation:
         success = _pDispatch->WindowManipulation(parameters.at(0), parameters.at(1), parameters.at(2));
         break;
+    case CsiActionCodes::FocusIn:
+        success = _pDispatch->FocusChanged(true);
+        break;
+    case CsiActionCodes::FocusOut:
+        success = _pDispatch->FocusChanged(false);
+        break;
     case CsiActionCodes::Win32KeyboardInput:
     {
         // Use WriteCtrlKey here, even for keys that _aren't_ control keys,

src/terminal/parser/InputStateMachineEngine.hpp

@@ -58,6 +58,8 @@ namespace Microsoft::Console::VirtualTerminal
         ArrowLeft = VTID("D"),
         Home = VTID("H"),
         End = VTID("F"),
+        FocusIn = VTID("I"),
+        FocusOut = VTID("O"),
         MouseDown = VTID("<M"),
         MouseUp = VTID("<m"),
         Generic = VTID("~"), // Used for a whole bunch of possible keys