Add support for naming windows with the -w parameter (#9300)
This finishes the implementation of `--window` to also accept a string as the "name" of the window. So you can say ```sh wt -w foo new-tab wt -w foo split-pane ``` and have both those commands execute in the same window, the one named "foo". This is just slightly more ergonomic than manually using the IDs of windows. In the future, I'll be working on renaming windows, and displaying these names. > #### `--window,-w <window-id>` > Run these commands in the given Windows Terminal session. This enables opening > new tabs, splits, etc. in already running Windows Terminal windows. > * If `window-id` is `0`, run the given commands in _the current window_. > * If `window-id` is a negative number, or the reserved name `new`, run the > commands in a _new_ Terminal window. > * If `window-id` is the ID or name of an existing window, then run the > commandline in that window. > * If `window-id` is _not_ the ID or name of an existing window, create a new > window. That window will be assigned the ID or name provided in the > commandline. The provided subcommands will be run in that new window. > * If `window-id` is omitted, then obey the value of `windowingBehavior` when > determining which window to run the command in. Before this PR, I think we didn't actually properly support assigning the id with `wt -w 12345`. If `12345` didn't exist, it would make a new window, but just assign it the next id, not assign it 12345. ## References * #4472, #8135 * https://github.com/microsoft/terminal/projects/5 ## Validation Steps Performed Ran tests Messed with naming windows, working as expected. Closes https://github.com/microsoft/terminal/projects/5#card-51431478
This commit is contained in:
Mike Griese
GitHub
parent
8346968881
commit
43c469fc95
|
|
@ -1594,59 +1594,155 @@ namespace TerminalAppLocalTests
|
|||
void CommandlineTest::TestFindTargetWindow()
|
||||
{
|
||||
{
|
||||
Log::Comment(L"wt.exe with no args should always use the value from"
|
||||
L" the settings (passed as the second argument).");
|
||||
|
||||
std::vector<winrt::hstring> args{ L"wt.exe" };
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew));
|
||||
auto result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseExisting,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting));
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseExisting, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseAnyExisting,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting));
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseAnyExisting, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
}
|
||||
{
|
||||
Log::Comment(L"-w -1 should always result in a new window");
|
||||
|
||||
std::vector<winrt::hstring> args{ L"wt.exe", L"-w", L"-1" };
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew));
|
||||
auto result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting));
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting));
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
}
|
||||
{
|
||||
Log::Comment(L"\"new\" should always result in a new window");
|
||||
|
||||
std::vector<winrt::hstring> args{ L"wt.exe", L"-w", L"new" };
|
||||
auto result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
}
|
||||
{
|
||||
Log::Comment(L"-w with a negative number should always result in a "
|
||||
L"new window");
|
||||
|
||||
std::vector<winrt::hstring> args{ L"wt.exe", L"-w", L"-12345" };
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew));
|
||||
auto result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting));
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting));
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
}
|
||||
{
|
||||
Log::Comment(L"-w with a positive number should result in us trying"
|
||||
L" to either make a new one or find an existing one "
|
||||
L"with that ID, depending on the provided argument");
|
||||
|
||||
std::vector<winrt::hstring> args{ L"wt.exe", L"-w", L"12345" };
|
||||
auto result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew);
|
||||
VERIFY_ARE_EQUAL(12345, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting);
|
||||
VERIFY_ARE_EQUAL(12345, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting);
|
||||
VERIFY_ARE_EQUAL(12345, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
}
|
||||
{
|
||||
Log::Comment(L"-w 0 should always use the \"current\" window");
|
||||
|
||||
std::vector<winrt::hstring> args{ L"wt.exe", L"-w", L"0" };
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseCurrent,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew));
|
||||
auto result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseCurrent, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseCurrent,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting));
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseCurrent, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseCurrent,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting));
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseCurrent, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
}
|
||||
{
|
||||
Log::Comment(L"-w last should always use the most recent window on "
|
||||
L"this desktop");
|
||||
|
||||
std::vector<winrt::hstring> args{ L"wt.exe", L"-w", L"last" };
|
||||
auto result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseExisting, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseExisting, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseExisting, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
}
|
||||
{
|
||||
Log::Comment(L"Make sure we follow the provided argument when a "
|
||||
L"--window-id wasn't explicitly provided");
|
||||
|
||||
std::vector<winrt::hstring> args{ L"wt.exe", L"new-tab" };
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew));
|
||||
auto result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseExisting,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting));
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseExisting, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseAnyExisting,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting));
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseAnyExisting, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
}
|
||||
{
|
||||
Log::Comment(L"Even if someone uses a subcommand as a window name, "
|
||||
L"that should work");
|
||||
|
||||
std::vector<winrt::hstring> args{ L"wt.exe", L"-w", L"new-tab" };
|
||||
auto result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseName, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"new-tab", result.WindowName());
|
||||
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseName, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"new-tab", result.WindowName());
|
||||
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseName, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"new-tab", result.WindowName());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1657,19 +1753,23 @@ namespace TerminalAppLocalTests
|
|||
// This is a little helper to make sure that these args _always_ return
|
||||
// UseNew, regardless of the windowing behavior.
|
||||
auto testHelper = [](auto&& args) {
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew));
|
||||
auto result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting));
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting));
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
};
|
||||
|
||||
testHelper(std::vector<winrt::hstring>{ L"wt.exe", L"--help" });
|
||||
testHelper(std::vector<winrt::hstring>{ L"wt.exe", L"new-tab", L"--help" });
|
||||
testHelper(std::vector<winrt::hstring>{ L"wt.exe", L"-w", L"0", L"new-tab", L"--help" });
|
||||
testHelper(std::vector<winrt::hstring>{ L"wt.exe", L"-w", L"foo", L"new-tab", L"--help" });
|
||||
testHelper(std::vector<winrt::hstring>{ L"wt.exe", L"new-tab", L";", L"--help" });
|
||||
}
|
||||
|
||||
|
|
@ -1680,14 +1780,17 @@ namespace TerminalAppLocalTests
|
|||
// This is a little helper to make sure that these args _always_ return
|
||||
// UseNew, regardless of the windowing behavior.
|
||||
auto testHelper = [](auto&& args) {
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew));
|
||||
auto result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseNew);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting));
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew,
|
||||
appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting));
|
||||
result = appImpl::AppLogic::_doFindTargetWindow({ args }, WindowingMode::UseAnyExisting);
|
||||
VERIFY_ARE_EQUAL(WindowingBehaviorUseNew, result.WindowId());
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
};
|
||||
|
||||
testHelper(std::vector<winrt::hstring>{ L"wt.exe", L"--version" });
|
||||
|
|
|
|||
|
|
@ -27,6 +27,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
{
|
||||
WINRT_PROPERTY(winrt::Microsoft::Terminal::Remoting::CommandlineArgs, Args, nullptr);
|
||||
WINRT_PROPERTY(int, ResultTargetWindow, -1);
|
||||
WINRT_PROPERTY(winrt::hstring, ResultTargetWindowName);
|
||||
|
||||
public:
|
||||
FindTargetWindowArgs(winrt::Microsoft::Terminal::Remoting::CommandlineArgs args) :
|
||||
|
|
|
|||
|
|
@ -147,6 +147,59 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
}
|
||||
}
|
||||
|
||||
// Method Description:
|
||||
// - Find the ID of the peasant with the given name. If no such peasant
|
||||
// exists, then we'll return 0. If we encounter any peasants who have died
|
||||
// during this process, then we'll remove them from the set of _peasants
|
||||
// Arguments:
|
||||
// - name: The window name to look for
|
||||
// Return Value:
|
||||
// - 0 if we didn't find the given peasant, otherwise a positive number for
|
||||
// the window's ID.
|
||||
uint64_t Monarch::_lookupPeasantIdForName(std::wstring_view name)
|
||||
{
|
||||
if (name.empty())
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
std::vector<uint64_t> peasantsToErase{};
|
||||
uint64_t result = 0;
|
||||
for (const auto& [id, p] : _peasants)
|
||||
{
|
||||
try
|
||||
{
|
||||
auto otherName = p.WindowName();
|
||||
if (otherName == name)
|
||||
{
|
||||
result = id;
|
||||
break;
|
||||
}
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
LOG_CAUGHT_EXCEPTION();
|
||||
// Normally, we'd just erase the peasant here. However, we can't
|
||||
// erase from the map while we're iterating over it like this.
|
||||
// Instead, pull a good ole Java and collect this id for removal
|
||||
// later.
|
||||
peasantsToErase.push_back(id);
|
||||
}
|
||||
}
|
||||
|
||||
// Remove the dead peasants we came across while iterating.
|
||||
for (const auto& id : peasantsToErase)
|
||||
{
|
||||
// Remove the peasant from the list of peasants
|
||||
_peasants.erase(id);
|
||||
// Remove the peasant from the list of MRU windows. They're dead.
|
||||
// They can't be the MRU anymore.
|
||||
_clearOldMruEntries(id);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// Method Description:
|
||||
// - Handler for the `Peasant::WindowActivated` event. We'll make a in-proc
|
||||
// copy of the WindowActivatedArgs from the peasant. That way, we won't
|
||||
|
|
@ -400,6 +453,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
// After the event was handled, ResultTargetWindow() will be filled with
|
||||
// the parsed result.
|
||||
const auto targetWindow = findWindowArgs->ResultTargetWindow();
|
||||
const auto targetWindowName = findWindowArgs->ResultTargetWindowName();
|
||||
|
||||
TraceLoggingWrite(g_hRemotingProvider,
|
||||
"Monarch_ProposeCommandline",
|
||||
|
|
@ -410,6 +464,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
// that goes with it. Alternatively, if we were given a magic windowing
|
||||
// constant, we can use that to look up an appropriate peasant.
|
||||
if (targetWindow >= 0 ||
|
||||
targetWindow == WindowingBehaviorUseName ||
|
||||
targetWindow == WindowingBehaviorUseExisting ||
|
||||
targetWindow == WindowingBehaviorUseAnyExisting)
|
||||
{
|
||||
|
|
@ -429,6 +484,9 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
case WindowingBehaviorUseAnyExisting:
|
||||
windowID = _getMostRecentPeasantID(false);
|
||||
break;
|
||||
case WindowingBehaviorUseName:
|
||||
windowID = _lookupPeasantIdForName(targetWindowName);
|
||||
break;
|
||||
default:
|
||||
windowID = ::base::saturated_cast<uint64_t>(targetWindow);
|
||||
break;
|
||||
|
|
@ -449,7 +507,6 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
if (auto targetPeasant{ _getPeasant(windowID) })
|
||||
{
|
||||
auto result{ winrt::make_self<Remoting::implementation::ProposeCommandlineResult>(false) };
|
||||
|
||||
try
|
||||
{
|
||||
// This will raise the peasant's ExecuteCommandlineRequested
|
||||
|
|
@ -463,6 +520,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
// If we fail to propose the commandline to the peasant (it
|
||||
// died?) then just tell this process to become a new window
|
||||
// instead.
|
||||
result->WindowName(targetWindowName);
|
||||
result->ShouldCreateWindow(true);
|
||||
|
||||
// If this fails, it'll be logged in the following
|
||||
|
|
@ -497,6 +555,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
|
||||
auto result{ winrt::make_self<Remoting::implementation::ProposeCommandlineResult>(true) };
|
||||
result->Id(windowID);
|
||||
result->WindowName(targetWindowName);
|
||||
return *result;
|
||||
}
|
||||
}
|
||||
|
|
@ -508,6 +567,8 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE));
|
||||
|
||||
// In this case, no usable ID was provided. Return { true, nullopt }
|
||||
return winrt::make<Remoting::implementation::ProposeCommandlineResult>(true);
|
||||
auto result = winrt::make_self<Remoting::implementation::ProposeCommandlineResult>(true);
|
||||
result->WindowName(targetWindowName);
|
||||
return *result;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -67,6 +67,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
|
||||
winrt::Microsoft::Terminal::Remoting::IPeasant _getPeasant(uint64_t peasantID);
|
||||
uint64_t _getMostRecentPeasantID(bool limitToCurrentDesktop);
|
||||
uint64_t _lookupPeasantIdForName(std::wstring_view name);
|
||||
|
||||
void _peasantWindowActivated(const winrt::Windows::Foundation::IInspectable& sender,
|
||||
const winrt::Microsoft::Terminal::Remoting::WindowActivatedArgs& args);
|
||||
|
|
|
|||
|
|
@ -9,11 +9,12 @@ namespace Microsoft.Terminal.Remoting
|
|||
[default_interface] runtimeclass FindTargetWindowArgs {
|
||||
CommandlineArgs Args { get; };
|
||||
Int32 ResultTargetWindow;
|
||||
String ResultTargetWindowName;
|
||||
}
|
||||
|
||||
[default_interface] runtimeclass ProposeCommandlineResult {
|
||||
Windows.Foundation.IReference<UInt64> Id { get; };
|
||||
// TODO:projects/5 - also return the name here, if the name was set on the commandline
|
||||
String WindowName { get; };
|
||||
Boolean ShouldCreateWindow { get; }; // If you name this `CreateWindow`, the compiler will explode
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -26,6 +26,8 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
winrt::Microsoft::Terminal::Remoting::WindowActivatedArgs GetLastActivatedArgs();
|
||||
|
||||
winrt::Microsoft::Terminal::Remoting::CommandlineArgs InitialArgs();
|
||||
WINRT_PROPERTY(winrt::hstring, WindowName);
|
||||
|
||||
TYPED_EVENT(WindowActivated, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::WindowActivatedArgs);
|
||||
TYPED_EVENT(ExecuteCommandlineRequested, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::CommandlineArgs);
|
||||
|
||||
|
|
|
|||
|
|
@ -33,6 +33,7 @@ namespace Microsoft.Terminal.Remoting
|
|||
Boolean ExecuteCommandline(CommandlineArgs args);
|
||||
void ActivateWindow(WindowActivatedArgs args);
|
||||
WindowActivatedArgs GetLastActivatedArgs();
|
||||
String WindowName { get; };
|
||||
|
||||
event Windows.Foundation.TypedEventHandler<Object, WindowActivatedArgs> WindowActivated;
|
||||
event Windows.Foundation.TypedEventHandler<Object, CommandlineArgs> ExecuteCommandlineRequested;
|
||||
|
|
|
|||
|
|
@ -27,6 +27,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
{
|
||||
public:
|
||||
WINRT_PROPERTY(Windows::Foundation::IReference<uint64_t>, Id);
|
||||
WINRT_PROPERTY(winrt::hstring, WindowName);
|
||||
WINRT_PROPERTY(bool, ShouldCreateWindow, true);
|
||||
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -5,6 +5,8 @@
|
|||
#include "WindowManager.h"
|
||||
#include "MonarchFactory.h"
|
||||
#include "CommandlineArgs.h"
|
||||
#include "../inc/WindowingBehavior.h"
|
||||
#include "FindTargetWindowArgs.h"
|
||||
|
||||
#include "WindowManager.g.cpp"
|
||||
#include "../../types/inc/utils.hpp"
|
||||
|
|
@ -69,6 +71,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
// Otherwise, the King will tell us if we should make a new window
|
||||
_shouldCreateWindow = _isKing;
|
||||
std::optional<uint64_t> givenID;
|
||||
winrt::hstring givenName{};
|
||||
if (!_isKing)
|
||||
{
|
||||
// The monarch may respond back "you should be a new
|
||||
|
|
@ -86,7 +89,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
{
|
||||
givenID = result.Id().Value();
|
||||
}
|
||||
|
||||
givenName = result.WindowName();
|
||||
// TraceLogging doesn't have a good solution for logging an
|
||||
// optional. So we have to repeat the calls here:
|
||||
if (givenID)
|
||||
|
|
@ -95,6 +98,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
"WindowManager_ProposeCommandline",
|
||||
TraceLoggingBoolean(_shouldCreateWindow, "CreateWindow", "true iff we should create a new window"),
|
||||
TraceLoggingUInt64(givenID.value(), "Id", "The ID we should assign our peasant"),
|
||||
TraceLoggingWideString(givenName.c_str(), "Name", "The name we should assign this window"),
|
||||
TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE));
|
||||
}
|
||||
else
|
||||
|
|
@ -103,6 +107,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
"WindowManager_ProposeCommandline",
|
||||
TraceLoggingBoolean(_shouldCreateWindow, "CreateWindow", "true iff we should create a new window"),
|
||||
TraceLoggingPointer(nullptr, "Id", "No ID provided"),
|
||||
TraceLoggingWideString(givenName.c_str(), "Name", "The name we should assign this window"),
|
||||
TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE));
|
||||
}
|
||||
}
|
||||
|
|
@ -110,17 +115,60 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
{
|
||||
// We're the monarch, we don't need to propose anything. We're just
|
||||
// going to do it.
|
||||
TraceLoggingWrite(g_hRemotingProvider,
|
||||
"WindowManager_ProposeCommandline_AsMonarch",
|
||||
TraceLoggingBoolean(_shouldCreateWindow, "CreateWindow", "true iff we should create a new window"),
|
||||
TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE));
|
||||
//
|
||||
// However, we _do_ need to ask what our name should be. It's
|
||||
// possible someone started the _first_ wt with something like `wt
|
||||
// -w king` as the commandline - we want to make sure we set our
|
||||
// name to "king".
|
||||
//
|
||||
// The FindTargetWindow event is the WindowManager's way of saying
|
||||
// "I do not know how to figure out how to turn this list of args
|
||||
// into a window ID/name. Whoever's listening to this event does, so
|
||||
// I'll ask them". It's a convoluted way of hooking the
|
||||
// WindowManager up to AppLogic without actually telling it anything
|
||||
// about TerminalApp (or even WindowsTerminal)
|
||||
auto findWindowArgs{ winrt::make_self<Remoting::implementation::FindTargetWindowArgs>(args) };
|
||||
_raiseFindTargetWindowRequested(nullptr, *findWindowArgs);
|
||||
|
||||
const auto responseId = findWindowArgs->ResultTargetWindow();
|
||||
if (responseId > 0)
|
||||
{
|
||||
givenID = ::base::saturated_cast<uint64_t>(responseId);
|
||||
|
||||
TraceLoggingWrite(g_hRemotingProvider,
|
||||
"WindowManager_ProposeCommandline_AsMonarch",
|
||||
TraceLoggingBoolean(_shouldCreateWindow, "CreateWindow", "true iff we should create a new window"),
|
||||
TraceLoggingUInt64(givenID.value(), "Id", "The ID we should assign our peasant"),
|
||||
TraceLoggingWideString(givenName.c_str(), "Name", "The name we should assign this window"),
|
||||
TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE));
|
||||
}
|
||||
else if (responseId == WindowingBehaviorUseName)
|
||||
{
|
||||
givenName = findWindowArgs->ResultTargetWindowName();
|
||||
|
||||
TraceLoggingWrite(g_hRemotingProvider,
|
||||
"WindowManager_ProposeCommandline_AsMonarch",
|
||||
TraceLoggingBoolean(_shouldCreateWindow, "CreateWindow", "true iff we should create a new window"),
|
||||
TraceLoggingUInt64(0, "Id", "The ID we should assign our peasant"),
|
||||
TraceLoggingWideString(givenName.c_str(), "Name", "The name we should assign this window"),
|
||||
TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE));
|
||||
}
|
||||
else
|
||||
{
|
||||
TraceLoggingWrite(g_hRemotingProvider,
|
||||
"WindowManager_ProposeCommandline_AsMonarch",
|
||||
TraceLoggingBoolean(_shouldCreateWindow, "CreateWindow", "true iff we should create a new window"),
|
||||
TraceLoggingUInt64(0, "Id", "The ID we should assign our peasant"),
|
||||
TraceLoggingWideString(L"", "Name", "The name we should assign this window"),
|
||||
TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE));
|
||||
}
|
||||
}
|
||||
|
||||
if (_shouldCreateWindow)
|
||||
{
|
||||
// If we should create a new window, then instantiate our Peasant
|
||||
// instance, and tell that peasant to handle that commandline.
|
||||
_createOurPeasant({ givenID });
|
||||
_createOurPeasant({ givenID }, givenName);
|
||||
|
||||
// Spawn a thread to wait on the monarch, and handle the election
|
||||
if (!_isKing)
|
||||
|
|
@ -208,13 +256,17 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
return (ourPID == kingPID);
|
||||
}
|
||||
|
||||
Remoting::IPeasant WindowManager::_createOurPeasant(std::optional<uint64_t> givenID)
|
||||
Remoting::IPeasant WindowManager::_createOurPeasant(std::optional<uint64_t> givenID,
|
||||
const winrt::hstring& givenName)
|
||||
{
|
||||
auto p = winrt::make_self<Remoting::implementation::Peasant>();
|
||||
if (givenID)
|
||||
{
|
||||
p->AssignID(givenID.value());
|
||||
}
|
||||
|
||||
// If the name wasn't specified, this will be an empty string.
|
||||
p->WindowName(givenName);
|
||||
_peasant = *p;
|
||||
|
||||
// Try to add us to the monarch. If that fails, try to find a monarch
|
||||
|
|
|
|||
|
|
@ -54,7 +54,8 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
|
|||
void _createMonarch();
|
||||
void _createMonarchAndCallbacks();
|
||||
bool _areWeTheKing();
|
||||
winrt::Microsoft::Terminal::Remoting::IPeasant _createOurPeasant(std::optional<uint64_t> givenID);
|
||||
winrt::Microsoft::Terminal::Remoting::IPeasant _createOurPeasant(std::optional<uint64_t> givenID,
|
||||
const winrt::hstring& givenName);
|
||||
|
||||
bool _performElection();
|
||||
void _createPeasantThread();
|
||||
|
|
|
|||
|
|
@ -185,9 +185,9 @@ void AppCommandlineArgs::_buildParser()
|
|||
maximized->excludes(fullscreen);
|
||||
focus->excludes(fullscreen);
|
||||
|
||||
_app.add_option<std::optional<int>, int>("-w,--window",
|
||||
_windowTarget,
|
||||
RS_A(L"CmdWindowTargetArgDesc"));
|
||||
_app.add_option("-w,--window",
|
||||
_windowTarget,
|
||||
RS_A(L"CmdWindowTargetArgDesc"));
|
||||
|
||||
// Subcommands
|
||||
_buildNewTabParser();
|
||||
|
|
@ -865,16 +865,10 @@ void AppCommandlineArgs::FullResetState()
|
|||
_exitMessage = "";
|
||||
_shouldExitEarly = false;
|
||||
|
||||
_windowTarget = std::nullopt;
|
||||
_windowTarget = {};
|
||||
}
|
||||
|
||||
std::optional<int> AppCommandlineArgs::GetTargetWindow() const noexcept
|
||||
std::string_view AppCommandlineArgs::GetTargetWindow() const noexcept
|
||||
{
|
||||
// If the user provides _any_ negative number, then treat it as -1, for "use a new window".
|
||||
if (_windowTarget.has_value() && *_windowTarget < 0)
|
||||
{
|
||||
return { -1 };
|
||||
}
|
||||
|
||||
return _windowTarget;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ public:
|
|||
void DisableHelpInExitMessage();
|
||||
void FullResetState();
|
||||
|
||||
std::optional<int> GetTargetWindow() const noexcept;
|
||||
std::string_view GetTargetWindow() const noexcept;
|
||||
|
||||
private:
|
||||
static const std::wregex _commandDelimiterRegex;
|
||||
|
|
@ -108,7 +108,7 @@ private:
|
|||
std::string _exitMessage;
|
||||
bool _shouldExitEarly{ false };
|
||||
|
||||
std::optional<int> _windowTarget{ std::nullopt };
|
||||
std::string _windowTarget{};
|
||||
// Are you adding more args or attributes here? If they are not reset in _resetStateToDefault, make sure to reset them in FullResetState
|
||||
|
||||
winrt::Microsoft::Terminal::Settings::Model::NewTerminalArgs _getNewTerminalArgs(NewTerminalSubcommand& subcommand);
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@
|
|||
#include "AppLogic.h"
|
||||
#include "../inc/WindowingBehavior.h"
|
||||
#include "AppLogic.g.cpp"
|
||||
#include "FindTargetWindowResult.g.cpp"
|
||||
#include <winrt/Microsoft.UI.Xaml.XamlTypeInfo.h>
|
||||
|
||||
#include <LibraryResources.h>
|
||||
|
|
@ -1219,14 +1220,20 @@ namespace winrt::TerminalApp::implementation
|
|||
// - WindowingBehaviorUseAnyExisting: We should handle the args "in the current
|
||||
// window ON ANY DESKTOP"
|
||||
// - anything else: We should handle the commandline in the window with the given ID.
|
||||
int32_t AppLogic::FindTargetWindow(array_view<const winrt::hstring> args)
|
||||
TerminalApp::FindTargetWindowResult AppLogic::FindTargetWindow(array_view<const winrt::hstring> args)
|
||||
{
|
||||
if (!_loadedInitialSettings)
|
||||
{
|
||||
// Load settings if we haven't already
|
||||
LoadSettings();
|
||||
}
|
||||
|
||||
return AppLogic::_doFindTargetWindow(args, _settings.GlobalSettings().WindowingBehavior());
|
||||
}
|
||||
|
||||
// The main body of this function is a static helper, to facilitate unit-testing
|
||||
int32_t AppLogic::_doFindTargetWindow(array_view<const winrt::hstring> args,
|
||||
const Microsoft::Terminal::Settings::Model::WindowingMode& windowingBehavior)
|
||||
TerminalApp::FindTargetWindowResult AppLogic::_doFindTargetWindow(array_view<const winrt::hstring> args,
|
||||
const Microsoft::Terminal::Settings::Model::WindowingMode& windowingBehavior)
|
||||
{
|
||||
::TerminalApp::AppCommandlineArgs appArgs;
|
||||
const auto result = appArgs.ParseArgs(args);
|
||||
|
|
@ -1234,31 +1241,70 @@ namespace winrt::TerminalApp::implementation
|
|||
{
|
||||
if (!appArgs.GetExitMessage().empty())
|
||||
{
|
||||
return WindowingBehaviorUseNew;
|
||||
return winrt::make<FindTargetWindowResult>(WindowingBehaviorUseNew);
|
||||
}
|
||||
|
||||
const auto parsedTarget = appArgs.GetTargetWindow();
|
||||
if (parsedTarget.has_value())
|
||||
const std::string parsedTarget{ appArgs.GetTargetWindow() };
|
||||
|
||||
// If the user did not provide any value on the commandline,
|
||||
// then lookup our windowing behavior to determine what to do
|
||||
// now.
|
||||
if (parsedTarget.empty())
|
||||
{
|
||||
// parsedTarget might be -1, if the user explicitly requested -1
|
||||
// (or any other negative number) on the commandline. So the set
|
||||
// of possible values here is {-1, 0, ℤ+}
|
||||
return *parsedTarget;
|
||||
}
|
||||
else
|
||||
{
|
||||
// If the user did not provide any value on the commandline,
|
||||
// then lookup our windowing behavior to determine what to do
|
||||
// now.
|
||||
int32_t windowId = WindowingBehaviorUseNew;
|
||||
switch (windowingBehavior)
|
||||
{
|
||||
case WindowingMode::UseExisting:
|
||||
return WindowingBehaviorUseExisting;
|
||||
case WindowingMode::UseAnyExisting:
|
||||
return WindowingBehaviorUseAnyExisting;
|
||||
case WindowingMode::UseNew:
|
||||
default:
|
||||
return WindowingBehaviorUseNew;
|
||||
windowId = WindowingBehaviorUseNew;
|
||||
break;
|
||||
case WindowingMode::UseExisting:
|
||||
windowId = WindowingBehaviorUseExisting;
|
||||
break;
|
||||
case WindowingMode::UseAnyExisting:
|
||||
windowId = WindowingBehaviorUseAnyExisting;
|
||||
break;
|
||||
}
|
||||
return winrt::make<FindTargetWindowResult>(windowId);
|
||||
}
|
||||
|
||||
// Here, the user _has_ provided a window-id on the commandline.
|
||||
// What is it? Let's start by checking if it's an int, for the
|
||||
// window's ID:
|
||||
try
|
||||
{
|
||||
int32_t windowId = ::base::saturated_cast<int32_t>(std::stoi(parsedTarget));
|
||||
|
||||
// If the user provides _any_ negative number, then treat it as
|
||||
// -1, for "use a new window".
|
||||
if (windowId < 0)
|
||||
{
|
||||
windowId = -1;
|
||||
}
|
||||
|
||||
// Hooray! This is a valid integer. The set of possible values
|
||||
// here is {-1, 0, ℤ+}. Let's return that window ID.
|
||||
return winrt::make<FindTargetWindowResult>(windowId);
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
// Value was not a valid int. It could be any other string to
|
||||
// use as a title though!
|
||||
//
|
||||
// First, check the reserved keywords:
|
||||
if (parsedTarget == "new")
|
||||
{
|
||||
return winrt::make<FindTargetWindowResult>(WindowingBehaviorUseNew);
|
||||
}
|
||||
else if (parsedTarget == "last")
|
||||
{
|
||||
return winrt::make<FindTargetWindowResult>(WindowingBehaviorUseExisting);
|
||||
}
|
||||
else
|
||||
{
|
||||
// The string they provided wasn't an int, it wasn't "new"
|
||||
// or "last", so whatever it is, that's the name they get.
|
||||
winrt::hstring winrtName{ til::u8u16(parsedTarget) };
|
||||
return winrt::make<FindTargetWindowResult>(WindowingBehaviorUseName, winrtName);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1274,7 +1320,7 @@ namespace winrt::TerminalApp::implementation
|
|||
// create a new window. Then, in that new window, we'll try to set the
|
||||
// StartupActions, which will again fail, returning the correct error
|
||||
// message.
|
||||
return WindowingBehaviorUseNew;
|
||||
return winrt::make<FindTargetWindowResult>(WindowingBehaviorUseNew);
|
||||
}
|
||||
|
||||
// Method Description:
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@
|
|||
#pragma once
|
||||
|
||||
#include "AppLogic.g.h"
|
||||
#include "FindTargetWindowResult.g.h"
|
||||
#include "TerminalPage.h"
|
||||
#include "Jumplist.h"
|
||||
#include "../../cascadia/inc/cppwinrt_utils.h"
|
||||
|
|
@ -18,6 +19,19 @@ namespace TerminalAppLocalTests
|
|||
|
||||
namespace winrt::TerminalApp::implementation
|
||||
{
|
||||
struct FindTargetWindowResult : FindTargetWindowResultT<FindTargetWindowResult>
|
||||
{
|
||||
WINRT_PROPERTY(int32_t, WindowId, -1);
|
||||
WINRT_PROPERTY(winrt::hstring, WindowName, L"");
|
||||
|
||||
public:
|
||||
FindTargetWindowResult(const int32_t id, const winrt::hstring& name) :
|
||||
_WindowId{ id }, _WindowName{ name } {};
|
||||
|
||||
FindTargetWindowResult(const int32_t id) :
|
||||
FindTargetWindowResult(id, L""){};
|
||||
};
|
||||
|
||||
struct AppLogic : AppLogicT<AppLogic, IInitializeWithWindow>
|
||||
{
|
||||
public:
|
||||
|
|
@ -38,7 +52,7 @@ namespace winrt::TerminalApp::implementation
|
|||
|
||||
int32_t SetStartupCommandline(array_view<const winrt::hstring> actions);
|
||||
int32_t ExecuteCommandline(array_view<const winrt::hstring> actions, const winrt::hstring& cwd);
|
||||
int32_t FindTargetWindow(array_view<const winrt::hstring> actions);
|
||||
TerminalApp::FindTargetWindowResult FindTargetWindow(array_view<const winrt::hstring> actions);
|
||||
winrt::hstring ParseCommandlineMessage();
|
||||
bool ShouldExitEarly();
|
||||
|
||||
|
|
@ -98,8 +112,8 @@ namespace winrt::TerminalApp::implementation
|
|||
::TerminalApp::AppCommandlineArgs _appArgs;
|
||||
::TerminalApp::AppCommandlineArgs _settingsAppArgs;
|
||||
int _ParseArgs(winrt::array_view<const hstring>& args);
|
||||
static int32_t _doFindTargetWindow(winrt::array_view<const hstring> args,
|
||||
const Microsoft::Terminal::Settings::Model::WindowingMode& windowingBehavior);
|
||||
static TerminalApp::FindTargetWindowResult _doFindTargetWindow(winrt::array_view<const hstring> args,
|
||||
const Microsoft::Terminal::Settings::Model::WindowingMode& windowingBehavior);
|
||||
|
||||
void _ShowLoadErrorsDialog(const winrt::hstring& titleKey, const winrt::hstring& contentKey, HRESULT settingsLoadedResult);
|
||||
void _ShowLoadWarningsDialog();
|
||||
|
|
|
|||
|
|
@ -13,6 +13,12 @@ namespace TerminalApp
|
|||
Int64 Y;
|
||||
};
|
||||
|
||||
[default_interface] runtimeclass FindTargetWindowResult
|
||||
{
|
||||
Int32 WindowId { get; };
|
||||
String WindowName { get; };
|
||||
};
|
||||
|
||||
[default_interface] runtimeclass AppLogic : IDirectKeyListener, IDialogPresenter
|
||||
{
|
||||
AppLogic();
|
||||
|
|
@ -57,7 +63,7 @@ namespace TerminalApp
|
|||
UInt64 GetLastActiveControlTaskbarState();
|
||||
UInt64 GetLastActiveControlTaskbarProgress();
|
||||
|
||||
Int32 FindTargetWindow(String[] args);
|
||||
FindTargetWindowResult FindTargetWindow(String[] args);
|
||||
|
||||
// See IDialogPresenter and TerminalPage's DialogPresenter for more
|
||||
// information.
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@
|
|||
#include "../Remoting/CommandlineArgs.h"
|
||||
#include "../Remoting/FindTargetWindowArgs.h"
|
||||
#include "../Remoting/ProposeCommandlineResult.h"
|
||||
#include "../inc/WindowingBehavior.h"
|
||||
|
||||
using namespace Microsoft::Console;
|
||||
using namespace WEX::Logging;
|
||||
|
|
@ -50,6 +51,7 @@ namespace RemotingUnitTests
|
|||
DeadPeasant() = default;
|
||||
void AssignID(uint64_t /*id*/) { throw winrt::hresult_error{}; };
|
||||
uint64_t GetID() { throw winrt::hresult_error{}; };
|
||||
winrt::hstring WindowName() { throw winrt::hresult_error{}; };
|
||||
uint64_t GetPID() { throw winrt::hresult_error{}; };
|
||||
bool ExecuteCommandline(const Remoting::CommandlineArgs& /*args*/) { throw winrt::hresult_error{}; }
|
||||
void ActivateWindow(const Remoting::WindowActivatedArgs& /*args*/) { throw winrt::hresult_error{}; }
|
||||
|
|
@ -85,6 +87,14 @@ namespace RemotingUnitTests
|
|||
TEST_METHOD(GetMostRecentAnyDesktop);
|
||||
TEST_METHOD(MostRecentIsDead);
|
||||
|
||||
TEST_METHOD(GetPeasantsByName);
|
||||
TEST_METHOD(AddNamedPeasantsToNewMonarch);
|
||||
TEST_METHOD(LookupNamedPeasantWhenOthersDied);
|
||||
TEST_METHOD(LookupNamedPeasantWhenItDied);
|
||||
TEST_METHOD(GetMruPeasantAfterNameLookupForDeadPeasant);
|
||||
|
||||
TEST_METHOD(ProposeCommandlineForNamedDeadWindow);
|
||||
|
||||
TEST_CLASS_SETUP(ClassSetup)
|
||||
{
|
||||
return true;
|
||||
|
|
@ -95,6 +105,9 @@ namespace RemotingUnitTests
|
|||
|
||||
static void _findTargetWindowHelper(const winrt::Windows::Foundation::IInspectable& sender,
|
||||
const winrt::Microsoft::Terminal::Remoting::FindTargetWindowArgs& args);
|
||||
|
||||
static void _findTargetWindowByNameHelper(const winrt::Windows::Foundation::IInspectable& sender,
|
||||
const winrt::Microsoft::Terminal::Remoting::FindTargetWindowArgs& args);
|
||||
};
|
||||
|
||||
// Helper to replace the specified peasant in a monarch with a
|
||||
|
|
@ -126,6 +139,19 @@ namespace RemotingUnitTests
|
|||
}
|
||||
}
|
||||
|
||||
// Helper to get the first argument out of the commandline, and return it as
|
||||
// a name to use.
|
||||
void RemotingTests::_findTargetWindowByNameHelper(const winrt::Windows::Foundation::IInspectable& /*sender*/,
|
||||
const winrt::Microsoft::Terminal::Remoting::FindTargetWindowArgs& args)
|
||||
{
|
||||
const auto arguments = args.Args().Commandline();
|
||||
if (arguments.size() > 0)
|
||||
{
|
||||
args.ResultTargetWindow(WindowingBehaviorUseName);
|
||||
args.ResultTargetWindowName(arguments.at(0));
|
||||
}
|
||||
}
|
||||
|
||||
void RemotingTests::CreateMonarch()
|
||||
{
|
||||
auto m1 = winrt::make_self<Remoting::implementation::Monarch>();
|
||||
|
|
@ -978,4 +1004,352 @@ namespace RemotingUnitTests
|
|||
VERIFY_ARE_EQUAL(p1->GetID(), m0->_mruPeasants[0].PeasantID());
|
||||
}
|
||||
|
||||
void RemotingTests::GetPeasantsByName()
|
||||
{
|
||||
Log::Comment(L"Test that looking up a peasant by name finds the window we expect");
|
||||
|
||||
const auto monarch0PID = 12345u;
|
||||
const auto peasant1PID = 23456u;
|
||||
const auto peasant2PID = 34567u;
|
||||
|
||||
com_ptr<Remoting::implementation::Monarch> m0;
|
||||
m0.attach(new Remoting::implementation::Monarch(monarch0PID));
|
||||
|
||||
com_ptr<Remoting::implementation::Peasant> p1;
|
||||
p1.attach(new Remoting::implementation::Peasant(peasant1PID));
|
||||
|
||||
com_ptr<Remoting::implementation::Peasant> p2;
|
||||
p2.attach(new Remoting::implementation::Peasant(peasant2PID));
|
||||
|
||||
VERIFY_IS_NOT_NULL(m0);
|
||||
VERIFY_IS_NOT_NULL(p1);
|
||||
VERIFY_IS_NOT_NULL(p2);
|
||||
|
||||
p1->WindowName(L"one");
|
||||
p2->WindowName(L"two");
|
||||
|
||||
VERIFY_ARE_EQUAL(0, p1->GetID());
|
||||
VERIFY_ARE_EQUAL(0, p2->GetID());
|
||||
VERIFY_ARE_EQUAL(L"one", p1->WindowName());
|
||||
VERIFY_ARE_EQUAL(L"two", p2->WindowName());
|
||||
|
||||
m0->AddPeasant(*p1);
|
||||
m0->AddPeasant(*p2);
|
||||
|
||||
VERIFY_ARE_EQUAL(1, p1->GetID());
|
||||
VERIFY_ARE_EQUAL(2, p2->GetID());
|
||||
VERIFY_ARE_EQUAL(L"one", p1->WindowName());
|
||||
VERIFY_ARE_EQUAL(L"two", p2->WindowName());
|
||||
|
||||
VERIFY_ARE_EQUAL(p1->GetID(), m0->_lookupPeasantIdForName(L"one"));
|
||||
VERIFY_ARE_EQUAL(p2->GetID(), m0->_lookupPeasantIdForName(L"two"));
|
||||
|
||||
Log::Comment(L"Rename p2");
|
||||
|
||||
p2->WindowName(L"foo");
|
||||
|
||||
VERIFY_ARE_EQUAL(0, m0->_lookupPeasantIdForName(L"two"));
|
||||
VERIFY_ARE_EQUAL(p2->GetID(), m0->_lookupPeasantIdForName(L"foo"));
|
||||
}
|
||||
|
||||
void RemotingTests::AddNamedPeasantsToNewMonarch()
|
||||
{
|
||||
Log::Comment(L"Test that moving peasants to a new monarch persists their original names");
|
||||
|
||||
const auto monarch0PID = 12345u;
|
||||
const auto peasant1PID = 23456u;
|
||||
const auto peasant2PID = 34567u;
|
||||
const auto monarch3PID = 45678u;
|
||||
|
||||
com_ptr<Remoting::implementation::Monarch> m0;
|
||||
m0.attach(new Remoting::implementation::Monarch(monarch0PID));
|
||||
|
||||
com_ptr<Remoting::implementation::Peasant> p1;
|
||||
p1.attach(new Remoting::implementation::Peasant(peasant1PID));
|
||||
|
||||
com_ptr<Remoting::implementation::Peasant> p2;
|
||||
p2.attach(new Remoting::implementation::Peasant(peasant2PID));
|
||||
|
||||
com_ptr<Remoting::implementation::Monarch> m3;
|
||||
m3.attach(new Remoting::implementation::Monarch(monarch3PID));
|
||||
|
||||
VERIFY_IS_NOT_NULL(m0);
|
||||
VERIFY_IS_NOT_NULL(p1);
|
||||
VERIFY_IS_NOT_NULL(p2);
|
||||
VERIFY_IS_NOT_NULL(m3);
|
||||
|
||||
p1->WindowName(L"one");
|
||||
p2->WindowName(L"two");
|
||||
|
||||
VERIFY_ARE_EQUAL(0, p1->GetID());
|
||||
VERIFY_ARE_EQUAL(0, p2->GetID());
|
||||
|
||||
m0->AddPeasant(*p1);
|
||||
m0->AddPeasant(*p2);
|
||||
|
||||
VERIFY_ARE_EQUAL(p1->GetID(), m0->_lookupPeasantIdForName(L"one"));
|
||||
VERIFY_ARE_EQUAL(p2->GetID(), m0->_lookupPeasantIdForName(L"two"));
|
||||
|
||||
VERIFY_ARE_EQUAL(1, p1->GetID());
|
||||
VERIFY_ARE_EQUAL(2, p2->GetID());
|
||||
VERIFY_ARE_EQUAL(L"one", p1->WindowName());
|
||||
VERIFY_ARE_EQUAL(L"two", p2->WindowName());
|
||||
|
||||
Log::Comment(L"When the peasants go to a new monarch, make sure they have the same name");
|
||||
m3->AddPeasant(*p1);
|
||||
m3->AddPeasant(*p2);
|
||||
|
||||
VERIFY_ARE_EQUAL(1, p1->GetID());
|
||||
VERIFY_ARE_EQUAL(2, p2->GetID());
|
||||
VERIFY_ARE_EQUAL(L"one", p1->WindowName());
|
||||
VERIFY_ARE_EQUAL(L"two", p2->WindowName());
|
||||
|
||||
VERIFY_ARE_EQUAL(p1->GetID(), m3->_lookupPeasantIdForName(L"one"));
|
||||
VERIFY_ARE_EQUAL(p2->GetID(), m3->_lookupPeasantIdForName(L"two"));
|
||||
}
|
||||
|
||||
void RemotingTests::LookupNamedPeasantWhenOthersDied()
|
||||
{
|
||||
Log::Comment(L"Test that looking for a peasant by name when a different"
|
||||
L" peasant has died cleans up the corpses of any peasants "
|
||||
L"we may have tripped over.");
|
||||
|
||||
const auto monarch0PID = 12345u;
|
||||
const auto peasant1PID = 23456u;
|
||||
const auto peasant2PID = 34567u;
|
||||
|
||||
com_ptr<Remoting::implementation::Monarch> m0;
|
||||
m0.attach(new Remoting::implementation::Monarch(monarch0PID));
|
||||
|
||||
com_ptr<Remoting::implementation::Peasant> p1;
|
||||
p1.attach(new Remoting::implementation::Peasant(peasant1PID));
|
||||
|
||||
com_ptr<Remoting::implementation::Peasant> p2;
|
||||
p2.attach(new Remoting::implementation::Peasant(peasant2PID));
|
||||
|
||||
VERIFY_IS_NOT_NULL(m0);
|
||||
VERIFY_IS_NOT_NULL(p1);
|
||||
VERIFY_IS_NOT_NULL(p2);
|
||||
p1->WindowName(L"one");
|
||||
p2->WindowName(L"two");
|
||||
|
||||
VERIFY_ARE_EQUAL(0, p1->GetID());
|
||||
VERIFY_ARE_EQUAL(0, p2->GetID());
|
||||
|
||||
m0->AddPeasant(*p1);
|
||||
m0->AddPeasant(*p2);
|
||||
|
||||
VERIFY_ARE_EQUAL(1, p1->GetID());
|
||||
VERIFY_ARE_EQUAL(2, p2->GetID());
|
||||
|
||||
VERIFY_ARE_EQUAL(2u, m0->_peasants.size());
|
||||
|
||||
VERIFY_ARE_EQUAL(p1->GetID(), m0->_lookupPeasantIdForName(L"one"));
|
||||
VERIFY_ARE_EQUAL(p2->GetID(), m0->_lookupPeasantIdForName(L"two"));
|
||||
|
||||
Log::Comment(L"Kill peasant 1. Make sure that it gets removed from the monarch.");
|
||||
RemotingTests::_killPeasant(m0, p1->GetID());
|
||||
|
||||
// By killing 1, then looking for "two", we happen to iterate over the
|
||||
// corpse of 1 when looking for the peasant named "two". This causes us
|
||||
// to remove 1 while looking for "two". Technically, we shouldn't be
|
||||
// relying on any sort of ordering for an unordered_map iterator, but
|
||||
// this one just so happens to work.
|
||||
VERIFY_ARE_EQUAL(p2->GetID(), m0->_lookupPeasantIdForName(L"two"));
|
||||
|
||||
Log::Comment(L"Peasant 1 should have been pruned");
|
||||
VERIFY_ARE_EQUAL(1u, m0->_peasants.size());
|
||||
}
|
||||
|
||||
void RemotingTests::LookupNamedPeasantWhenItDied()
|
||||
{
|
||||
Log::Comment(L"Test that looking up a dead peasant by name returns 0, "
|
||||
L"indicating there's no peasant with that name.");
|
||||
|
||||
const auto monarch0PID = 12345u;
|
||||
const auto peasant1PID = 23456u;
|
||||
const auto peasant2PID = 34567u;
|
||||
|
||||
com_ptr<Remoting::implementation::Monarch> m0;
|
||||
m0.attach(new Remoting::implementation::Monarch(monarch0PID));
|
||||
|
||||
com_ptr<Remoting::implementation::Peasant> p1;
|
||||
p1.attach(new Remoting::implementation::Peasant(peasant1PID));
|
||||
|
||||
com_ptr<Remoting::implementation::Peasant> p2;
|
||||
p2.attach(new Remoting::implementation::Peasant(peasant2PID));
|
||||
|
||||
VERIFY_IS_NOT_NULL(m0);
|
||||
VERIFY_IS_NOT_NULL(p1);
|
||||
VERIFY_IS_NOT_NULL(p2);
|
||||
p1->WindowName(L"one");
|
||||
p2->WindowName(L"two");
|
||||
|
||||
VERIFY_ARE_EQUAL(0, p1->GetID());
|
||||
VERIFY_ARE_EQUAL(0, p2->GetID());
|
||||
|
||||
m0->AddPeasant(*p1);
|
||||
m0->AddPeasant(*p2);
|
||||
|
||||
VERIFY_ARE_EQUAL(1, p1->GetID());
|
||||
VERIFY_ARE_EQUAL(2, p2->GetID());
|
||||
|
||||
VERIFY_ARE_EQUAL(2u, m0->_peasants.size());
|
||||
|
||||
VERIFY_ARE_EQUAL(p1->GetID(), m0->_lookupPeasantIdForName(L"one"));
|
||||
VERIFY_ARE_EQUAL(p2->GetID(), m0->_lookupPeasantIdForName(L"two"));
|
||||
|
||||
Log::Comment(L"Kill peasant 1. Make sure that it gets removed from the monarch.");
|
||||
RemotingTests::_killPeasant(m0, p1->GetID());
|
||||
|
||||
VERIFY_ARE_EQUAL(0, m0->_lookupPeasantIdForName(L"one"));
|
||||
|
||||
Log::Comment(L"Peasant 1 should have been pruned");
|
||||
VERIFY_ARE_EQUAL(1u, m0->_peasants.size());
|
||||
VERIFY_ARE_EQUAL(p2->GetID(), m0->_lookupPeasantIdForName(L"two"));
|
||||
}
|
||||
void RemotingTests::GetMruPeasantAfterNameLookupForDeadPeasant()
|
||||
{
|
||||
// This test is trying to hit the catch in Monarch::_lookupPeasantIdForName.
|
||||
//
|
||||
// We need to:
|
||||
// * add some peasants,
|
||||
// * make one the mru, then make a named two the mru
|
||||
// * then kill two
|
||||
// * then try to get the mru peasant -> it should be one
|
||||
|
||||
const winrt::guid guid1{ Utils::GuidFromString(L"{11111111-1111-1111-1111-111111111111}") };
|
||||
const auto monarch0PID = 12345u;
|
||||
const auto peasant1PID = 23456u;
|
||||
const auto peasant2PID = 34567u;
|
||||
|
||||
com_ptr<Remoting::implementation::Monarch> m0;
|
||||
m0.attach(new Remoting::implementation::Monarch(monarch0PID));
|
||||
|
||||
com_ptr<Remoting::implementation::Peasant> p1;
|
||||
p1.attach(new Remoting::implementation::Peasant(peasant1PID));
|
||||
|
||||
com_ptr<Remoting::implementation::Peasant> p2;
|
||||
p2.attach(new Remoting::implementation::Peasant(peasant2PID));
|
||||
|
||||
VERIFY_IS_NOT_NULL(m0);
|
||||
VERIFY_IS_NOT_NULL(p1);
|
||||
VERIFY_IS_NOT_NULL(p2);
|
||||
p1->WindowName(L"one");
|
||||
p2->WindowName(L"two");
|
||||
|
||||
VERIFY_ARE_EQUAL(0, p1->GetID());
|
||||
VERIFY_ARE_EQUAL(0, p2->GetID());
|
||||
|
||||
m0->AddPeasant(*p1);
|
||||
m0->AddPeasant(*p2);
|
||||
|
||||
VERIFY_ARE_EQUAL(1, p1->GetID());
|
||||
VERIFY_ARE_EQUAL(2, p2->GetID());
|
||||
|
||||
VERIFY_ARE_EQUAL(2u, m0->_peasants.size());
|
||||
|
||||
VERIFY_ARE_EQUAL(p1->GetID(), m0->_lookupPeasantIdForName(L"one"));
|
||||
VERIFY_ARE_EQUAL(p2->GetID(), m0->_lookupPeasantIdForName(L"two"));
|
||||
|
||||
{
|
||||
Log::Comment(L"Activate the first peasant, first desktop");
|
||||
Remoting::WindowActivatedArgs activatedArgs{ p1->GetID(),
|
||||
guid1,
|
||||
winrt::clock().now() };
|
||||
p1->ActivateWindow(activatedArgs);
|
||||
}
|
||||
{
|
||||
Log::Comment(L"Activate the second peasant, first desktop");
|
||||
Remoting::WindowActivatedArgs activatedArgs{ p2->GetID(),
|
||||
guid1,
|
||||
winrt::clock().now() };
|
||||
p2->ActivateWindow(activatedArgs);
|
||||
}
|
||||
Log::Comment(L"Kill peasant 2.");
|
||||
RemotingTests::_killPeasant(m0, p2->GetID());
|
||||
|
||||
VERIFY_ARE_EQUAL(p1->GetID(), m0->_getMostRecentPeasantID(false));
|
||||
VERIFY_ARE_EQUAL(p1->GetID(), m0->_getMostRecentPeasantID(true));
|
||||
}
|
||||
|
||||
void RemotingTests::ProposeCommandlineForNamedDeadWindow()
|
||||
{
|
||||
Log::Comment(L"Test proposing a commandline for a named window that's "
|
||||
L"currently dead. This should result in a new window with "
|
||||
L"the given name.");
|
||||
|
||||
const auto monarch0PID = 12345u;
|
||||
const auto peasant1PID = 23456u;
|
||||
const auto peasant2PID = 34567u;
|
||||
|
||||
com_ptr<Remoting::implementation::Monarch> m0;
|
||||
m0.attach(new Remoting::implementation::Monarch(monarch0PID));
|
||||
VERIFY_IS_NOT_NULL(m0);
|
||||
m0->FindTargetWindowRequested(&RemotingTests::_findTargetWindowByNameHelper);
|
||||
|
||||
com_ptr<Remoting::implementation::Peasant> p1;
|
||||
p1.attach(new Remoting::implementation::Peasant(peasant1PID));
|
||||
|
||||
com_ptr<Remoting::implementation::Peasant> p2;
|
||||
p2.attach(new Remoting::implementation::Peasant(peasant2PID));
|
||||
|
||||
VERIFY_IS_NOT_NULL(m0);
|
||||
VERIFY_IS_NOT_NULL(p1);
|
||||
VERIFY_IS_NOT_NULL(p2);
|
||||
p1->WindowName(L"one");
|
||||
p2->WindowName(L"two");
|
||||
|
||||
VERIFY_ARE_EQUAL(0, p1->GetID());
|
||||
VERIFY_ARE_EQUAL(0, p2->GetID());
|
||||
|
||||
p1->ExecuteCommandlineRequested([&](auto&&, const Remoting::CommandlineArgs& cmdlineArgs) {
|
||||
Log::Comment(L"Commandline dispatched to p1");
|
||||
VERIFY_IS_GREATER_THAN(cmdlineArgs.Commandline().size(), 1u);
|
||||
VERIFY_ARE_EQUAL(L"arg[1]", cmdlineArgs.Commandline().at(1));
|
||||
});
|
||||
p2->ExecuteCommandlineRequested([&](auto&&, const Remoting::CommandlineArgs& cmdlineArgs) {
|
||||
Log::Comment(L"Commandline dispatched to p2");
|
||||
VERIFY_IS_GREATER_THAN(cmdlineArgs.Commandline().size(), 1u);
|
||||
VERIFY_ARE_EQUAL(L"this is for p2", cmdlineArgs.Commandline().at(1));
|
||||
});
|
||||
|
||||
p1->WindowName(L"one");
|
||||
p2->WindowName(L"two");
|
||||
|
||||
m0->AddPeasant(*p1);
|
||||
m0->AddPeasant(*p2);
|
||||
|
||||
std::vector<winrt::hstring> p1Args{ L"one", L"arg[1]" };
|
||||
std::vector<winrt::hstring> p2Args{ L"two", L"this is for p2" };
|
||||
|
||||
{
|
||||
Remoting::CommandlineArgs eventArgs{ { p1Args }, { L"" } };
|
||||
auto result = m0->ProposeCommandline(eventArgs);
|
||||
VERIFY_ARE_EQUAL(false, result.ShouldCreateWindow());
|
||||
VERIFY_ARE_EQUAL(false, (bool)result.Id()); // Casting to (bool) checks if the reference has a value
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
}
|
||||
|
||||
{
|
||||
Log::Comment(L"Send a commandline to \"two\", which should be p2");
|
||||
Remoting::CommandlineArgs eventArgs{ { p2Args }, { L"" } };
|
||||
auto result = m0->ProposeCommandline(eventArgs);
|
||||
VERIFY_ARE_EQUAL(false, result.ShouldCreateWindow());
|
||||
VERIFY_ARE_EQUAL(false, (bool)result.Id()); // Casting to (bool) checks if the reference has a value
|
||||
VERIFY_ARE_EQUAL(L"", result.WindowName());
|
||||
}
|
||||
|
||||
Log::Comment(L"Kill peasant 2.");
|
||||
RemotingTests::_killPeasant(m0, p2->GetID());
|
||||
|
||||
{
|
||||
Log::Comment(L"Send a commandline to \"two\", who is now dead.");
|
||||
Remoting::CommandlineArgs eventArgs{ { p2Args }, { L"" } };
|
||||
auto result = m0->ProposeCommandline(eventArgs);
|
||||
VERIFY_ARE_EQUAL(true, result.ShouldCreateWindow());
|
||||
VERIFY_ARE_EQUAL(false, (bool)result.Id()); // Casting to (bool) checks if the reference has a value
|
||||
VERIFY_ARE_EQUAL(L"two", result.WindowName());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -566,7 +566,8 @@ void AppHost::_FindTargetWindow(const winrt::Windows::Foundation::IInspectable&
|
|||
const Remoting::FindTargetWindowArgs& args)
|
||||
{
|
||||
const auto targetWindow = _logic.FindTargetWindow(args.Args().Commandline());
|
||||
args.ResultTargetWindow(targetWindow);
|
||||
args.ResultTargetWindow(targetWindow.WindowId());
|
||||
args.ResultTargetWindowName(targetWindow.WindowName());
|
||||
}
|
||||
|
||||
winrt::fire_and_forget AppHost::_WindowActivated()
|
||||
|
|
|
|||
|
|
@ -4,7 +4,8 @@ Licensed under the MIT license.
|
|||
--*/
|
||||
|
||||
#pragma once
|
||||
constexpr int64_t WindowingBehaviorUseCurrent{ 0 };
|
||||
constexpr int64_t WindowingBehaviorUseNew{ -1 };
|
||||
constexpr int64_t WindowingBehaviorUseExisting{ -2 };
|
||||
constexpr int64_t WindowingBehaviorUseAnyExisting{ -3 };
|
||||
constexpr int32_t WindowingBehaviorUseCurrent{ 0 };
|
||||
constexpr int32_t WindowingBehaviorUseNew{ -1 };
|
||||
constexpr int32_t WindowingBehaviorUseExisting{ -2 };
|
||||
constexpr int32_t WindowingBehaviorUseAnyExisting{ -3 };
|
||||
constexpr int32_t WindowingBehaviorUseName{ -4 };
|
||||
|
|
|
|||
Loading…
Reference in a new issue