From b62f5ea85051fbe38d467cccca4d4de42d29ae8c Mon Sep 17 00:00:00 2001 From: Leonard Hecker Date: Thu, 16 Jul 2020 22:49:06 +0200 Subject: [PATCH 01/33] Added til::spsc, a lock-free, single-producer/-consumer FIFO queue (#6751) ## Summary of the Pull Request This PR adds the `til::spsc` namespace, which implements a lock-free, single-producer, single-consumer FIFO queue ("channel"). The queue efficiently blocks the caller using Futexes if no data can be written to / read from the queue (e.g. using `WaitOnAddress` on Windows). Furthermore it allows batching of data and contains logic to signal the caller if the other side has been dropped/destructed. ## PR Checklist * [ ] Closes #xxx * [x] CLA signed. If not, go over [here](https://cla.opensource.microsoft.com/microsoft/Terminal) and sign the CLA * [x] Tests added/passed * [ ] Documentation updated. If checked, please file a pull request on [our docs repo](https://github.com/MicrosoftDocs/terminal) and link it here: #xxx * [ ] Schema updated. * [x] I've discussed this with core contributors already. If not checked, I'm ready to accept this work might be rejected in favor of a different grand plan. Issue number where discussion took place: #xxx ## Detailed Description of the Pull Request / Additional comments `til::spsc::details::arc` contains most of the queue's logic and as such has the relevant documentation for its design. ## Validation Steps Performed The queue was tested on Windows, Linux and macOS using MSVC, gcc and llvm and each of their available runtime introspection utilities in order to ensure no race conditions or memory leaks occur. --- .../actions/spell-check/dictionary/apis.txt | 7 + src/inc/til.h | 1 + src/inc/til/spsc.h | 643 ++++++++++++++++++ src/til/ut_til/SPSCTests.cpp | 194 ++++++ src/til/ut_til/til.unit.tests.vcxproj | 1 + src/til/ut_til/til.unit.tests.vcxproj.filters | 1 + 6 files changed, 847 insertions(+) create mode 100644 src/inc/til/spsc.h create mode 100644 src/til/ut_til/SPSCTests.cpp diff --git a/.github/actions/spell-check/dictionary/apis.txt b/.github/actions/spell-check/dictionary/apis.txt index fdb6a2dcd05..88494b86f64 100644 --- a/.github/actions/spell-check/dictionary/apis.txt +++ b/.github/actions/spell-check/dictionary/apis.txt @@ -1,11 +1,13 @@ ACCEPTFILES ACCESSDENIED +alignof bitfield bitfields CLASSNOTAVAILABLE EXPCMDFLAGS EXPCMDSTATE fullkbd +futex href IAsync IBind @@ -33,5 +35,10 @@ RETURNCMD rfind roundf RSHIFT +rx SIZENS +spsc +STDCPP +syscall tmp +tx diff --git a/src/inc/til.h b/src/inc/til.h index b1773062cbc..e9504535708 100644 --- a/src/inc/til.h +++ b/src/inc/til.h @@ -15,6 +15,7 @@ #include "til/rectangle.h" #include "til/bitmap.h" #include "til/u8u16convert.h" +#include "til/spsc.h" namespace til // Terminal Implementation Library. Also: "Today I Learned" { diff --git a/src/inc/til/spsc.h b/src/inc/til/spsc.h new file mode 100644 index 00000000000..374306637fb --- /dev/null +++ b/src/inc/til/spsc.h @@ -0,0 +1,643 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +#pragma once + +// til::spsc::details::arc requires std::atomic::wait() and ::notify_one() and at the time of writing no +// STL supports these. Since both Windows and Linux offer a Futex implementation we can easily implement this though. +// On other platforms we fall back to using a std::condition_variable. +#if __cpp_lib_atomic_wait >= 201907 +#define _TIL_SPSC_DETAIL_POSITION_IMPL_NATIVE 1 +#elif defined(_WIN32_WINNT) && _WIN32_WINNT >= _WIN32_WINNT_WIN8 +#define _TIL_SPSC_DETAIL_POSITION_IMPL_WIN 1 +#elif __linux__ +#define _TIL_SPSC_DETAIL_POSITION_IMPL_LINUX 1 +#else +#define _TIL_SPSC_DETAIL_POSITION_IMPL_FALLBACK 1 +#endif + +// til: Terminal Implementation Library. Also: "Today I Learned". +// spsc: Single Producer Single Consumer. A SPSC queue/channel sends data from exactly one sender to one receiver. +namespace til::spsc +{ + using size_type = uint32_t; + + namespace details + { + static constexpr size_type position_mask = std::numeric_limits::max() >> 2u; // 0b00111.... + static constexpr size_type revolution_flag = 1u << (std::numeric_limits::digits - 2u); // 0b01000.... + static constexpr size_type drop_flag = 1u << (std::numeric_limits::digits - 1u); // 0b10000.... + + struct block_initially_policy + { + using _spsc_policy = int; + static constexpr bool _block_forever = false; + }; + + struct block_forever_policy + { + using _spsc_policy = int; + static constexpr bool _block_forever = true; + }; + + template + using enable_if_wait_policy_t = typename std::remove_reference_t::_spsc_policy; + +#if _TIL_SPSC_DETAIL_POSITION_IMPL_NATIVE + using atomic_size_type = std::atomic; +#else + // atomic_size_type is a fallback if native std::atomic::wait() + // and ::notify_one() methods are unavailable in the STL. + struct atomic_size_type + { + size_type load(std::memory_order order) const noexcept + { + return _value.load(order); + } + + void store(size_type desired, std::memory_order order) noexcept + { +#if _TIL_SPSC_DETAIL_POSITION_IMPL_FALLBACK + // We must use a lock here to prevent us from modifying the value + // in between wait() reading the value and the thread being suspended. + std::lock_guard lock{ _m }; +#endif + _value.store(desired, order); + } + + void wait(size_type old, [[maybe_unused]] std::memory_order order) const noexcept + { +#if _TIL_SPSC_DETAIL_POSITION_IMPL_WIN +#pragma warning(suppress : 26492) // Don't use const_cast to cast away const or volatile + WaitOnAddress(const_cast*>(&_value), &old, sizeof(_value), INFINITE); +#elif _TIL_SPSC_DETAIL_POSITION_IMPL_LINUX + futex(FUTEX_WAIT_PRIVATE, old); +#elif _TIL_SPSC_DETAIL_POSITION_IMPL_FALLBACK + std::unique_lock lock{ _m }; + _cv.wait(lock, [&]() { return _value.load(order) != old; }); +#endif + } + + void notify_one() noexcept + { +#if _TIL_SPSC_DETAIL_POSITION_IMPL_WIN + WakeByAddressSingle(&_value); +#elif _TIL_SPSC_DETAIL_POSITION_IMPL_LINUX + futex(FUTEX_WAKE_PRIVATE, 1); +#elif _TIL_SPSC_DETAIL_POSITION_IMPL_FALLBACK + _cv.notify_one(); +#endif + } + + private: +#if _TIL_SPSC_DETAIL_POSITION_IMPL_LINUX + inline void futex(int futex_op, size_type val) const noexcept + { + // See: https://man7.org/linux/man-pages/man2/futex.2.html + static_assert(sizeof(std::atomic) == 4); + syscall(SYS_futex, &_value, futex_op, val, nullptr, nullptr, 0); + } +#endif + + std::atomic _value{ 0 }; + +#if _TIL_SPSC_DETAIL_POSITION_IMPL_FALLBACK + private: + std::mutex _m; + std::condition_variable _cv; +#endif + }; +#endif + + template + inline T* alloc_raw_memory(size_t size) + { + constexpr auto alignment = alignof(T); + if constexpr (alignment <= __STDCPP_DEFAULT_NEW_ALIGNMENT__) + { + return static_cast(::operator new(size)); + } + else + { + return static_cast(::operator new(size, std::align_val_t(alignment))); + } + } + + template + inline void free_raw_memory(T* ptr) noexcept + { + constexpr auto alignment = alignof(T); + if constexpr (alignment <= __STDCPP_DEFAULT_NEW_ALIGNMENT__) + { + ::operator delete(ptr); + } + else + { + ::operator delete(ptr, std::align_val_t(alignment)); + } + } + + struct acquisition + { + // The index range [begin, end) is the range of slots in the array returned by + // arc::data() that may be written to / read from respectively. + // If a range has been successfully acquired "end > begin" is true. end thus can't be 0. + size_type begin; + size_type end; + + // Upon release() of an acquisition, next is the value that's written to the consumer/producer position. + // It's basically the same as end, but with the revolution flag mixed in. + // If end is equal to capacity, next will be 0 (mixed with the next revolution flag). + size_type next; + + // If the other side of the queue hasn't been destroyed yet, alive will be true. + bool alive; + + constexpr acquisition(size_type begin, size_type end, size_type next, bool alive) : + begin(begin), + end(end), + next(next), + alive(alive) + { + } + }; + + // The following assumes you know what ring/circular buffers are. You can read about them here: + // https://en.wikipedia.org/wiki/Circular_buffer + // + // Furthermore the implementation solves a problem known as the producer-consumer problem: + // https://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem + // + // arc follows the classic spsc design and manages a ring buffer with two positions: _producer and _consumer. + // They contain the position the producer / consumer will next write to / read from respectively. + // As usual with ring buffers, these positions are modulo to the _capacity of the underlying buffer. + // The producer's writable range is [_producer, _consumer) and the consumer's readable is [_consumer, _producer). + // + // After you wrote the numbers 0 to 6 into a queue of size 10, a typical state of the ring buffer might be: + // [ 0 | 1 | 2 | 3 | 4 | 5 | 6 | _ | _ | _ | _ ] + // ^ ^ ^ + // _consumer = 0 _producer = 7 _capacity = 10 + // + // As you can see the readable range currently is [_consumer, _producer) = [0, 7). + // The remaining writable range on the other hand is [_producer, _consumer) = [7, 0). + // Wait, what? [7, 0)? How does that work? As all positions are modulo _capacity, 0 mod 10 is the same as 10 mod 10. + // If we only want to read forward in the buffer [7, 0) is thus the same as [7, 10). + // + // If we read 3 items from the queue the contents will be: + // [ _ | _ | _ | 3 | 4 | 5 | 6 | _ | _ | _ | _ ] + // ^ ^ + // _consumer = 3 _producer = 7 + // + // Now the writable range is still [_producer, _consumer), but it wraps around the end of the ring buffer. + // In this case arc will split the range in two and return each separately in acquire(). + // The first returned range will be [_producer, _capacity) and the second [0, _consumer). + // The same logic applies if the readable range wraps around the end of the ring buffer. + // + // As these are symmetric, the logic for acquiring and releasing ranges is the same for both sides. + // The producer will acquire() and release() ranges with its own position as "mine" and the consumer's + // position as "theirs". These arguments are correspondingly flipped for the consumer. + // + // As part of the producer-consumer problem, the producer cannot write more values ahead of the + // consumer than the buffer's capacity. Since both positions are modulo to the capacity we can only + // determine positional differences smaller than the capacity. Due to that both producer and + // consumer store a "revolution_flag" as the second highest bit within their positions. + // This bit is flipped each time the producer/consumer wrap around the end of the ring buffer. + // If the positions are identical, except for their "revolution_flag" value, the producer thus must + // be capacity-many positions ahead of the consumer and must wait until items have been consumed. + // + // Inversely the consumer must wait until the producer has written at least one value ahead. + // This can be detected by checking whether the positions are identical including the revolution_flag. + template + struct arc + { + explicit arc(size_type capacity) noexcept : + _data(alloc_raw_memory(size_t(capacity) * sizeof(T))), + _capacity(capacity) + { + } + + ~arc() + { + auto beg = _consumer.load(std::memory_order_acquire); + auto end = _producer.load(std::memory_order_acquire); + auto differentRevolution = ((beg ^ end) & revolution_flag) != 0; + + beg &= position_mask; + end &= position_mask; + + // The producer position will always be ahead of the consumer, but since we're dealing + // with a ring buffer the producer may be wrapped around the end of the buffer. + // We thus need to deal with 3 potential cases: + // * No valid data. + // If both positions including their revolution bits are identical. + // * Valid data in the middle of the ring buffer. + // If _producer > _consumer. + // * Valid data at both ends of the ring buffer. + // If the revolution bits differ, even if the positions are otherwise identical, + // which they might be if the channel contains exactly as many values as its capacity. + if (end > beg) + { + std::destroy(_data + beg, _data + end); + } + else if (differentRevolution) + { + std::destroy(_data, _data + end); + std::destroy(_data + beg, _data + _capacity); + } + + free_raw_memory(_data); + } + + void drop_producer() + { + drop(_producer); + } + + void drop_consumer() + { + drop(_consumer); + } + + acquisition producer_acquire(size_type slots, bool blocking) noexcept + { + return acquire(_producer, _consumer, revolution_flag, slots, blocking); + } + + void producer_release(acquisition acquisition) noexcept + { + release(_producer, acquisition); + } + + acquisition consumer_acquire(size_type slots, bool blocking) noexcept + { + return acquire(_consumer, _producer, 0, slots, blocking); + } + + void consumer_release(acquisition acquisition) noexcept + { + release(_consumer, acquisition); + } + + T* data() const noexcept + { + return _data; + } + + private: + void drop(atomic_size_type& mine) + { + // Signal the other side we're dropped. See acquire() for the handling of the drop_flag. + // We don't need to use release ordering like release() does as each call to + // any of the producer/consumer methods already results in a call to release(). + // Another release ordered write can't possibly synchronize any more data anyways at this point. + const auto myPos = mine.load(std::memory_order_relaxed); + mine.store(myPos | drop_flag, std::memory_order_relaxed); + mine.notify_one(); + + // The first time SPSCBase is dropped (destroyed) we'll set + // the flag to true and get false, causing us to return early. + // Only the second time we'll get true. + // --> The contents are only deleted when both sides have been dropped. + if (_eitherSideDropped.exchange(true, std::memory_order_relaxed)) + { + delete this; + } + } + + // NOTE: waitMask MUST be either 0 (consumer) or revolution_flag (producer). + acquisition acquire(atomic_size_type& mine, atomic_size_type& theirs, size_type waitMask, size_type slots, bool blocking) noexcept + { + size_type myPos = mine.load(std::memory_order_relaxed); + size_type theirPos; + + while (true) + { + // This acquire read synchronizes with the release write in release(). + theirPos = theirs.load(std::memory_order_acquire); + if ((myPos ^ theirPos) != waitMask) + { + break; + } + if (!blocking) + { + return { + 0, + 0, + 0, + true, + }; + } + + theirs.wait(theirPos, std::memory_order_relaxed); + } + + // If the other side's position contains a drop flag, as a X -> we need to... + // * producer -> stop immediately + // FYI: isProducer == (waitMask != 0). + // * consumer -> finish consuming all values and then stop + // We're finished if the only difference between our + // and the other side's position is the drop flag. + if ((theirPos & drop_flag) != 0 && (waitMask != 0 || (myPos ^ theirPos) == drop_flag)) + { + return { + 0, + 0, + 0, + false, + }; + } + + auto begin = myPos & position_mask; + auto end = theirPos & position_mask; + + // [begin, end) is the writable/readable range for the producer/consumer. + // The following detects whether we'd be wrapping around the end of the ring buffer + // and splits the range into the first half [mine, _capacity). + // If acquire() is called again it'll return [0, theirs). + end = end > begin ? end : _capacity; + + // Of course we also need to ensure to not return more than we've been asked for. + end = std::min(end, begin + slots); + + // "next" will contain the value that's stored into "mine" when release() is called. + // It's basically the same as "end", but with the revolution flag spliced in. + // If we acquired the range [mine, _capacity) "end" will equal _capacity + // and thus wrap around the ring buffer. The next value for "mine" is thus the + // position zero | the flipped "revolution" (and 0 | x == x). + auto revolution = myPos & revolution_flag; + auto next = end != _capacity ? end | revolution : revolution ^ revolution_flag; + + return { + begin, + end, + next, + true, + }; + } + + void release(atomic_size_type& mine, acquisition acquisition) noexcept + { + // This release write synchronizes with the acquire read in acquire(). + mine.store(acquisition.next, std::memory_order_release); + mine.notify_one(); + } + + T* const _data; + const size_type _capacity; + + std::atomic _eitherSideDropped{ false }; + + atomic_size_type _producer; + atomic_size_type _consumer; + }; + + inline void validate_size(size_t v) + { + if (v > static_cast(position_mask)) + { + throw std::overflow_error{ "size too large for spsc" }; + } + } + } + + // Block until at least one item has been written into the sender / read from the receiver. + inline constexpr details::block_initially_policy block_initially{}; + + // Block until all items have been written into the sender / read from the receiver. + inline constexpr details::block_forever_policy block_forever{}; + + template + struct producer + { + explicit producer(details::arc* arc) noexcept : + _arc(arc) {} + + producer(const producer&) = delete; + producer& operator=(const producer&) = delete; + + producer(producer&& other) noexcept + { + drop(); + _arc = std::exchange(other._arc, nullptr); + } + + producer& operator=(producer&& other) noexcept + { + drop(); + _arc = std::exchange(other._arc, nullptr); + } + + ~producer() + { + drop(); + } + + // emplace constructs an item in-place at the end of the queue. + // It returns true, if the item was successfully placed within the queue. + // The return value will be false, if the consumer is gone. + template + bool emplace(Args&&... args) const + { + auto acquisition = _arc->producer_acquire(1, true); + if (!acquisition.end) + { + return false; + } + + auto data = _arc->data(); + auto begin = data + acquisition.begin; + new (begin) T(std::forward(args)...); + + _arc->producer_release(acquisition); + return true; + } + + template + std::pair push(InputIt first, InputIt last) const + { + return push_n(block_forever, first, std::distance(first, last)); + } + + // push writes the items between first and last into the queue. + // The amount of successfully written items is returned as the first pair field. + // The second pair field will be false if the consumer is gone. + template = 0> + std::pair push(WaitPolicy&& policy, InputIt first, InputIt last) const + { + return push_n(std::forward(policy), first, std::distance(first, last)); + } + + template + std::pair push_n(InputIt first, size_t count) const + { + return push_n(block_forever, first, count); + } + + // push_n writes count items from first into the queue. + // The amount of successfully written items is returned as the first pair field. + // The second pair field will be false if the consumer is gone. + template = 0> + std::pair push_n(WaitPolicy&&, InputIt first, size_t count) const + { + details::validate_size(count); + + const auto data = _arc->data(); + auto remaining = static_cast(count); + auto blocking = true; + auto ok = true; + + while (remaining != 0) + { + auto acquisition = _arc->producer_acquire(remaining, blocking); + if (!acquisition.end) + { + ok = acquisition.alive; + break; + } + + const auto begin = data + acquisition.begin; + const auto got = acquisition.end - acquisition.begin; + std::uninitialized_copy_n(first, got, begin); + first += got; + remaining -= got; + + _arc->producer_release(acquisition); + + if constexpr (!std::remove_reference_t::_block_forever) + { + blocking = false; + } + } + + return { count - remaining, ok }; + } + + private: + void drop() + { + if (_arc) + { + _arc->drop_producer(); + } + } + + details::arc* _arc = nullptr; + }; + + template + struct consumer + { + explicit consumer(details::arc* arc) noexcept : + _arc(arc) {} + + consumer(const consumer&) = delete; + consumer& operator=(const consumer&) = delete; + + consumer(consumer&& other) noexcept + { + drop(); + _arc = std::exchange(other._arc, nullptr); + } + + consumer& operator=(consumer&& other) noexcept + { + drop(); + _arc = std::exchange(other._arc, nullptr); + } + + ~consumer() + { + drop(); + } + + // pop returns the next item in the queue, or std::nullopt if the producer is gone. + std::optional pop() const + { + auto acquisition = _arc->consumer_acquire(1, true); + if (!acquisition.end) + { + return std::nullopt; + } + + auto data = _arc->data(); + auto begin = data + acquisition.begin; + + auto item = std::move(*begin); + std::destroy_at(begin); + + _arc->consumer_release(acquisition); + return item; + } + + template + std::pair pop_n(OutputIt first, size_t count) const + { + return pop_n(block_forever, first, count); + } + + // pop_n reads up to count items into first. + // The amount of successfully read items is returned as the first pair field. + // The second pair field will be false if the consumer is gone. + template = 0> + std::pair pop_n(WaitPolicy&&, OutputIt first, size_t count) const + { + details::validate_size(count); + + const auto data = _arc->data(); + auto remaining = static_cast(count); + auto blocking = true; + auto ok = true; + + while (remaining != 0) + { + auto acquisition = _arc->consumer_acquire(remaining, blocking); + if (!acquisition.end) + { + ok = acquisition.alive; + break; + } + + auto beg = data + acquisition.begin; + auto end = data + acquisition.end; + auto got = acquisition.end - acquisition.begin; + first = std::move(beg, end, first); + std::destroy(beg, end); + remaining -= got; + + _arc->consumer_release(acquisition); + + if constexpr (!std::remove_reference_t::_block_forever) + { + blocking = false; + } + } + + return { count - remaining, ok }; + } + + private: + void drop() + { + if (_arc) + { + _arc->drop_consumer(); + } + } + + details::arc* _arc = nullptr; + }; + + // channel returns a bounded, lock-free, single-producer, single-consumer + // FIFO queue ("channel") with the given maximum capacity. + template + std::pair, consumer> channel(uint32_t capacity) + { + if (capacity == 0) + { + throw std::invalid_argument{ "invalid capacity" }; + } + + const auto arc = new details::arc(capacity); + return { std::piecewise_construct, std::forward_as_tuple(arc), std::forward_as_tuple(arc) }; + } +} diff --git a/src/til/ut_til/SPSCTests.cpp b/src/til/ut_til/SPSCTests.cpp new file mode 100644 index 00000000000..6558bb439c1 --- /dev/null +++ b/src/til/ut_til/SPSCTests.cpp @@ -0,0 +1,194 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +#include "precomp.h" +#include "WexTestClass.h" + +using namespace WEX::Common; +using namespace WEX::Logging; +using namespace WEX::TestExecution; + +struct drop_indicator +{ + explicit drop_indicator(int& counter) noexcept : + _counter(&counter) {} + + drop_indicator(const drop_indicator&) = delete; + drop_indicator& operator=(const drop_indicator&) = delete; + + drop_indicator(drop_indicator&& other) noexcept + { + _counter = std::exchange(other._counter, nullptr); + } + + drop_indicator& operator=(drop_indicator&& other) noexcept + { + _counter = std::exchange(other._counter, nullptr); + } + + ~drop_indicator() + { + if (_counter) + { + ++*_counter; + } + } + +private: + int* _counter = nullptr; +}; + +template +void drop(T&& val) +{ + auto _ = std::move(val); +} + +class SPSCTests +{ + BEGIN_TEST_CLASS(SPSCTests) + TEST_CLASS_PROPERTY(L"TestTimeout", L"0:0:10") // 10s timeout + END_TEST_CLASS() + + TEST_METHOD(DropEmptyTest); + TEST_METHOD(DropSameRevolutionTest); + TEST_METHOD(DropDifferentRevolutionTest); + TEST_METHOD(IntegrationTest); +}; + +void SPSCTests::DropEmptyTest() +{ + auto [tx, rx] = til::spsc::channel(5); + int counter = 0; + + for (int i = 0; i < 5; ++i) + { + tx.emplace(counter); + } + VERIFY_ARE_EQUAL(counter, 0); + + for (int i = 0; i < 5; ++i) + { + rx.pop(); + } + VERIFY_ARE_EQUAL(counter, 5); + + for (int i = 0; i < 3; ++i) + { + tx.emplace(counter); + } + VERIFY_ARE_EQUAL(counter, 5); + + drop(tx); + VERIFY_ARE_EQUAL(counter, 5); + + for (int i = 0; i < 3; ++i) + { + rx.pop(); + } + VERIFY_ARE_EQUAL(counter, 8); + + drop(rx); + VERIFY_ARE_EQUAL(counter, 8); +} + +void SPSCTests::DropSameRevolutionTest() +{ + auto [tx, rx] = til::spsc::channel(5); + int counter = 0; + + for (int i = 0; i < 5; ++i) + { + tx.emplace(counter); + } + VERIFY_ARE_EQUAL(counter, 0); + + drop(tx); + VERIFY_ARE_EQUAL(counter, 0); + + for (int i = 0; i < 3; ++i) + { + rx.pop(); + } + VERIFY_ARE_EQUAL(counter, 3); + + drop(rx); + VERIFY_ARE_EQUAL(counter, 5); +} + +void SPSCTests::DropDifferentRevolutionTest() +{ + auto [tx, rx] = til::spsc::channel(5); + int counter = 0; + + for (int i = 0; i < 4; ++i) + { + tx.emplace(counter); + } + VERIFY_ARE_EQUAL(counter, 0); + + for (int i = 0; i < 3; ++i) + { + rx.pop(); + } + VERIFY_ARE_EQUAL(counter, 3); + + for (int i = 0; i < 4; ++i) + { + tx.emplace(counter); + } + VERIFY_ARE_EQUAL(counter, 3); + + // At this point we emplace()d 8 items and pop()ed 3 in a channel with a capacity of 5. + // Both producer and consumer positions will be 3 and only differ in their revolution flag. + // This ensures that the arc destructor works even if + + drop(tx); + VERIFY_ARE_EQUAL(counter, 3); + + drop(rx); + VERIFY_ARE_EQUAL(counter, 8); +} + +void SPSCTests::IntegrationTest() +{ + auto [tx, rx] = til::spsc::channel(7); + + std::thread t([tx = std::move(tx)]() { + std::array buffer{}; + std::generate(buffer.begin(), buffer.end(), [v = 0]() mutable { return v++; }); + + for (int i = 0; i < 37; ++i) + { + tx.emplace(i); + } + for (int i = 0; i < 3; ++i) + { + tx.push(buffer.begin(), buffer.end()); + } + }); + + std::array buffer{}; + + for (int i = 0; i < 3; ++i) + { + rx.pop_n(buffer.data(), buffer.size()); + for (int j = 0; j < 11; ++j) + { + VERIFY_ARE_EQUAL(i * 11 + j, buffer[j]); + } + } + for (int i = 33; i < 37; ++i) + { + auto actual = rx.pop(); + VERIFY_ARE_EQUAL(i, actual); + } + for (int i = 0; i < 33; ++i) + { + auto expected = i % 11; + auto actual = rx.pop(); + VERIFY_ARE_EQUAL(expected, actual); + } + + t.join(); +} diff --git a/src/til/ut_til/til.unit.tests.vcxproj b/src/til/ut_til/til.unit.tests.vcxproj index 84ee72de877..82b7908bb7c 100644 --- a/src/til/ut_til/til.unit.tests.vcxproj +++ b/src/til/ut_til/til.unit.tests.vcxproj @@ -22,6 +22,7 @@ Create + diff --git a/src/til/ut_til/til.unit.tests.vcxproj.filters b/src/til/ut_til/til.unit.tests.vcxproj.filters index 20492e2c64c..5633f453b7d 100644 --- a/src/til/ut_til/til.unit.tests.vcxproj.filters +++ b/src/til/ut_til/til.unit.tests.vcxproj.filters @@ -15,6 +15,7 @@ + From 3255177dd0c6245e362f9a35d9c6c922d1eba489 Mon Sep 17 00:00:00 2001 From: Michael Niksa Date: Thu, 16 Jul 2020 13:53:56 -0700 Subject: [PATCH 02/33] Correct comment in this SPSC test as a quick follow up to merge. --- src/til/ut_til/SPSCTests.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/til/ut_til/SPSCTests.cpp b/src/til/ut_til/SPSCTests.cpp index 6558bb439c1..77f3d111613 100644 --- a/src/til/ut_til/SPSCTests.cpp +++ b/src/til/ut_til/SPSCTests.cpp @@ -141,7 +141,8 @@ void SPSCTests::DropDifferentRevolutionTest() // At this point we emplace()d 8 items and pop()ed 3 in a channel with a capacity of 5. // Both producer and consumer positions will be 3 and only differ in their revolution flag. - // This ensures that the arc destructor works even if + // This ensures that the arc destructor works even if the + // two positions within the circular buffer are identical (modulo the capacity). drop(tx); VERIFY_ARE_EQUAL(counter, 3); From 81b7e546592a5743dac65b01c0cb280a75751624 Mon Sep 17 00:00:00 2001 From: Michael Niksa Date: Thu, 16 Jul 2020 14:46:10 -0700 Subject: [PATCH 03/33] Cache the viewport to make invalidation faster (#6918) In `Renderer::TriggerRedraw`, the act of fetching the viewport from the `pData` over and over is wasted time. We already have a cached variable of the viewport that is updated on every scroll check (on `TriggerScroll` and on `PaintFrame`.) Scrolling wouldn't be working correctly if the clients weren't already notifying us that the viewport has changed for scroll purposes, so we can just keep using that cached value for the invalidation restriction to speed things up over fetching it again. ## Validation Steps Performed - Run `time cat big.txt`. Checked average time before/after, WPR traces before/after. ## PR Checklist * [x] Closes perf itch * [x] I work here * [x] Manual test * [x] Documentation irrelevant. * [x] Schema irrelevant. * [x] Am core contributor. --- src/host/ut_host/VtIoTests.cpp | 145 ++++++++++++++++++++++++++++++++- src/renderer/base/renderer.cpp | 13 ++- src/renderer/base/renderer.hpp | 2 +- 3 files changed, 150 insertions(+), 10 deletions(-) diff --git a/src/host/ut_host/VtIoTests.cpp b/src/host/ut_host/VtIoTests.cpp index 6ef1113b86b..599a29caec4 100644 --- a/src/host/ut_host/VtIoTests.cpp +++ b/src/host/ut_host/VtIoTests.cpp @@ -254,6 +254,145 @@ void VtIoTests::DtorTestStackAllocMany() } } +class MockRenderData : public IRenderData, IUiaData +{ +public: + Microsoft::Console::Types::Viewport GetViewport() noexcept override + { + return Microsoft::Console::Types::Viewport{}; + } + + COORD GetTextBufferEndPosition() const noexcept override + { + return COORD{}; + } + + const TextBuffer& GetTextBuffer() noexcept override + { + FAIL_FAST_HR(E_NOTIMPL); + } + + const FontInfo& GetFontInfo() noexcept override + { + FAIL_FAST_HR(E_NOTIMPL); + } + + std::vector GetSelectionRects() noexcept override + { + return std::vector{}; + } + + void LockConsole() noexcept override + { + } + + void UnlockConsole() noexcept override + { + } + + const TextAttribute GetDefaultBrushColors() noexcept override + { + return TextAttribute{}; + } + + std::pair GetAttributeColors(const TextAttribute& /*attr*/) const noexcept override + { + return std::make_pair(COLORREF{}, COLORREF{}); + } + + COORD GetCursorPosition() const noexcept override + { + return COORD{}; + } + + bool IsCursorVisible() const noexcept override + { + return false; + } + + bool IsCursorOn() const noexcept override + { + return false; + } + + ULONG GetCursorHeight() const noexcept override + { + return 42ul; + } + + CursorType GetCursorStyle() const noexcept override + { + return CursorType::FullBox; + } + + ULONG GetCursorPixelWidth() const noexcept override + { + return 12ul; + } + + COLORREF GetCursorColor() const noexcept override + { + return COLORREF{}; + } + + bool IsCursorDoubleWidth() const override + { + return false; + } + + bool IsScreenReversed() const noexcept override + { + return false; + } + + const std::vector GetOverlays() const noexcept override + { + return std::vector{}; + } + + const bool IsGridLineDrawingAllowed() noexcept override + { + return false; + } + + const std::wstring GetConsoleTitle() const noexcept override + { + return std::wstring{}; + } + + const bool IsSelectionActive() const override + { + return false; + } + + const bool IsBlockSelection() const noexcept override + { + return false; + } + + void ClearSelection() override + { + } + + void SelectNewRegion(const COORD /*coordStart*/, const COORD /*coordEnd*/) override + { + } + + const COORD GetSelectionAnchor() const noexcept + { + return COORD{}; + } + + const COORD GetSelectionEnd() const noexcept + { + return COORD{}; + } + + void ColorSelection(const COORD /*coordSelectionStart*/, const COORD /*coordSelectionEnd*/, const TextAttribute /*attr*/) + { + } +}; + void VtIoTests::RendererDtorAndThread() { Log::Comment(NoThrowString().Format( @@ -261,9 +400,10 @@ void VtIoTests::RendererDtorAndThread() for (int i = 0; i < 16; ++i) { + auto data = std::make_unique(); auto thread = std::make_unique(); auto* pThread = thread.get(); - auto pRenderer = std::make_unique(nullptr, nullptr, 0, std::move(thread)); + auto pRenderer = std::make_unique(data.get(), nullptr, 0, std::move(thread)); VERIFY_SUCCEEDED(pThread->Initialize(pRenderer.get())); // Sleep for a hot sec to make sure the thread starts before we enable painting // If you don't, the thread might wait on the paint enabled event AFTER @@ -286,9 +426,10 @@ void VtIoTests::RendererDtorAndThreadAndDx() for (int i = 0; i < 16; ++i) { + auto data = std::make_unique(); auto thread = std::make_unique(); auto* pThread = thread.get(); - auto pRenderer = std::make_unique(nullptr, nullptr, 0, std::move(thread)); + auto pRenderer = std::make_unique(data.get(), nullptr, 0, std::move(thread)); VERIFY_SUCCEEDED(pThread->Initialize(pRenderer.get())); auto dxEngine = std::make_unique<::Microsoft::Console::Render::DxEngine>(); diff --git a/src/renderer/base/renderer.cpp b/src/renderer/base/renderer.cpp index f382dbd7c07..bdda98bc3cf 100644 --- a/src/renderer/base/renderer.cpp +++ b/src/renderer/base/renderer.cpp @@ -26,13 +26,12 @@ Renderer::Renderer(IRenderData* pData, _In_reads_(cEngines) IRenderEngine** const rgpEngines, const size_t cEngines, std::unique_ptr thread) : - _pData(pData), + _pData(THROW_HR_IF_NULL(E_INVALIDARG, pData)), _pThread{ std::move(thread) }, _destructing{ false }, - _clusterBuffer{} + _clusterBuffer{}, + _viewport{ pData->GetViewport() } { - _srViewportPrevious = { 0 }; - for (size_t i = 0; i < cEngines; i++) { IRenderEngine* engine = rgpEngines[i]; @@ -208,7 +207,7 @@ void Renderer::TriggerSystemRedraw(const RECT* const prcDirtyClient) // - void Renderer::TriggerRedraw(const Viewport& region) { - Viewport view = _pData->GetViewport(); + Viewport view = _viewport; SMALL_RECT srUpdateRegion = region.ToExclusive(); if (view.TrimToViewport(&srUpdateRegion)) @@ -357,7 +356,7 @@ void Renderer::TriggerSelection() // - True if something changed and we scrolled. False otherwise. bool Renderer::_CheckViewportAndScroll() { - SMALL_RECT const srOldViewport = _srViewportPrevious; + SMALL_RECT const srOldViewport = _viewport.ToInclusive(); SMALL_RECT const srNewViewport = _pData->GetViewport().ToInclusive(); COORD coordDelta; @@ -369,7 +368,7 @@ bool Renderer::_CheckViewportAndScroll() LOG_IF_FAILED(engine->UpdateViewport(srNewViewport)); } - _srViewportPrevious = srNewViewport; + _viewport = Viewport::FromInclusive(srNewViewport); // If we're keeping some buffers between calls, let them know about the viewport size // so they can prepare the buffers for changes to either preallocate memory at once diff --git a/src/renderer/base/renderer.hpp b/src/renderer/base/renderer.hpp index 6c30e0f4ee6..db6dc6d3875 100644 --- a/src/renderer/base/renderer.hpp +++ b/src/renderer/base/renderer.hpp @@ -120,7 +120,7 @@ namespace Microsoft::Console::Render [[nodiscard]] HRESULT _PerformScrolling(_In_ IRenderEngine* const pEngine); - SMALL_RECT _srViewportPrevious; + Microsoft::Console::Types::Viewport _viewport; static constexpr float _shrinkThreshold = 0.8f; std::vector _clusterBuffer; From 53df6c7f96bd4b18182090e5818f8995b18d373f Mon Sep 17 00:00:00 2001 From: Dan Thompson Date: Thu, 16 Jul 2020 16:58:48 -0700 Subject: [PATCH 04/33] Fix 'bcz exclusive' typo (#6938) Without this fix, you'd end up with an empty target variable, and so msbuild would complain and tell you to give it a target. --- tools/bcz.cmd | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tools/bcz.cmd b/tools/bcz.cmd index f70269aaf34..3262b0b39e1 100644 --- a/tools/bcz.cmd +++ b/tools/bcz.cmd @@ -116,8 +116,12 @@ set "__PROJECT_NAME=!_OUTPUT!" rem If we're trying to clean build, make sure to update the target here. if "%_MSBUILD_TARGET%" == "Build" ( set __MSBUILD_TARGET=%__PROJECT_NAME% -) else if "%_MSBUILD_TARGET%" == "Clean,Build" ( +) else if "%_MSBUILD_TARGET%" == "Clean;Build" ( set __MSBUILD_TARGET=%__PROJECT_NAME%:Rebuild +) else ( + echo. + echo Oops... build bug in the neighborhood of configuring a build target. + echo. ) rem This statement will propagate our internal variables up to the calling rem scope. Because they're all on one line, the value of our local variables From 7062a830b844a6dbfa6d2c06c9c001545b6483c4 Mon Sep 17 00:00:00 2001 From: jtippet Date: Thu, 16 Jul 2020 17:33:03 -0700 Subject: [PATCH 05/33] Smooth animation of command palette filtering (#6939) The command palette is a ListView of commands. As you type into the search box, commands are added or removed from the ListView. Currently, each update is done by completely clearing the backing list, then adding back any items that should be displayed. However, this defeats the ListView's built-in animations: upon every keystroke, ListView displays its list-clearing animation, then animates the insertion of every item that wasn't deleted. This results in noticeable flickering. This PR changes the update logic so that it updates the list using (roughly) the minimum number of Insert and Remove calls, so the ListView makes smoother transitions as you type. I implemented it by keeping the existing code that builds the filtered list, but I changed it to build into a scratch list. Then I grafted on a generic delta algorithm to make the real list look like the scratch list. To verify the delta algorithm, I tested all 360,000 permutations of pairs of up to 5 element lists in a toy C# app. ## Validation I'm not sure if my screen capture tool really caught all the flickering here, but the screencasts below should give a rough idea of the difference. (All the flickering was becoming a nuisance while I was testing out the HC changes.) See the images in #6939 for more info. Co-authored-by: Jeffrey Tippet --- src/cascadia/TerminalApp/CommandPalette.cpp | 64 ++++++++++++++++++--- src/cascadia/TerminalApp/CommandPalette.h | 1 + 2 files changed, 58 insertions(+), 7 deletions(-) diff --git a/src/cascadia/TerminalApp/CommandPalette.cpp b/src/cascadia/TerminalApp/CommandPalette.cpp index 6fac2d35d62..33d32defe7e 100644 --- a/src/cascadia/TerminalApp/CommandPalette.cpp +++ b/src/cascadia/TerminalApp/CommandPalette.cpp @@ -271,16 +271,17 @@ namespace winrt::TerminalApp::implementation }; // Method Description: - // - Update our list of filtered actions to reflect the current contents of + // - Produce a list of filtered actions to reflect the current contents of // the input box. For more details on which commands will be displayed, // see `_getWeight`. // Arguments: - // - + // - A collection that will receive the filtered actions // Return Value: // - - void CommandPalette::_updateFilteredActions() + std::vector CommandPalette::_collectFilteredActions() { - _filteredActions.Clear(); + std::vector actions; + auto searchText = _searchBox().Text(); const bool addAll = searchText.empty(); @@ -303,10 +304,10 @@ namespace winrt::TerminalApp::implementation for (auto action : sortedCommands) { - _filteredActions.Append(action); + actions.push_back(action); } - return; + return actions; } // Here, there was some filter text. @@ -343,7 +344,56 @@ namespace winrt::TerminalApp::implementation { auto top = heap.top(); heap.pop(); - _filteredActions.Append(top.command); + actions.push_back(top.command); + } + + return actions; + } + + // Method Description: + // - Update our list of filtered actions to reflect the current contents of + // the input box. For more details on which commands will be displayed, + // see `_getWeight`. + // Arguments: + // - + // Return Value: + // - + void CommandPalette::_updateFilteredActions() + { + auto actions = _collectFilteredActions(); + + // Make _filteredActions look identical to actions, using only Insert and Remove. + // This allows WinUI to nicely animate the ListView as it changes. + for (uint32_t i = 0; i < _filteredActions.Size() && i < actions.size(); i++) + { + for (uint32_t j = i; j < _filteredActions.Size(); j++) + { + if (_filteredActions.GetAt(j) == actions[i]) + { + for (uint32_t k = i; k < j; k++) + { + _filteredActions.RemoveAt(i); + } + break; + } + } + + if (_filteredActions.GetAt(i) != actions[i]) + { + _filteredActions.InsertAt(i, actions[i]); + } + } + + // Remove any extra trailing items from the destination + while (_filteredActions.Size() > actions.size()) + { + _filteredActions.RemoveAtEnd(); + } + + // Add any extra trailing items from the source + while (_filteredActions.Size() < actions.size()) + { + _filteredActions.Append(actions[_filteredActions.Size()]); } } diff --git a/src/cascadia/TerminalApp/CommandPalette.h b/src/cascadia/TerminalApp/CommandPalette.h index 2d396070518..a14466f4f36 100644 --- a/src/cascadia/TerminalApp/CommandPalette.h +++ b/src/cascadia/TerminalApp/CommandPalette.h @@ -37,6 +37,7 @@ namespace winrt::TerminalApp::implementation void _selectNextItem(const bool moveDown); void _updateFilteredActions(); + std::vector _collectFilteredActions(); static int _getWeight(const winrt::hstring& searchText, const winrt::hstring& name); void _close(); From 03e25f12e9828f65549ec0d4fedeae7aff363fdf Mon Sep 17 00:00:00 2001 From: "Dustin L. Howett" Date: Thu, 16 Jul 2020 17:33:23 -0700 Subject: [PATCH 06/33] Move to the TerminalDependencies NuGet feed (#6954) After we stood up our own NuGet feed in Azure blob storage, Azure DevOps came out with a public artifact feed feature. I've migrated all our packages over, and the only thing left to do is switch our project's NuGet config to use it. Fixes #6952 --- NuGet.Config | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/NuGet.Config b/NuGet.Config index de105e187bc..00b1de60c4f 100644 --- a/NuGet.Config +++ b/NuGet.Config @@ -8,7 +8,7 @@ - + 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

j+zVyRO>L;D4YjeM?QBm2)&aasxWNP{0Xz(N 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 kFey;Cx6Q46a_wjSTK3DhL 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 delta 88821 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 z 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 G{Qm$|k0dz& diff --git a/res/README.md b/res/README.md index 8ae4844d54c..f0929cfff73 100644 --- a/res/README.md +++ b/res/README.md @@ -17,5 +17,5 @@ Please consult the [license](https://raw.githubusercontent.com/microsoft/cascadi ### Fonts Included -* Cascadia Code, Cascadia Mono (2007.01) - * from microsoft/cascadia-code@311cc603f30635da704b6a7d13050e245e61667b +* Cascadia Code, Cascadia Mono (2007.15) + * from microsoft/cascadia-code@2a54363b2c867f7ae811b9a034c0024cef67de96 From 7bc5de613c47f1de90cddfac27637dba74a2c373 Mon Sep 17 00:00:00 2001 From: "Dustin L. Howett" Date: Thu, 16 Jul 2020 18:18:33 -0700 Subject: [PATCH 08/33] version: bump to 1.3 on master --- custom.props | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/custom.props b/custom.props index 272e30a61fa..c4bf1eefda0 100644 --- a/custom.props +++ b/custom.props @@ -5,7 +5,7 @@ true 2020 1 - 2 + 3 Windows Terminal From efb1fddb991dc1e6b614d1637daca7314a229925 Mon Sep 17 00:00:00 2001 From: "Dustin L. Howett" Date: Thu, 16 Jul 2020 18:31:09 -0700 Subject: [PATCH 09/33] Convert most of our JSON deserializers to use type-based conversion (#6590) This pull request converts the following JSON deserializers to use the new JSON deserializer pattern: * Profile * Command * ColorScheme * Action/Args * GlobalSettings * CascadiaSettingsSerialization This is the completion of a long-term JSON refactoring that makes our parser and deserializer more type-safe and robust. We're finally able to get rid of all our manual enum conversion code and unify JSON conversion around _types_ instead of around _keys_. I've introduced another file filled with template specializations, TerminalSettingsSerializationHelpers.h, which comprises a single unit that holds all of the JSON deserializers (and eventually serializers) for every type that comes from TerminalApp or TerminalSettings. I've also moved some types out of Profile and GlobalAppSettings into a new SettingsTypes.h to improve settings locality. This does to some extent constitute a breaking change for already-broken settings. Instead of parsing "successfully" (where invalid values are null or 0 or unknown or unset), deserialization will now fail when there's a type mismatch. Because of that, some tests had to be removed. While I was on a refactoring spree, I removed a number of helpless helpers, like GetWstringFromJson (which converted a u8 string to an hstring to make a wstring out of its data pointer :|) and _ConvertJsonToBool. In the future, we can make the error types more robust and give them position and type information such that a conformant application can display rich error information ("line 3 column 3, I expected a string, you gave me an integer"). Closes #2550. --- .../LocalTests_TerminalApp/CommandTests.cpp | 26 +- .../KeyBindingsTests.cpp | 36 +- .../LocalTests_TerminalApp/SettingsTests.cpp | 5 - src/cascadia/TerminalApp/ActionAndArgs.cpp | 12 +- src/cascadia/TerminalApp/ActionArgs.h | 182 +----- .../CascadiaSettingsSerialization.cpp | 4 +- src/cascadia/TerminalApp/ColorScheme.cpp | 47 +- src/cascadia/TerminalApp/Command.cpp | 18 +- .../TerminalApp/GlobalAppSettings.cpp | 190 +----- src/cascadia/TerminalApp/GlobalAppSettings.h | 16 +- src/cascadia/TerminalApp/JsonUtils.cpp | 125 ---- src/cascadia/TerminalApp/JsonUtils.h | 545 ++++++++++++++---- src/cascadia/TerminalApp/JsonUtilsNew.h | 490 ---------------- src/cascadia/TerminalApp/Profile.cpp | 501 ++-------------- src/cascadia/TerminalApp/Profile.h | 28 +- src/cascadia/TerminalApp/SettingsTypes.h | 28 + .../TerminalSettingsSerializationHelpers.h | 272 +++++++++ src/cascadia/TerminalApp/Utils.cpp | 18 - src/cascadia/TerminalApp/Utils.h | 2 - .../TerminalApp/lib/TerminalAppLib.vcxproj | 3 +- .../lib/TerminalAppLib.vcxproj.filters | 9 +- src/cascadia/ut_app/JsonTests.cpp | 56 -- src/cascadia/ut_app/JsonUtilsTests.cpp | 2 +- 23 files changed, 877 insertions(+), 1738 deletions(-) delete mode 100644 src/cascadia/TerminalApp/JsonUtils.cpp delete mode 100644 src/cascadia/TerminalApp/JsonUtilsNew.h create mode 100644 src/cascadia/TerminalApp/SettingsTypes.h create mode 100644 src/cascadia/TerminalApp/TerminalSettingsSerializationHelpers.h delete mode 100644 src/cascadia/TerminalApp/Utils.cpp diff --git a/src/cascadia/LocalTests_TerminalApp/CommandTests.cpp b/src/cascadia/LocalTests_TerminalApp/CommandTests.cpp index 129e2469182..1babcf6a2c8 100644 --- a/src/cascadia/LocalTests_TerminalApp/CommandTests.cpp +++ b/src/cascadia/LocalTests_TerminalApp/CommandTests.cpp @@ -147,10 +147,8 @@ namespace TerminalAppLocalTests { "name": "command0", "command": { "action": "splitPane", "split": null } }, { "name": "command1", "command": { "action": "splitPane", "split": "vertical" } }, { "name": "command2", "command": { "action": "splitPane", "split": "horizontal" } }, - { "name": "command3", "command": { "action": "splitPane", "split": "none" } }, { "name": "command4", "command": { "action": "splitPane" } }, - { "name": "command5", "command": { "action": "splitPane", "split": "auto" } }, - { "name": "command6", "command": { "action": "splitPane", "split": "foo" } } + { "name": "command5", "command": { "action": "splitPane", "split": "auto" } } ])" }; const auto commands0Json = VerifyParseSucceeded(commands0String); @@ -159,7 +157,7 @@ namespace TerminalAppLocalTests VERIFY_ARE_EQUAL(0u, commands.size()); auto warnings = implementation::Command::LayerJson(commands, commands0Json); VERIFY_ARE_EQUAL(0u, warnings.size()); - VERIFY_ARE_EQUAL(7u, commands.size()); + VERIFY_ARE_EQUAL(5u, commands.size()); { auto command = commands.at(L"command0"); @@ -191,16 +189,6 @@ namespace TerminalAppLocalTests // Verify the args have the expected value VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Horizontal, realArgs.SplitStyle()); } - { - auto command = commands.at(L"command3"); - VERIFY_IS_NOT_NULL(command); - VERIFY_IS_NOT_NULL(command.Action()); - VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.Action().Action()); - const auto& realArgs = command.Action().Args().try_as(); - VERIFY_IS_NOT_NULL(realArgs); - // Verify the args have the expected value - VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Automatic, realArgs.SplitStyle()); - } { auto command = commands.at(L"command4"); VERIFY_IS_NOT_NULL(command); @@ -221,16 +209,6 @@ namespace TerminalAppLocalTests // Verify the args have the expected value VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Automatic, realArgs.SplitStyle()); } - { - auto command = commands.at(L"command6"); - VERIFY_IS_NOT_NULL(command); - VERIFY_IS_NOT_NULL(command.Action()); - VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.Action().Action()); - const auto& realArgs = command.Action().Args().try_as(); - VERIFY_IS_NOT_NULL(realArgs); - // Verify the args have the expected value - VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Automatic, realArgs.SplitStyle()); - } } void CommandTests::TestResourceKeyName() { diff --git a/src/cascadia/LocalTests_TerminalApp/KeyBindingsTests.cpp b/src/cascadia/LocalTests_TerminalApp/KeyBindingsTests.cpp index 760bfd94c8a..ad51cf8269b 100644 --- a/src/cascadia/LocalTests_TerminalApp/KeyBindingsTests.cpp +++ b/src/cascadia/LocalTests_TerminalApp/KeyBindingsTests.cpp @@ -323,10 +323,8 @@ namespace TerminalAppLocalTests { "keys": ["ctrl+c"], "command": { "action": "splitPane", "split": null } }, { "keys": ["ctrl+d"], "command": { "action": "splitPane", "split": "vertical" } }, { "keys": ["ctrl+e"], "command": { "action": "splitPane", "split": "horizontal" } }, - { "keys": ["ctrl+f"], "command": { "action": "splitPane", "split": "none" } }, { "keys": ["ctrl+g"], "command": { "action": "splitPane" } }, - { "keys": ["ctrl+h"], "command": { "action": "splitPane", "split": "auto" } }, - { "keys": ["ctrl+i"], "command": { "action": "splitPane", "split": "foo" } } + { "keys": ["ctrl+h"], "command": { "action": "splitPane", "split": "auto" } } ])" }; const auto bindings0Json = VerifyParseSucceeded(bindings0String); @@ -335,7 +333,7 @@ namespace TerminalAppLocalTests VERIFY_IS_NOT_NULL(appKeyBindings); VERIFY_ARE_EQUAL(0u, appKeyBindings->_keyShortcuts.size()); appKeyBindings->LayerJson(bindings0Json); - VERIFY_ARE_EQUAL(7u, appKeyBindings->_keyShortcuts.size()); + VERIFY_ARE_EQUAL(5u, appKeyBindings->_keyShortcuts.size()); { KeyChord kc{ true, false, false, static_cast('C') }; @@ -364,15 +362,6 @@ namespace TerminalAppLocalTests // Verify the args have the expected value VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Horizontal, realArgs.SplitStyle()); } - { - KeyChord kc{ true, false, false, static_cast('F') }; - auto actionAndArgs = TestUtils::GetActionAndArgs(*appKeyBindings, kc); - VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action()); - const auto& realArgs = actionAndArgs.Args().try_as(); - VERIFY_IS_NOT_NULL(realArgs); - // Verify the args have the expected value - VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Automatic, realArgs.SplitStyle()); - } { KeyChord kc{ true, false, false, static_cast('G') }; auto actionAndArgs = TestUtils::GetActionAndArgs(*appKeyBindings, kc); @@ -391,15 +380,6 @@ namespace TerminalAppLocalTests // Verify the args have the expected value VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Automatic, realArgs.SplitStyle()); } - { - KeyChord kc{ true, false, false, static_cast('I') }; - auto actionAndArgs = TestUtils::GetActionAndArgs(*appKeyBindings, kc); - VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action()); - const auto& realArgs = actionAndArgs.Args().try_as(); - VERIFY_IS_NOT_NULL(realArgs); - // Verify the args have the expected value - VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Automatic, realArgs.SplitStyle()); - } } void KeyBindingsTests::TestSetTabColorArgs() @@ -407,7 +387,6 @@ namespace TerminalAppLocalTests const std::string bindings0String{ R"([ { "keys": ["ctrl+c"], "command": { "action": "setTabColor", "color": null } }, { "keys": ["ctrl+d"], "command": { "action": "setTabColor", "color": "#123456" } }, - { "keys": ["ctrl+e"], "command": { "action": "setTabColor", "color": "thisStringObviouslyWontWork" } }, { "keys": ["ctrl+f"], "command": "setTabColor" }, ])" }; @@ -417,7 +396,7 @@ namespace TerminalAppLocalTests VERIFY_IS_NOT_NULL(appKeyBindings); VERIFY_ARE_EQUAL(0u, appKeyBindings->_keyShortcuts.size()); appKeyBindings->LayerJson(bindings0Json); - VERIFY_ARE_EQUAL(4u, appKeyBindings->_keyShortcuts.size()); + VERIFY_ARE_EQUAL(3u, appKeyBindings->_keyShortcuts.size()); { KeyChord kc{ true, false, false, static_cast('C') }; @@ -439,15 +418,6 @@ namespace TerminalAppLocalTests // Remember that COLORREFs are actually BBGGRR order, while the string is in #RRGGBB order VERIFY_ARE_EQUAL(static_cast(til::color(0x563412)), realArgs.TabColor().Value()); } - { - KeyChord kc{ true, false, false, static_cast('E') }; - auto actionAndArgs = TestUtils::GetActionAndArgs(*appKeyBindings, kc); - VERIFY_ARE_EQUAL(ShortcutAction::SetTabColor, actionAndArgs.Action()); - const auto& realArgs = actionAndArgs.Args().try_as(); - VERIFY_IS_NOT_NULL(realArgs); - // Verify the args have the expected value - VERIFY_IS_NULL(realArgs.TabColor()); - } { KeyChord kc{ true, false, false, static_cast('F') }; auto actionAndArgs = TestUtils::GetActionAndArgs(*appKeyBindings, kc); diff --git a/src/cascadia/LocalTests_TerminalApp/SettingsTests.cpp b/src/cascadia/LocalTests_TerminalApp/SettingsTests.cpp index 8aed7e4525d..ecd58743f56 100644 --- a/src/cascadia/LocalTests_TerminalApp/SettingsTests.cpp +++ b/src/cascadia/LocalTests_TerminalApp/SettingsTests.cpp @@ -1431,10 +1431,6 @@ namespace TerminalAppLocalTests { "name": "profile3", "closeOnExit": null - }, - { - "name": "profile4", - "closeOnExit": { "clearly": "not a string" } } ] })" }; @@ -1449,7 +1445,6 @@ namespace TerminalAppLocalTests // Unknown modes parse as "Graceful" VERIFY_ARE_EQUAL(CloseOnExitMode::Graceful, settings._profiles[3].GetCloseOnExitMode()); - VERIFY_ARE_EQUAL(CloseOnExitMode::Graceful, settings._profiles[4].GetCloseOnExitMode()); } void SettingsTests::TestCloseOnExitCompatibilityShim() { diff --git a/src/cascadia/TerminalApp/ActionAndArgs.cpp b/src/cascadia/TerminalApp/ActionAndArgs.cpp index 5375ea02cb0..a5d98e89bd2 100644 --- a/src/cascadia/TerminalApp/ActionAndArgs.cpp +++ b/src/cascadia/TerminalApp/ActionAndArgs.cpp @@ -2,6 +2,9 @@ #include "ActionArgs.h" #include "ActionAndArgs.h" #include "ActionAndArgs.g.cpp" + +#include "JsonUtils.h" + #include static constexpr std::string_view CopyTextKey{ "copy" }; @@ -44,6 +47,8 @@ static constexpr std::string_view UnboundKey{ "unbound" }; namespace winrt::TerminalApp::implementation { + using namespace ::TerminalApp; + // Specifically use a map here over an unordered_map. We want to be able to // iterate over these entries in-order when we're serializing the keybindings. // HERE BE DRAGONS: @@ -183,11 +188,9 @@ namespace winrt::TerminalApp::implementation } else if (json.isObject()) { - const auto actionVal = json[JsonKey(ActionKey)]; - if (actionVal.isString()) + if (const auto actionString{ JsonUtils::GetValueForKey>(json, ActionKey) }) { - auto actionString = actionVal.asString(); - action = GetActionFromString(actionString); + action = GetActionFromString(*actionString); argsVal = json; } } @@ -281,5 +284,4 @@ namespace winrt::TerminalApp::implementation const auto found = GeneratedActionNames.find(_Action); return found != GeneratedActionNames.end() ? found->second : L""; } - } diff --git a/src/cascadia/TerminalApp/ActionArgs.h b/src/cascadia/TerminalApp/ActionArgs.h index eb233b5967a..93e2b5baf3e 100644 --- a/src/cascadia/TerminalApp/ActionArgs.h +++ b/src/cascadia/TerminalApp/ActionArgs.h @@ -23,6 +23,8 @@ #include "JsonUtils.h" #include "TerminalWarnings.h" +#include "TerminalSettingsSerializationHelpers.h" + // Notes on defining ActionArgs and ActionEventArgs: // * All properties specific to an action should be defined as an ActionArgs // class that implements IActionArgs @@ -31,6 +33,7 @@ namespace winrt::TerminalApp::implementation { + using namespace ::TerminalApp; using FromJsonResult = std::tuple>; struct ActionEventArgs : public ActionEventArgsT @@ -73,26 +76,11 @@ namespace winrt::TerminalApp::implementation { // LOAD BEARING: Not using make_self here _will_ break you in the future! auto args = winrt::make_self(); - if (auto commandline{ json[JsonKey(CommandlineKey)] }) - { - args->_Commandline = winrt::to_hstring(commandline.asString()); - } - if (auto startingDirectory{ json[JsonKey(StartingDirectoryKey)] }) - { - args->_StartingDirectory = winrt::to_hstring(startingDirectory.asString()); - } - if (auto tabTitle{ json[JsonKey(TabTitleKey)] }) - { - args->_TabTitle = winrt::to_hstring(tabTitle.asString()); - } - if (auto index{ json[JsonKey(ProfileIndexKey)] }) - { - args->_ProfileIndex = index.asInt(); - } - if (auto profile{ json[JsonKey(ProfileKey)] }) - { - args->_Profile = winrt::to_hstring(profile.asString()); - } + JsonUtils::GetValueForKey(json, CommandlineKey, args->_Commandline); + JsonUtils::GetValueForKey(json, StartingDirectoryKey, args->_StartingDirectory); + JsonUtils::GetValueForKey(json, TabTitleKey, args->_TabTitle); + JsonUtils::GetValueForKey(json, ProfileIndexKey, args->_ProfileIndex); + JsonUtils::GetValueForKey(json, ProfileKey, args->_Profile); return *args; } }; @@ -120,10 +108,7 @@ namespace winrt::TerminalApp::implementation { // LOAD BEARING: Not using make_self here _will_ break you in the future! auto args = winrt::make_self(); - if (auto singleLine{ json[JsonKey(SingleLineKey)] }) - { - args->_SingleLine = singleLine.asBool(); - } + JsonUtils::GetValueForKey(json, SingleLineKey, args->_SingleLine); return { *args, {} }; } }; @@ -177,49 +162,11 @@ namespace winrt::TerminalApp::implementation { // LOAD BEARING: Not using make_self here _will_ break you in the future! auto args = winrt::make_self(); - if (auto tabIndex{ json[JsonKey(TabIndexKey)] }) - { - args->_TabIndex = tabIndex.asUInt(); - } + JsonUtils::GetValueForKey(json, TabIndexKey, args->_TabIndex); return { *args, {} }; } }; - // Possible Direction values - // TODO:GH#2550/#3475 - move these to a centralized deserializing place - static constexpr std::string_view LeftString{ "left" }; - static constexpr std::string_view RightString{ "right" }; - static constexpr std::string_view UpString{ "up" }; - static constexpr std::string_view DownString{ "down" }; - - // Function Description: - // - Helper function for parsing a Direction from a string - // Arguments: - // - directionString: the string to attempt to parse - // Return Value: - // - The encoded Direction value, or Direction::None if it was an invalid string - static TerminalApp::Direction ParseDirection(const std::string& directionString) - { - if (directionString == LeftString) - { - return TerminalApp::Direction::Left; - } - else if (directionString == RightString) - { - return TerminalApp::Direction::Right; - } - else if (directionString == UpString) - { - return TerminalApp::Direction::Up; - } - else if (directionString == DownString) - { - return TerminalApp::Direction::Down; - } - // default behavior for invalid data - return TerminalApp::Direction::None; - }; - struct ResizePaneArgs : public ResizePaneArgsT { ResizePaneArgs() = default; @@ -243,10 +190,7 @@ namespace winrt::TerminalApp::implementation { // LOAD BEARING: Not using make_self here _will_ break you in the future! auto args = winrt::make_self(); - if (auto directionString{ json[JsonKey(DirectionKey)] }) - { - args->_Direction = ParseDirection(directionString.asString()); - } + JsonUtils::GetValueForKey(json, DirectionKey, args->_Direction); if (args->_Direction == TerminalApp::Direction::None) { return { nullptr, { ::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter } }; @@ -281,10 +225,7 @@ namespace winrt::TerminalApp::implementation { // LOAD BEARING: Not using make_self here _will_ break you in the future! auto args = winrt::make_self(); - if (auto directionString{ json[JsonKey(DirectionKey)] }) - { - args->_Direction = ParseDirection(directionString.asString()); - } + JsonUtils::GetValueForKey(json, DirectionKey, args->_Direction); if (args->_Direction == TerminalApp::Direction::None) { return { nullptr, { ::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter } }; @@ -319,48 +260,11 @@ namespace winrt::TerminalApp::implementation { // LOAD BEARING: Not using make_self here _will_ break you in the future! auto args = winrt::make_self(); - if (auto jsonDelta{ json[JsonKey(AdjustFontSizeDelta)] }) - { - args->_Delta = jsonDelta.asInt(); - } + JsonUtils::GetValueForKey(json, AdjustFontSizeDelta, args->_Delta); return { *args, {} }; } }; - // Possible SplitState values - // TODO:GH#2550/#3475 - move these to a centralized deserializing place - static constexpr std::string_view VerticalKey{ "vertical" }; - static constexpr std::string_view HorizontalKey{ "horizontal" }; - static constexpr std::string_view AutomaticKey{ "auto" }; - static TerminalApp::SplitState ParseSplitState(const std::string& stateString) - { - if (stateString == VerticalKey) - { - return TerminalApp::SplitState::Vertical; - } - else if (stateString == HorizontalKey) - { - return TerminalApp::SplitState::Horizontal; - } - else if (stateString == AutomaticKey) - { - return TerminalApp::SplitState::Automatic; - } - // default behavior for invalid data - return TerminalApp::SplitState::Automatic; - }; - - // Possible SplitType values - static constexpr std::string_view DuplicateKey{ "duplicate" }; - static TerminalApp::SplitType ParseSplitModeState(const std::string& stateString) - { - if (stateString == DuplicateKey) - { - return TerminalApp::SplitType::Duplicate; - } - return TerminalApp::SplitType::Manual; - } - struct SplitPaneArgs : public SplitPaneArgsT { SplitPaneArgs() = default; @@ -391,48 +295,12 @@ namespace winrt::TerminalApp::implementation // LOAD BEARING: Not using make_self here _will_ break you in the future! auto args = winrt::make_self(); args->_TerminalArgs = NewTerminalArgs::FromJson(json); - if (auto jsonStyle{ json[JsonKey(SplitKey)] }) - { - args->_SplitStyle = ParseSplitState(jsonStyle.asString()); - } - if (auto jsonStyle{ json[JsonKey(SplitModeKey)] }) - { - args->_SplitMode = ParseSplitModeState(jsonStyle.asString()); - } + JsonUtils::GetValueForKey(json, SplitKey, args->_SplitStyle); + JsonUtils::GetValueForKey(json, SplitModeKey, args->_SplitMode); return { *args, {} }; } }; - // Possible SettingsTarget values - // TODO:GH#2550/#3475 - move these to a centralized deserializing place - static constexpr std::string_view SettingsFileString{ "settingsFile" }; - static constexpr std::string_view DefaultsFileString{ "defaultsFile" }; - static constexpr std::string_view AllFilesString{ "allFiles" }; - - // Function Description: - // - Helper function for parsing a SettingsTarget from a string - // Arguments: - // - targetString: the string to attempt to parse - // Return Value: - // - The encoded SettingsTarget value, or SettingsTarget::SettingsFile if it was an invalid string - static TerminalApp::SettingsTarget ParseSettingsTarget(const std::string& targetString) - { - if (targetString == SettingsFileString) - { - return TerminalApp::SettingsTarget::SettingsFile; - } - else if (targetString == DefaultsFileString) - { - return TerminalApp::SettingsTarget::DefaultsFile; - } - else if (targetString == AllFilesString) - { - return TerminalApp::SettingsTarget::AllFiles; - } - // default behavior for invalid data - return TerminalApp::SettingsTarget::SettingsFile; - }; - struct OpenSettingsArgs : public OpenSettingsArgsT { OpenSettingsArgs() = default; @@ -456,10 +324,7 @@ namespace winrt::TerminalApp::implementation { // LOAD BEARING: Not using make_self here _will_ break you in the future! auto args = winrt::make_self(); - if (auto targetString{ json[JsonKey(TargetKey)] }) - { - args->_Target = ParseSettingsTarget(targetString.asString()); - } + JsonUtils::GetValueForKey(json, TargetKey, args->_Target); return { *args, {} }; } }; @@ -487,16 +352,10 @@ namespace winrt::TerminalApp::implementation { // LOAD BEARING: Not using make_self here _will_ break you in the future! auto args = winrt::make_self(); - std::optional temp; - try + if (const auto temp{ JsonUtils::GetValueForKey>(json, ColorKey) }) { - ::TerminalApp::JsonUtils::GetOptionalColor(json, ColorKey, temp); - if (temp.has_value()) - { - args->_TabColor = static_cast(temp.value()); - } + args->_TabColor = static_cast(*temp); } - CATCH_LOG(); return { *args, {} }; } }; @@ -524,10 +383,7 @@ namespace winrt::TerminalApp::implementation { // LOAD BEARING: Not using make_self here _will_ break you in the future! auto args = winrt::make_self(); - if (auto title{ json[JsonKey(TitleKey)] }) - { - args->_Title = winrt::to_hstring(title.asString()); - } + JsonUtils::GetValueForKey(json, TitleKey, args->_Title); return { *args, {} }; } }; diff --git a/src/cascadia/TerminalApp/CascadiaSettingsSerialization.cpp b/src/cascadia/TerminalApp/CascadiaSettingsSerialization.cpp index 2ed23f8c770..1a8f2b6e71f 100644 --- a/src/cascadia/TerminalApp/CascadiaSettingsSerialization.cpp +++ b/src/cascadia/TerminalApp/CascadiaSettingsSerialization.cpp @@ -249,9 +249,9 @@ void CascadiaSettings::_LoadDynamicProfiles() const auto disabledProfileSources = CascadiaSettings::_GetDisabledProfileSourcesJsonObject(_userSettings); if (disabledProfileSources.isArray()) { - for (const auto& ns : disabledProfileSources) + for (const auto& json : disabledProfileSources) { - ignoredNamespaces.emplace(GetWstringFromJson(ns)); + ignoredNamespaces.emplace(JsonUtils::GetValue(json)); } } diff --git a/src/cascadia/TerminalApp/ColorScheme.cpp b/src/cascadia/TerminalApp/ColorScheme.cpp index 45d4e7748e4..525d8ec95cd 100644 --- a/src/cascadia/TerminalApp/ColorScheme.cpp +++ b/src/cascadia/TerminalApp/ColorScheme.cpp @@ -105,9 +105,9 @@ ColorScheme ColorScheme::FromJson(const Json::Value& json) // - true iff the json object has the same `name` as we do. bool ColorScheme::ShouldBeLayered(const Json::Value& json) const { - if (const auto name{ json[JsonKey(NameKey)] }) + std::wstring nameFromJson{}; + if (JsonUtils::GetValueForKey(json, NameKey, nameFromJson)) { - const auto nameFromJson = GetWstringFromJson(name); return nameFromJson == _schemeName; } return false; @@ -125,39 +125,16 @@ bool ColorScheme::ShouldBeLayered(const Json::Value& json) const // void ColorScheme::LayerJson(const Json::Value& json) { - if (auto name{ json[JsonKey(NameKey)] }) - { - _schemeName = winrt::to_hstring(name.asString()); - } - if (auto fgString{ json[JsonKey(ForegroundKey)] }) - { - const auto color = Utils::ColorFromHexString(fgString.asString()); - _defaultForeground = color; - } - if (auto bgString{ json[JsonKey(BackgroundKey)] }) - { - const auto color = Utils::ColorFromHexString(bgString.asString()); - _defaultBackground = color; - } - if (auto sbString{ json[JsonKey(SelectionBackgroundKey)] }) - { - const auto color = Utils::ColorFromHexString(sbString.asString()); - _selectionBackground = color; - } - if (auto sbString{ json[JsonKey(CursorColorKey)] }) - { - const auto color = Utils::ColorFromHexString(sbString.asString()); - _cursorColor = color; - } + JsonUtils::GetValueForKey(json, NameKey, _schemeName); + JsonUtils::GetValueForKey(json, ForegroundKey, _defaultForeground); + JsonUtils::GetValueForKey(json, BackgroundKey, _defaultBackground); + JsonUtils::GetValueForKey(json, SelectionBackgroundKey, _selectionBackground); + JsonUtils::GetValueForKey(json, CursorColorKey, _cursorColor); int i = 0; for (const auto& current : TableColors) { - if (auto str{ json[JsonKey(current)] }) - { - const auto color = Utils::ColorFromHexString(str.asString()); - _table.at(i) = color; - } + JsonUtils::GetValueForKey(json, current, _table.at(i)); i++; } } @@ -200,11 +177,7 @@ til::color ColorScheme::GetCursorColor() const noexcept // - the name of the color scheme represented by `json` as a std::wstring optional // i.e. the value of the `name` property. // - returns std::nullopt if `json` doesn't have the `name` property -std::optional TerminalApp::ColorScheme::GetNameFromJson(const Json::Value& json) +std::optional ColorScheme::GetNameFromJson(const Json::Value& json) { - if (const auto name{ json[JsonKey(NameKey)] }) - { - return GetWstringFromJson(name); - } - return std::nullopt; + return JsonUtils::GetValueForKey>(json, NameKey); } diff --git a/src/cascadia/TerminalApp/Command.cpp b/src/cascadia/TerminalApp/Command.cpp index a8e72ec6a84..f3fe1219126 100644 --- a/src/cascadia/TerminalApp/Command.cpp +++ b/src/cascadia/TerminalApp/Command.cpp @@ -7,10 +7,12 @@ #include "Utils.h" #include "ActionAndArgs.h" +#include "JsonUtils.h" #include using namespace winrt::Microsoft::Terminal::Settings; using namespace winrt::TerminalApp; +using namespace ::TerminalApp; static constexpr std::string_view NameKey{ "name" }; static constexpr std::string_view IconPathKey{ "iconPath" }; @@ -35,25 +37,17 @@ namespace winrt::TerminalApp::implementation { if (name.isObject()) { - try + if (const auto resourceKey{ JsonUtils::GetValueForKey>(name, "key") }) { - if (const auto keyJson{ name[JsonKey("key")] }) + if (HasLibraryResourceWithName(*resourceKey)) { - // Make sure the key is present before we try - // loading it. Otherwise we'll crash - const auto resourceKey = GetWstringFromJson(keyJson); - if (HasLibraryResourceWithName(resourceKey)) - { - return GetLibraryResourceString(resourceKey); - } + return GetLibraryResourceString(*resourceKey); } } - CATCH_LOG(); } else if (name.isString()) { - auto nameStr = name.asString(); - return winrt::to_hstring(nameStr); + return JsonUtils::GetValue(name); } } diff --git a/src/cascadia/TerminalApp/GlobalAppSettings.cpp b/src/cascadia/TerminalApp/GlobalAppSettings.cpp index 1e074d86cf2..c214c04896d 100644 --- a/src/cascadia/TerminalApp/GlobalAppSettings.cpp +++ b/src/cascadia/TerminalApp/GlobalAppSettings.cpp @@ -7,11 +7,11 @@ #include "../../inc/DefaultSettings.h" #include "Utils.h" #include "JsonUtils.h" +#include "TerminalSettingsSerializationHelpers.h" using namespace TerminalApp; using namespace winrt::Microsoft::Terminal::Settings; using namespace winrt::TerminalApp; -using namespace winrt::Windows::Data::Json; using namespace winrt::Windows::UI::Xaml; using namespace ::Microsoft::Console; using namespace winrt::Microsoft::UI::Xaml::Controls; @@ -44,21 +44,6 @@ static constexpr std::string_view ForceFullRepaintRenderingKey{ "experimental.re static constexpr std::string_view SoftwareRenderingKey{ "experimental.rendering.software" }; static constexpr std::string_view ForceVTInputKey{ "experimental.input.forceVT" }; -// Launch mode values -static constexpr std::wstring_view DefaultLaunchModeValue{ L"default" }; -static constexpr std::wstring_view MaximizedLaunchModeValue{ L"maximized" }; -static constexpr std::wstring_view FullscreenLaunchModeValue{ L"fullscreen" }; - -// Tab Width Mode values -static constexpr std::wstring_view EqualTabWidthModeValue{ L"equal" }; -static constexpr std::wstring_view TitleLengthTabWidthModeValue{ L"titleLength" }; -static constexpr std::wstring_view TitleLengthCompactModeValue{ L"compact" }; - -// Theme values -static constexpr std::wstring_view LightThemeValue{ L"light" }; -static constexpr std::wstring_view DarkThemeValue{ L"dark" }; -static constexpr std::wstring_view SystemThemeValue{ L"system" }; - #ifdef _DEBUG static constexpr bool debugFeaturesDefault{ true }; #else @@ -149,66 +134,51 @@ GlobalAppSettings GlobalAppSettings::FromJson(const Json::Value& json) void GlobalAppSettings::LayerJson(const Json::Value& json) { - if (auto defaultProfile{ json[JsonKey(DefaultProfileKey)] }) - { - _unparsedDefaultProfile.emplace(GetWstringFromJson(defaultProfile)); - } + JsonUtils::GetValueForKey(json, DefaultProfileKey, _unparsedDefaultProfile); - JsonUtils::GetBool(json, AlwaysShowTabsKey, _AlwaysShowTabs); + JsonUtils::GetValueForKey(json, AlwaysShowTabsKey, _AlwaysShowTabs); - JsonUtils::GetBool(json, ConfirmCloseAllKey, _ConfirmCloseAllTabs); + JsonUtils::GetValueForKey(json, ConfirmCloseAllKey, _ConfirmCloseAllTabs); - JsonUtils::GetInt(json, InitialRowsKey, _InitialRows); + JsonUtils::GetValueForKey(json, InitialRowsKey, _InitialRows); - JsonUtils::GetInt(json, InitialColsKey, _InitialCols); + JsonUtils::GetValueForKey(json, InitialColsKey, _InitialCols); - if (auto initialPosition{ json[JsonKey(InitialPositionKey)] }) - { - _ParseInitialPosition(initialPosition.asString(), _InitialPosition); - } + JsonUtils::GetValueForKey(json, InitialPositionKey, _InitialPosition); - JsonUtils::GetBool(json, ShowTitleInTitlebarKey, _ShowTitleInTitlebar); + JsonUtils::GetValueForKey(json, ShowTitleInTitlebarKey, _ShowTitleInTitlebar); - JsonUtils::GetBool(json, ShowTabsInTitlebarKey, _ShowTabsInTitlebar); + JsonUtils::GetValueForKey(json, ShowTabsInTitlebarKey, _ShowTabsInTitlebar); - JsonUtils::GetWstring(json, WordDelimitersKey, _WordDelimiters); + JsonUtils::GetValueForKey(json, WordDelimitersKey, _WordDelimiters); - JsonUtils::GetBool(json, CopyOnSelectKey, _CopyOnSelect); + JsonUtils::GetValueForKey(json, CopyOnSelectKey, _CopyOnSelect); - JsonUtils::GetBool(json, CopyFormattingKey, _CopyFormatting); + JsonUtils::GetValueForKey(json, CopyFormattingKey, _CopyFormatting); - JsonUtils::GetBool(json, WarnAboutLargePasteKey, _WarnAboutLargePaste); + JsonUtils::GetValueForKey(json, WarnAboutLargePasteKey, _WarnAboutLargePaste); - JsonUtils::GetBool(json, WarnAboutMultiLinePasteKey, _WarnAboutMultiLinePaste); + JsonUtils::GetValueForKey(json, WarnAboutMultiLinePasteKey, _WarnAboutMultiLinePaste); - if (auto launchMode{ json[JsonKey(LaunchModeKey)] }) - { - _LaunchMode = _ParseLaunchMode(GetWstringFromJson(launchMode)); - } + JsonUtils::GetValueForKey(json, LaunchModeKey, _LaunchMode); - if (auto theme{ json[JsonKey(ThemeKey)] }) - { - _Theme = _ParseTheme(GetWstringFromJson(theme)); - } + JsonUtils::GetValueForKey(json, ThemeKey, _Theme); - if (auto tabWidthMode{ json[JsonKey(TabWidthModeKey)] }) - { - _TabWidthMode = _ParseTabWidthMode(GetWstringFromJson(tabWidthMode)); - } + JsonUtils::GetValueForKey(json, TabWidthModeKey, _TabWidthMode); - JsonUtils::GetBool(json, SnapToGridOnResizeKey, _SnapToGridOnResize); + JsonUtils::GetValueForKey(json, SnapToGridOnResizeKey, _SnapToGridOnResize); - JsonUtils::GetBool(json, ForceFullRepaintRenderingKey, _ForceFullRepaintRendering); + // GetValueForKey will only override the current value if the key exists + JsonUtils::GetValueForKey(json, DebugFeaturesKey, _DebugFeaturesEnabled); - JsonUtils::GetBool(json, SoftwareRenderingKey, _SoftwareRendering); - JsonUtils::GetBool(json, ForceVTInputKey, _ForceVTInput); + JsonUtils::GetValueForKey(json, ForceFullRepaintRenderingKey, _ForceFullRepaintRendering); - // GetBool will only override the current value if the key exists - JsonUtils::GetBool(json, DebugFeaturesKey, _DebugFeaturesEnabled); + JsonUtils::GetValueForKey(json, SoftwareRenderingKey, _SoftwareRendering); + JsonUtils::GetValueForKey(json, ForceVTInputKey, _ForceVTInput); - JsonUtils::GetBool(json, EnableStartupTaskKey, _StartOnUserLogin); + JsonUtils::GetValueForKey(json, EnableStartupTaskKey, _StartOnUserLogin); - JsonUtils::GetBool(json, AlwaysOnTopKey, _AlwaysOnTop); + JsonUtils::GetValueForKey(json, AlwaysOnTopKey, _AlwaysOnTop); // This is a helper lambda to get the keybindings and commands out of both // and array of objects. We'll use this twice, once on the legacy @@ -236,116 +206,6 @@ void GlobalAppSettings::LayerJson(const Json::Value& json) parseBindings(BindingsKey); } -// Method Description: -// - Helper function for converting a user-specified cursor style corresponding -// CursorStyle enum value -// Arguments: -// - themeString: The string value from the settings file to parse -// Return Value: -// - The corresponding enum value which maps to the string provided by the user -ElementTheme GlobalAppSettings::_ParseTheme(const std::wstring& themeString) noexcept -{ - if (themeString == LightThemeValue) - { - return ElementTheme::Light; - } - else if (themeString == DarkThemeValue) - { - return ElementTheme::Dark; - } - // default behavior for invalid data or SystemThemeValue - return ElementTheme::Default; -} - -// Method Description: -// - Helper function for converting the initial position string into -// 2 coordinate values. We allow users to only provide one coordinate, -// thus, we use comma as the separator: -// (100, 100): standard input string -// (, 100), (100, ): if a value is missing, we set this value as a default -// (,): both x and y are set to default -// (abc, 100): if a value is not valid, we treat it as default -// (100, 100, 100): we only read the first two values, this is equivalent to (100, 100) -// Arguments: -// - initialPosition: the initial position string from json -// ret: reference to a struct whose optionals will be populated -// Return Value: -// - None -void GlobalAppSettings::_ParseInitialPosition(const std::string& initialPosition, - LaunchPosition& ret) noexcept -{ - static constexpr char singleCharDelim = ','; - std::stringstream tokenStream(initialPosition); - std::string token; - uint8_t initialPosIndex = 0; - - // Get initial position values till we run out of delimiter separated values in the stream - // or we hit max number of allowable values (= 2) - // Non-numeral values or empty string will be caught as exception and we do not assign them - for (; std::getline(tokenStream, token, singleCharDelim) && (initialPosIndex < 2); initialPosIndex++) - { - try - { - int32_t position = std::stoi(token); - if (initialPosIndex == 0) - { - ret.x.emplace(position); - } - - if (initialPosIndex == 1) - { - ret.y.emplace(position); - } - } - catch (...) - { - // Do nothing - } - } -} - -// Method Description: -// - Helper function for converting the user-specified launch mode -// to a LaunchMode enum value -// Arguments: -// - launchModeString: The string value from the settings file to parse -// Return Value: -// - The corresponding enum value which maps to the string provided by the user -LaunchMode GlobalAppSettings::_ParseLaunchMode(const std::wstring& launchModeString) noexcept -{ - if (launchModeString == MaximizedLaunchModeValue) - { - return LaunchMode::MaximizedMode; - } - else if (launchModeString == FullscreenLaunchModeValue) - { - return LaunchMode::FullscreenMode; - } - - return LaunchMode::DefaultMode; -} - -// Method Description: -// - Helper function for converting the user-specified tab width -// to a TabViewWidthMode enum value -// Arguments: -// - tabWidthModeString: The string value from the settings file to parse -// Return Value: -// - The corresponding enum value which maps to the string provided by the user -TabViewWidthMode GlobalAppSettings::_ParseTabWidthMode(const std::wstring& tabWidthModeString) noexcept -{ - if (tabWidthModeString == TitleLengthTabWidthModeValue) - { - return TabViewWidthMode::SizeToContent; - } - else if (tabWidthModeString == TitleLengthCompactModeValue) - { - return TabViewWidthMode::Compact; - } - // default behavior for invalid data or EqualTabWidthValue - return TabViewWidthMode::Equal; -} - // Method Description: // - Adds the given colorscheme to our map of schemes, using its name as the key. // Arguments: diff --git a/src/cascadia/TerminalApp/GlobalAppSettings.h b/src/cascadia/TerminalApp/GlobalAppSettings.h index 988d7fe1c08..7491b433f41 100644 --- a/src/cascadia/TerminalApp/GlobalAppSettings.h +++ b/src/cascadia/TerminalApp/GlobalAppSettings.h @@ -17,6 +17,7 @@ Author(s): #include "AppKeyBindings.h" #include "ColorScheme.h" #include "Command.h" +#include "SettingsTypes.h" // fwdecl unittest classes namespace TerminalAppLocalTests @@ -28,12 +29,6 @@ namespace TerminalAppLocalTests namespace TerminalApp { class GlobalAppSettings; - - struct LaunchPosition - { - std::optional x; - std::optional y; - }; }; class TerminalApp::GlobalAppSettings final @@ -96,15 +91,6 @@ class TerminalApp::GlobalAppSettings final std::unordered_map _colorSchemes; std::unordered_map _commands; - static winrt::Windows::UI::Xaml::ElementTheme _ParseTheme(const std::wstring& themeString) noexcept; - - static winrt::Microsoft::UI::Xaml::Controls::TabViewWidthMode _ParseTabWidthMode(const std::wstring& tabWidthModeString) noexcept; - - static void _ParseInitialPosition(const std::string& initialPosition, - LaunchPosition& ret) noexcept; - - static winrt::TerminalApp::LaunchMode _ParseLaunchMode(const std::wstring& launchModeString) noexcept; - friend class TerminalAppLocalTests::SettingsTests; friend class TerminalAppLocalTests::ColorSchemeTests; }; diff --git a/src/cascadia/TerminalApp/JsonUtils.cpp b/src/cascadia/TerminalApp/JsonUtils.cpp deleted file mode 100644 index f4282097b83..00000000000 --- a/src/cascadia/TerminalApp/JsonUtils.cpp +++ /dev/null @@ -1,125 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT license. - -#include "pch.h" -#include "Utils.h" -#include "JsonUtils.h" -#include "../../types/inc/Utils.hpp" - -void TerminalApp::JsonUtils::GetOptionalColor(const Json::Value& json, - std::string_view key, - std::optional& target) -{ - const auto conversionFn = [](const Json::Value& value) -> til::color { - return ::Microsoft::Console::Utils::ColorFromHexString(value.asString()); - }; - GetOptionalValue(json, - key, - target, - conversionFn); -} - -void TerminalApp::JsonUtils::GetOptionalString(const Json::Value& json, - std::string_view key, - std::optional& target) -{ - const auto conversionFn = [](const Json::Value& value) -> std::wstring { - return GetWstringFromJson(value); - }; - GetOptionalValue(json, - key, - target, - conversionFn); -} - -void TerminalApp::JsonUtils::GetOptionalGuid(const Json::Value& json, - std::string_view key, - std::optional& target) -{ - const auto conversionFn = [](const Json::Value& value) -> GUID { - return ::Microsoft::Console::Utils::GuidFromString(GetWstringFromJson(value)); - }; - GetOptionalValue(json, - key, - target, - conversionFn); -} - -void TerminalApp::JsonUtils::GetOptionalDouble(const Json::Value& json, - std::string_view key, - std::optional& target) -{ - const auto conversionFn = [](const Json::Value& value) -> double { - return value.asFloat(); - }; - const auto validationFn = [](const Json::Value& value) -> bool { - return value.isNumeric(); - }; - GetOptionalValue(json, - key, - target, - conversionFn, - validationFn); -} - -void TerminalApp::JsonUtils::GetInt(const Json::Value& json, - std::string_view key, - int& target) -{ - const auto conversionFn = [](const Json::Value& value) -> int { - return value.asInt(); - }; - const auto validationFn = [](const Json::Value& value) -> bool { - return value.isInt(); - }; - GetValue(json, key, target, conversionFn, validationFn); -} - -void TerminalApp::JsonUtils::GetUInt(const Json::Value& json, - std::string_view key, - uint32_t& target) -{ - const auto conversionFn = [](const Json::Value& value) -> uint32_t { - return value.asUInt(); - }; - const auto validationFn = [](const Json::Value& value) -> bool { - return value.isUInt(); - }; - GetValue(json, key, target, conversionFn, validationFn); -} - -void TerminalApp::JsonUtils::GetDouble(const Json::Value& json, - std::string_view key, - double& target) -{ - const auto conversionFn = [](const Json::Value& value) -> double { - return value.asFloat(); - }; - const auto validationFn = [](const Json::Value& value) -> bool { - return value.isNumeric(); - }; - GetValue(json, key, target, conversionFn, validationFn); -} - -void TerminalApp::JsonUtils::GetBool(const Json::Value& json, - std::string_view key, - bool& target) -{ - const auto conversionFn = [](const Json::Value& value) -> bool { - return value.asBool(); - }; - const auto validationFn = [](const Json::Value& value) -> bool { - return value.isBool(); - }; - GetValue(json, key, target, conversionFn, validationFn); -} - -void TerminalApp::JsonUtils::GetWstring(const Json::Value& json, - std::string_view key, - std::wstring& target) -{ - const auto conversionFn = [](const Json::Value& value) -> std::wstring { - return GetWstringFromJson(value); - }; - GetValue(json, key, target, conversionFn, nullptr); -} diff --git a/src/cascadia/TerminalApp/JsonUtils.h b/src/cascadia/TerminalApp/JsonUtils.h index 1845a9d6524..b98ade1da9d 100644 --- a/src/cascadia/TerminalApp/JsonUtils.h +++ b/src/cascadia/TerminalApp/JsonUtils.h @@ -9,136 +9,483 @@ Module Name: - Helpers for the TerminalApp project Author(s): - Mike Griese - August 2019 - +- Dustin Howett - January 2020 --*/ + #pragma once +#include + +#include "../types/inc/utils.hpp" + +namespace winrt +{ + // If we don't use winrt, nobody will include the ConversionTraits for winrt stuff. + // If nobody includes it, these forward declarations will suffice. + struct guid; + struct hstring; + namespace Windows::Foundation + { + template + struct IReference; + } +} + namespace TerminalApp::JsonUtils { - void GetOptionalColor(const Json::Value& json, - std::string_view key, - std::optional& target); + namespace Detail + { + // Function Description: + // - Returns a string_view to a Json::Value's internal string storage, + // hopefully without copying it. + __declspec(noinline) inline const std::string_view GetStringView(const Json::Value& json) + { + const char* begin{ nullptr }; + const char* end{ nullptr }; + json.getString(&begin, &end); + const std::string_view zeroCopyString{ begin, gsl::narrow_cast(end - begin) }; + return zeroCopyString; + } - void GetOptionalString(const Json::Value& json, - std::string_view key, - std::optional& target); + template + struct DeduceOptional + { + using Type = typename std::decay::type; + static constexpr bool IsOptional = false; + }; - void GetOptionalGuid(const Json::Value& json, - std::string_view key, - std::optional& target); + template + struct DeduceOptional> + { + using Type = typename std::decay::type; + static constexpr bool IsOptional = true; + }; - void GetOptionalDouble(const Json::Value& json, - std::string_view key, - std::optional& target); + template + struct DeduceOptional<::winrt::Windows::Foundation::IReference> + { + using Type = typename std::decay::type; + static constexpr bool IsOptional = true; + }; + } - // Method Description: - // - Helper that can be used for retrieving an optional value from a json - // object, and parsing it's value to layer on a given target object. - // - If the key we're looking for _doesn't_ exist in the json object, - // we'll leave the target object unmodified. - // - If the key exists in the json object, but is set to `null`, then - // we'll instead set the target back to nullopt. - // - Each caller should provide a conversion function that takes a - // Json::Value and returns an object of the same type as target. - // Arguments: - // - json: The json object to search for the given key - // - key: The key to look for in the json object - // - target: the optional object to receive the value from json - // - conversion: a std::function which can be used to - // convert the Json::Value to the appropriate type. - // - validation: optional, if provided, will be called first to ensure that - // the json::value is of the correct type before attempting to call - // `conversion`. - // Return Value: - // - - template - void GetOptionalValue(const Json::Value& json, - std::string_view key, - std::optional& target, - F&& conversion, - const std::function& validation = nullptr) + // These exceptions cannot use localized messages, as we do not have + // guaranteed access to the resource loader. + class TypeMismatchException : public std::runtime_error + { + public: + TypeMismatchException() : + runtime_error("unexpected data type") {} + }; + + class KeyedException : public std::runtime_error + { + public: + KeyedException(const std::string_view key, std::exception_ptr exception) : + runtime_error(fmt::format("error parsing \"{0}\"", key).c_str()), + _key{ key }, + _innerException{ std::move(exception) } {} + + std::string GetKey() const + { + return _key; + } + + [[noreturn]] void RethrowInner() const + { + std::rethrow_exception(_innerException); + } + + private: + std::string _key; + std::exception_ptr _innerException; + }; + + class UnexpectedValueException : public std::runtime_error + { + public: + UnexpectedValueException(const std::string_view value) : + runtime_error(fmt::format("unexpected value \"{0}\"", value).c_str()), + _value{ value } {} + + std::string GetValue() const + { + return _value; + } + + private: + std::string _value; + }; + + template + struct ConversionTrait + { + // Forward-declare these so the linker can pick up specializations from elsewhere! + T FromJson(const Json::Value&); + bool CanConvert(const Json::Value& json); + }; + + template<> + struct ConversionTrait + { + std::string FromJson(const Json::Value& json) + { + return json.asString(); + } + + bool CanConvert(const Json::Value& json) + { + return json.isString(); + } + }; + + template<> + struct ConversionTrait + { + std::wstring FromJson(const Json::Value& json) + { + return til::u8u16(Detail::GetStringView(json)); + } + + bool CanConvert(const Json::Value& json) + { + return json.isString(); + } + }; + +#ifdef WINRT_BASE_H + template<> + struct ConversionTrait : public ConversionTrait + { + // Leverage the wstring converter's validation + winrt::hstring FromJson(const Json::Value& json) + { + return winrt::hstring{ til::u8u16(Detail::GetStringView(json)) }; + } + }; +#endif + + template<> + struct ConversionTrait + { + bool FromJson(const Json::Value& json) + { + return json.asBool(); + } + + bool CanConvert(const Json::Value& json) + { + return json.isBool(); + } + }; + + template<> + struct ConversionTrait + { + int FromJson(const Json::Value& json) + { + return json.asInt(); + } + + bool CanConvert(const Json::Value& json) + { + return json.isInt(); + } + }; + + template<> + struct ConversionTrait + { + unsigned int FromJson(const Json::Value& json) + { + return json.asUInt(); + } + + bool CanConvert(const Json::Value& json) + { + return json.isUInt(); + } + }; + + template<> + struct ConversionTrait + { + float FromJson(const Json::Value& json) + { + return json.asFloat(); + } + + bool CanConvert(const Json::Value& json) + { + return json.isNumeric(); + } + }; + + template<> + struct ConversionTrait + { + double FromJson(const Json::Value& json) + { + return json.asDouble(); + } + + bool CanConvert(const Json::Value& json) + { + return json.isNumeric(); + } + }; + + template<> + struct ConversionTrait + { + GUID FromJson(const Json::Value& json) + { + return ::Microsoft::Console::Utils::GuidFromString(til::u8u16(Detail::GetStringView(json))); + } + + bool CanConvert(const Json::Value& json) + { + if (!json.isString()) + { + return false; + } + + const auto string{ Detail::GetStringView(json) }; + return string.length() == 38 && string.front() == '{' && string.back() == '}'; + } + }; + + // (GUID and winrt::guid are mutually convertible!) + template<> + struct ConversionTrait : public ConversionTrait + { + }; + + template<> + struct ConversionTrait + { + til::color FromJson(const Json::Value& json) + { + return ::Microsoft::Console::Utils::ColorFromHexString(Detail::GetStringView(json)); + } + + bool CanConvert(const Json::Value& json) + { + if (!json.isString()) + { + return false; + } + + const auto string{ Detail::GetStringView(json) }; + return (string.length() == 7 || string.length() == 4) && string.front() == '#'; + } + }; + + template + struct EnumMapper { - if (json.isMember(JsonKey(key))) + using BaseEnumMapper = EnumMapper; + using ValueType = T; + using pair_type = std::pair; + T FromJson(const Json::Value& json) { - if (auto jsonVal{ json[JsonKey(key)] }) + const auto name{ Detail::GetStringView(json) }; + for (const auto& pair : TBase::mappings) { - if (validation == nullptr || validation(jsonVal)) + if (pair.first == name) { - target = conversion(jsonVal); + return pair.second; } } - else + + throw UnexpectedValueException{ name }; + } + + bool CanConvert(const Json::Value& json) + { + return json.isString(); + } + }; + + // FlagMapper is EnumMapper, but it works for bitfields. + // It supports a string (single flag) or an array of strings. + // Does an O(n*m) search; meant for small search spaces! + // + // Cleverly leverage EnumMapper to do the heavy lifting. + template + struct FlagMapper : public EnumMapper + { + private: + // Hide BaseEnumMapper so FlagMapper's consumers cannot see + // it. + using BaseEnumMapper = EnumMapper::BaseEnumMapper; + + public: + using BaseFlagMapper = FlagMapper; + static constexpr T AllSet{ static_cast(~0u) }; + static constexpr T AllClear{ static_cast(0u) }; + + T FromJson(const Json::Value& json) + { + if (json.isString()) + { + return BaseEnumMapper::FromJson(json); + } + else if (json.isArray()) { - // This branch is hit when the json object contained the key, - // but the key was set to `null`. In this case, explicitly clear - // the target. - target = std::nullopt; + unsigned int seen{ 0 }; + T value{}; + for (const auto& element : json) + { + const auto newFlag{ BaseEnumMapper::FromJson(element) }; + if (++seen > 1 && + ((newFlag == AllClear && value != AllClear) || + (value == AllClear && newFlag != AllClear))) + { + // attempt to combine AllClear (explicitly) with anything else + throw UnexpectedValueException{ element.asString() }; + } + value |= newFlag; + } + return value; } + + // We'll only get here if CanConvert has failed us. + return AllClear; } - } + + bool CanConvert(const Json::Value& json) + { + return BaseEnumMapper::CanConvert(json) || json.isArray(); + } + }; // Method Description: - // - Helper that can be used for retrieving a value from a json - // object, and parsing it's value to set on a given target object. - // - If the key we're looking for _doesn't_ exist in the json object, - // we'll leave the target object unmodified. - // - If the key exists in the json object, we'll use the provided - // `validation` function to ensure that the json value is of the - // correct type. - // - If we successfully validate the json value type (or no validation - // function was provided), then we'll use `conversion` to parse the - // value and place the result into `target` - // - Each caller should provide a conversion function that takes a - // Json::Value and returns an object of the same type as target. - // - Unlike GetOptionalValue, if the key exists but is set to `null`, we'll - // just ignore it. + // - Helper that will populate a reference with a value converted from a json object. // Arguments: - // - json: The json object to search for the given key - // - key: The key to look for in the json object - // - target: the optional object to receive the value from json - // - conversion: a std::function which can be used to - // convert the Json::Value to the appropriate type. - // - validation: optional, if provided, will be called first to ensure that - // the json::value is of the correct type before attempting to call - // `conversion`. + // - json: the json object to convert + // - target: the value to populate with the converted result // Return Value: - // - - template - void GetValue(const Json::Value& json, - std::string_view key, - T& target, - F&& conversion, - const std::function& validation = nullptr) + // - a boolean indicating whether the value existed (in this case, was non-null) + // + // GetValue, type-deduced, manual converter + template + bool GetValue(const Json::Value& json, T& target, Converter&& conv) { - if (json.isMember(JsonKey(key))) + if constexpr (Detail::DeduceOptional::IsOptional) { - if (auto jsonVal{ json[JsonKey(key)] }) + // FOR OPTION TYPES + // - If the json object is set to `null`, then + // we'll instead set the target back to the empty optional. + if (json.isNull()) { - if (validation == nullptr || validation(jsonVal)) - { - target = conversion(jsonVal); - } + target = T{}; // zero-construct an empty optional + return true; + } + } + + if (json) + { + if (!conv.CanConvert(json)) + { + throw TypeMismatchException{}; + } + + target = conv.FromJson(json); + return true; + } + return false; + } + + // GetValue, forced return type, manual converter + template + std::decay_t GetValue(const Json::Value& json, Converter&& conv) + { + std::decay_t local{}; + GetValue(json, local, std::forward(conv)); + return local; // returns zero-initialized or value + } + + // GetValueForKey, type-deduced, manual converter + template + bool GetValueForKey(const Json::Value& json, std::string_view key, T& target, Converter&& conv) + { + if (auto found{ json.find(&*key.cbegin(), (&*key.cbegin()) + key.size()) }) + { + try + { + return GetValue(*found, target, std::forward(conv)); + } + catch (...) + { + // Wrap any caught exceptions in one that preserves context. + throw KeyedException(key, std::current_exception()); } } + return false; } - void GetInt(const Json::Value& json, - std::string_view key, - int& target); + // GetValueForKey, forced return type, manual converter + template + std::decay_t GetValueForKey(const Json::Value& json, std::string_view key, Converter&& conv) + { + std::decay_t local{}; + GetValueForKey(json, key, local, std::forward(conv)); + return local; // returns zero-initialized? + } - void GetUInt(const Json::Value& json, - std::string_view key, - uint32_t& target); + // GetValue, type-deduced, with automatic converter + template + bool GetValue(const Json::Value& json, T& target) + { + return GetValue(json, target, ConversionTrait::Type>{}); + } - void GetDouble(const Json::Value& json, - std::string_view key, - double& target); + // GetValue, forced return type, with automatic converter + template + std::decay_t GetValue(const Json::Value& json) + { + std::decay_t local{}; + GetValue(json, local, ConversionTrait::Type>{}); + return local; // returns zero-initialized or value + } - void GetBool(const Json::Value& json, - std::string_view key, - bool& target); + // GetValueForKey, type-deduced, with automatic converter + template + bool GetValueForKey(const Json::Value& json, std::string_view key, T& target) + { + return GetValueForKey(json, key, target, ConversionTrait::Type>{}); + } + + // GetValueForKey, forced return type, with automatic converter + template + std::decay_t GetValueForKey(const Json::Value& json, std::string_view key) + { + return GetValueForKey(json, key, ConversionTrait::Type>{}); + } + + // Get multiple values for keys (json, k, &v, k, &v, k, &v, ...). + // Uses the default converter for each v. + // Careful: this can cause a template explosion. + constexpr void GetValuesForKeys(const Json::Value& /*json*/) {} - void GetWstring(const Json::Value& json, - std::string_view key, - std::wstring& target); + template + void GetValuesForKeys(const Json::Value& json, std::string_view key1, T&& val1, Args&&... args) + { + GetValueForKey(json, key1, val1); + GetValuesForKeys(json, std::forward(args)...); + } }; + +#define JSON_ENUM_MAPPER(...) \ + template<> \ + struct ::TerminalApp::JsonUtils::ConversionTrait<__VA_ARGS__> : \ + public ::TerminalApp::JsonUtils::EnumMapper<__VA_ARGS__, ::TerminalApp::JsonUtils::ConversionTrait<__VA_ARGS__>> + +#define JSON_FLAG_MAPPER(...) \ + template<> \ + struct ::TerminalApp::JsonUtils::ConversionTrait<__VA_ARGS__> : \ + public ::TerminalApp::JsonUtils::FlagMapper<__VA_ARGS__, ::TerminalApp::JsonUtils::ConversionTrait<__VA_ARGS__>> + +#define JSON_MAPPINGS(Count) \ + static constexpr std::array mappings diff --git a/src/cascadia/TerminalApp/JsonUtilsNew.h b/src/cascadia/TerminalApp/JsonUtilsNew.h deleted file mode 100644 index 03e9826f4b2..00000000000 --- a/src/cascadia/TerminalApp/JsonUtilsNew.h +++ /dev/null @@ -1,490 +0,0 @@ -/*++ -Copyright (c) Microsoft Corporation -Licensed under the MIT license. - -Module Name: -- JsonUtils.h - -Abstract: -- Helpers for the TerminalApp project -Author(s): -- Mike Griese - August 2019 -- Dustin Howett - January 2020 ---*/ - -#pragma once - -#include - -#include "../types/inc/utils.hpp" - -namespace winrt -{ - // If we don't use winrt, nobody will include the ConversionTraits for winrt stuff. - // If nobody includes it, these forward declarations will suffice. - struct guid; - struct hstring; - namespace Windows::Foundation - { - template - struct IReference; - } -} - -namespace TerminalApp::JsonUtils -{ - namespace Detail - { - // Function Description: - // - Returns a string_view to a Json::Value's internal string storage, - // hopefully without copying it. - __declspec(noinline) inline const std::string_view GetStringView(const Json::Value& json) - { - const char* begin{ nullptr }; - const char* end{ nullptr }; - json.getString(&begin, &end); - const std::string_view zeroCopyString{ begin, gsl::narrow_cast(end - begin) }; - return zeroCopyString; - } - - template - struct DeduceOptional - { - using Type = typename std::decay::type; - static constexpr bool IsOptional = false; - }; - - template - struct DeduceOptional> - { - using Type = typename std::decay::type; - static constexpr bool IsOptional = true; - }; - - template - struct DeduceOptional<::winrt::Windows::Foundation::IReference> - { - using Type = typename std::decay::type; - static constexpr bool IsOptional = true; - }; - } - - // These exceptions cannot use localized messages, as we do not have - // guaranteed access to the resource loader. - class TypeMismatchException : public std::runtime_error - { - public: - TypeMismatchException() : - runtime_error("unexpected data type") {} - }; - - class KeyedException : public std::runtime_error - { - public: - KeyedException(const std::string_view key, std::exception_ptr exception) : - runtime_error(fmt::format("error parsing \"{0}\"", key).c_str()), - _key{ key }, - _innerException{ std::move(exception) } {} - - std::string GetKey() const - { - return _key; - } - - [[noreturn]] void RethrowInner() const - { - std::rethrow_exception(_innerException); - } - - private: - std::string _key; - std::exception_ptr _innerException; - }; - - class UnexpectedValueException : public std::runtime_error - { - public: - UnexpectedValueException(const std::string_view value) : - runtime_error(fmt::format("unexpected value \"{0}\"", value).c_str()), - _value{ value } {} - - std::string GetValue() const - { - return _value; - } - - private: - std::string _value; - }; - - template - struct ConversionTrait - { - // Forward-declare these so the linker can pick up specializations from elsewhere! - T FromJson(const Json::Value&); - bool CanConvert(const Json::Value& json); - }; - - template<> - struct ConversionTrait - { - std::string FromJson(const Json::Value& json) - { - return json.asString(); - } - - bool CanConvert(const Json::Value& json) - { - return json.isString(); - } - }; - - template<> - struct ConversionTrait - { - std::wstring FromJson(const Json::Value& json) - { - return til::u8u16(Detail::GetStringView(json)); - } - - bool CanConvert(const Json::Value& json) - { - return json.isString(); - } - }; - -#ifdef WINRT_BASE_H - template<> - struct ConversionTrait : public ConversionTrait - { - // Leverage the wstring converter's validation - winrt::hstring FromJson(const Json::Value& json) - { - return winrt::hstring{ til::u8u16(Detail::GetStringView(json)) }; - } - }; -#endif - - template<> - struct ConversionTrait - { - bool FromJson(const Json::Value& json) - { - return json.asBool(); - } - - bool CanConvert(const Json::Value& json) - { - return json.isBool(); - } - }; - - template<> - struct ConversionTrait - { - int FromJson(const Json::Value& json) - { - return json.asInt(); - } - - bool CanConvert(const Json::Value& json) - { - return json.isInt(); - } - }; - - template<> - struct ConversionTrait - { - unsigned int FromJson(const Json::Value& json) - { - return json.asUInt(); - } - - bool CanConvert(const Json::Value& json) - { - return json.isUInt(); - } - }; - - template<> - struct ConversionTrait - { - float FromJson(const Json::Value& json) - { - return json.asFloat(); - } - - bool CanConvert(const Json::Value& json) - { - return json.isNumeric(); - } - }; - - template<> - struct ConversionTrait - { - double FromJson(const Json::Value& json) - { - return json.asDouble(); - } - - bool CanConvert(const Json::Value& json) - { - return json.isNumeric(); - } - }; - - template<> - struct ConversionTrait - { - GUID FromJson(const Json::Value& json) - { - return ::Microsoft::Console::Utils::GuidFromString(til::u8u16(Detail::GetStringView(json))); - } - - bool CanConvert(const Json::Value& json) - { - if (!json.isString()) - { - return false; - } - - const auto string{ Detail::GetStringView(json) }; - return string.length() == 38 && string.front() == '{' && string.back() == '}'; - } - }; - - // (GUID and winrt::guid are mutually convertible!) - template<> - struct ConversionTrait : public ConversionTrait - { - }; - - template<> - struct ConversionTrait - { - til::color FromJson(const Json::Value& json) - { - return ::Microsoft::Console::Utils::ColorFromHexString(Detail::GetStringView(json)); - } - - bool CanConvert(const Json::Value& json) - { - if (!json.isString()) - { - return false; - } - - const auto string{ Detail::GetStringView(json) }; - return (string.length() == 7 || string.length() == 4) && string.front() == '#'; - } - }; - - template - struct EnumMapper - { - using BaseEnumMapper = EnumMapper; - using pair_type = std::pair; - T FromJson(const Json::Value& json) - { - const auto name{ Detail::GetStringView(json) }; - for (const auto& pair : TBase::mappings) - { - if (pair.first == name) - { - return pair.second; - } - } - - throw UnexpectedValueException{ name }; - } - - bool CanConvert(const Json::Value& json) - { - return json.isString(); - } - }; - - // FlagMapper is EnumMapper, but it works for bitfields. - // It supports a string (single flag) or an array of strings. - // Does an O(n*m) search; meant for small search spaces! - // - // Cleverly leverage EnumMapper to do the heavy lifting. - template - struct FlagMapper : public EnumMapper - { - private: - // Hide BaseEnumMapper so FlagMapper's consumers cannot see - // it. - using BaseEnumMapper = EnumMapper::BaseEnumMapper; - - public: - using BaseFlagMapper = FlagMapper; - static constexpr T AllSet{ static_cast(~0u) }; - static constexpr T AllClear{ static_cast(0u) }; - - T FromJson(const Json::Value& json) - { - if (json.isString()) - { - return BaseEnumMapper::FromJson(json); - } - else if (json.isArray()) - { - unsigned int seen{ 0 }; - T value{}; - for (const auto& element : json) - { - const auto newFlag{ BaseEnumMapper::FromJson(element) }; - if (++seen > 1 && - ((newFlag == AllClear && value != AllClear) || - (value == AllClear && newFlag != AllClear))) - { - // attempt to combine AllClear (explicitly) with anything else - throw UnexpectedValueException{ element.asString() }; - } - value |= newFlag; - } - return value; - } - - // We'll only get here if CanConvert has failed us. - return AllClear; - } - - bool CanConvert(const Json::Value& json) - { - return BaseEnumMapper::CanConvert(json) || json.isArray(); - } - }; - - // Method Description: - // - Helper that will populate a reference with a value converted from a json object. - // Arguments: - // - json: the json object to convert - // - target: the value to populate with the converted result - // Return Value: - // - a boolean indicating whether the value existed (in this case, was non-null) - // - // GetValue, type-deduced, manual converter - template - bool GetValue(const Json::Value& json, T& target, Converter&& conv) - { - if constexpr (Detail::DeduceOptional::IsOptional) - { - // FOR OPTION TYPES - // - If the json object is set to `null`, then - // we'll instead set the target back to the empty optional. - if (json.isNull()) - { - target = T{}; // zero-construct an empty optional - return true; - } - } - - if (json) - { - if (!conv.CanConvert(json)) - { - throw TypeMismatchException{}; - } - - target = conv.FromJson(json); - return true; - } - return false; - } - - // GetValue, forced return type, manual converter - template - std::decay_t GetValue(const Json::Value& json, Converter&& conv) - { - std::decay_t local{}; - GetValue(json, local, std::forward(conv)); - return local; // returns zero-initialized or value - } - - // GetValueForKey, type-deduced, manual converter - template - bool GetValueForKey(const Json::Value& json, std::string_view key, T& target, Converter&& conv) - { - if (auto found{ json.find(&*key.cbegin(), (&*key.cbegin()) + key.size()) }) - { - try - { - return GetValue(*found, target, std::forward(conv)); - } - catch (...) - { - // Wrap any caught exceptions in one that preserves context. - throw KeyedException(key, std::current_exception()); - } - } - return false; - } - - // GetValueForKey, forced return type, manual converter - template - std::decay_t GetValueForKey(const Json::Value& json, std::string_view key, Converter&& conv) - { - std::decay_t local{}; - GetValueForKey(json, key, local, std::forward(conv)); - return local; // returns zero-initialized? - } - - // GetValue, type-deduced, with automatic converter - template - bool GetValue(const Json::Value& json, T& target) - { - return GetValue(json, target, ConversionTrait::Type>{}); - } - - // GetValue, forced return type, with automatic converter - template - std::decay_t GetValue(const Json::Value& json) - { - std::decay_t local{}; - GetValue(json, local, ConversionTrait::Type>{}); - return local; // returns zero-initialized or value - } - - // GetValueForKey, type-deduced, with automatic converter - template - bool GetValueForKey(const Json::Value& json, std::string_view key, T& target) - { - return GetValueForKey(json, key, target, ConversionTrait::Type>{}); - } - - // GetValueForKey, forced return type, with automatic converter - template - std::decay_t GetValueForKey(const Json::Value& json, std::string_view key) - { - return GetValueForKey(json, key, ConversionTrait::Type>{}); - } - - // Get multiple values for keys (json, k, &v, k, &v, k, &v, ...). - // Uses the default converter for each v. - // Careful: this can cause a template explosion. - constexpr void GetValuesForKeys(const Json::Value& /*json*/) {} - - template - void GetValuesForKeys(const Json::Value& json, std::string_view key1, T&& val1, Args&&... args) - { - GetValueForKey(json, key1, val1); - GetValuesForKeys(json, std::forward(args)...); - } -}; - -#define JSON_ENUM_MAPPER(...) \ - template<> \ - struct ::TerminalApp::JsonUtils::ConversionTrait<__VA_ARGS__> : \ - public ::TerminalApp::JsonUtils::EnumMapper<__VA_ARGS__, ::TerminalApp::JsonUtils::ConversionTrait<__VA_ARGS__>> - -#define JSON_FLAG_MAPPER(...) \ - template<> \ - struct ::TerminalApp::JsonUtils::ConversionTrait<__VA_ARGS__> : \ - public ::TerminalApp::JsonUtils::FlagMapper<__VA_ARGS__, ::TerminalApp::JsonUtils::ConversionTrait<__VA_ARGS__>> - -#define JSON_MAPPINGS(Count) \ - static constexpr std::array mappings diff --git a/src/cascadia/TerminalApp/Profile.cpp b/src/cascadia/TerminalApp/Profile.cpp index 5ee40fd27a2..7cd80a65b11 100644 --- a/src/cascadia/TerminalApp/Profile.cpp +++ b/src/cascadia/TerminalApp/Profile.cpp @@ -9,6 +9,7 @@ #include #include "LegacyProfileGeneratorNamespaces.h" +#include "TerminalSettingsSerializationHelpers.h" using namespace TerminalApp; using namespace winrt::Microsoft::Terminal::Settings; @@ -52,57 +53,6 @@ static constexpr std::string_view BackgroundImageAlignmentKey{ "backgroundImageA static constexpr std::string_view RetroTerminalEffectKey{ "experimental.retroTerminalEffect" }; static constexpr std::string_view AntialiasingModeKey{ "antialiasingMode" }; -// Possible values for closeOnExit -static constexpr std::string_view CloseOnExitAlways{ "always" }; -static constexpr std::string_view CloseOnExitGraceful{ "graceful" }; -static constexpr std::string_view CloseOnExitNever{ "never" }; - -// Possible values for Scrollbar state -static constexpr std::wstring_view AlwaysVisible{ L"visible" }; -static constexpr std::wstring_view AlwaysHide{ L"hidden" }; - -// Possible values for Cursor Shape -static constexpr std::wstring_view CursorShapeVintage{ L"vintage" }; -static constexpr std::wstring_view CursorShapeBar{ L"bar" }; -static constexpr std::wstring_view CursorShapeUnderscore{ L"underscore" }; -static constexpr std::wstring_view CursorShapeFilledbox{ L"filledBox" }; -static constexpr std::wstring_view CursorShapeEmptybox{ L"emptyBox" }; - -// Possible values for Font Weight -static constexpr std::string_view FontWeightThin{ "thin" }; -static constexpr std::string_view FontWeightExtraLight{ "extra-light" }; -static constexpr std::string_view FontWeightLight{ "light" }; -static constexpr std::string_view FontWeightSemiLight{ "semi-light" }; -static constexpr std::string_view FontWeightNormal{ "normal" }; -static constexpr std::string_view FontWeightMedium{ "medium" }; -static constexpr std::string_view FontWeightSemiBold{ "semi-bold" }; -static constexpr std::string_view FontWeightBold{ "bold" }; -static constexpr std::string_view FontWeightExtraBold{ "extra-bold" }; -static constexpr std::string_view FontWeightBlack{ "black" }; -static constexpr std::string_view FontWeightExtraBlack{ "extra-black" }; - -// Possible values for Image Stretch Mode -static constexpr std::string_view ImageStretchModeNone{ "none" }; -static constexpr std::string_view ImageStretchModeFill{ "fill" }; -static constexpr std::string_view ImageStretchModeUniform{ "uniform" }; -static constexpr std::string_view ImageStretchModeUniformTofill{ "uniformToFill" }; - -// Possible values for Image Alignment -static constexpr std::string_view ImageAlignmentCenter{ "center" }; -static constexpr std::string_view ImageAlignmentLeft{ "left" }; -static constexpr std::string_view ImageAlignmentTop{ "top" }; -static constexpr std::string_view ImageAlignmentRight{ "right" }; -static constexpr std::string_view ImageAlignmentBottom{ "bottom" }; -static constexpr std::string_view ImageAlignmentTopLeft{ "topLeft" }; -static constexpr std::string_view ImageAlignmentTopRight{ "topRight" }; -static constexpr std::string_view ImageAlignmentBottomLeft{ "bottomLeft" }; -static constexpr std::string_view ImageAlignmentBottomRight{ "bottomRight" }; - -// Possible values for TextAntialiasingMode -static constexpr std::wstring_view AntialiasingModeGrayscale{ L"grayscale" }; -static constexpr std::wstring_view AntialiasingModeCleartype{ L"cleartype" }; -static constexpr std::wstring_view AntialiasingModeAliased{ L"aliased" }; - Profile::Profile() : Profile(std::nullopt) { @@ -248,8 +198,7 @@ TerminalSettings Profile::CreateTerminalSettings(const std::unordered_map>(json, GuidKey) }) { - const auto guid{ json[JsonKey(GuidKey)] }; - const auto otherGuid = Utils::GuidFromString(GetWstringFromJson(guid)); - if (_guid.value() != otherGuid) + if (otherGuid != _guid) // optional compare takes care of this { return false; } @@ -368,16 +315,17 @@ bool Profile::ShouldBeLayered(const Json::Value& json) const return false; } - const auto& otherSource = json.isMember(JsonKey(SourceKey)) ? json[JsonKey(SourceKey)] : Json::Value::null; + std::optional otherSource; + bool otherHadSource = JsonUtils::GetValueForKey(json, SourceKey, otherSource); // For profiles with a `source`, also check the `source` property. bool sourceMatches = false; if (_source.has_value()) { - if (json.isMember(JsonKey(SourceKey))) + if (otherHadSource) { - const auto otherSourceString = GetWstringFromJson(otherSource); - sourceMatches = otherSourceString == _source.value(); + // If we have a source and the other has a source, compare them! + sourceMatches = otherSource == _source; } else { @@ -395,52 +343,13 @@ bool Profile::ShouldBeLayered(const Json::Value& json) const } else { - // We do not have a source. The only way we match is if source is set to null or "". - if (otherSource.isNull() || (otherSource.isString() && otherSource == "")) - { - sourceMatches = true; - } + // We do not have a source. The only way we match is if source is unset or set to "". + sourceMatches = (!otherSource.has_value() || otherSource.value() == L""); } return sourceMatches; } -// Method Description: -// - Helper function to convert a json value into a value of the Stretch enum. -// Calls into ParseImageStretchMode. Used with JsonUtils::GetOptionalValue. -// Arguments: -// - json: the Json::Value object to parse. -// Return Value: -// - An appropriate value from Windows.UI.Xaml.Media.Stretch -Media::Stretch Profile::_ConvertJsonToStretchMode(const Json::Value& json) -{ - return Profile::ParseImageStretchMode(json.asString()); -} - -// Method Description: -// - Helper function to convert a json value into a value of the Stretch enum. -// Calls into ParseImageAlignment. Used with JsonUtils::GetOptionalValue. -// Arguments: -// - json: the Json::Value object to parse. -// Return Value: -// - A pair of HorizontalAlignment and VerticalAlignment -std::tuple Profile::_ConvertJsonToAlignment(const Json::Value& json) -{ - return Profile::ParseImageAlignment(json.asString()); -} - -// Method Description: -// - Helper function to convert a json value into a bool. -// Used with JsonUtils::GetOptionalValue. -// Arguments: -// - json: the Json::Value object to parse. -// Return Value: -// - A bool -bool Profile::_ConvertJsonToBool(const Json::Value& json) -{ - return json.asBool(); -} - // Method Description: // - Layer values from the given json object on top of the existing properties // of this object. For any keys we're expecting to be able to parse in the @@ -456,89 +365,45 @@ bool Profile::_ConvertJsonToBool(const Json::Value& json) void Profile::LayerJson(const Json::Value& json) { // Profile-specific Settings - JsonUtils::GetWstring(json, NameKey, _name); - - JsonUtils::GetOptionalGuid(json, GuidKey, _guid); - - JsonUtils::GetBool(json, HiddenKey, _hidden); + JsonUtils::GetValueForKey(json, NameKey, _name); + JsonUtils::GetValueForKey(json, GuidKey, _guid); + JsonUtils::GetValueForKey(json, HiddenKey, _hidden); // Core Settings - JsonUtils::GetOptionalColor(json, ForegroundKey, _defaultForeground); - - JsonUtils::GetOptionalColor(json, BackgroundKey, _defaultBackground); - - JsonUtils::GetOptionalColor(json, SelectionBackgroundKey, _selectionBackground); - - JsonUtils::GetOptionalColor(json, CursorColorKey, _cursorColor); - - JsonUtils::GetOptionalString(json, ColorSchemeKey, _schemeName); + JsonUtils::GetValueForKey(json, ForegroundKey, _defaultForeground); + JsonUtils::GetValueForKey(json, BackgroundKey, _defaultBackground); + JsonUtils::GetValueForKey(json, SelectionBackgroundKey, _selectionBackground); + JsonUtils::GetValueForKey(json, CursorColorKey, _cursorColor); + JsonUtils::GetValueForKey(json, ColorSchemeKey, _schemeName); // TODO:MSFT:20642297 - Use a sentinel value (-1) for "Infinite scrollback" - JsonUtils::GetInt(json, HistorySizeKey, _historySize); - - JsonUtils::GetBool(json, SnapOnInputKey, _snapOnInput); - - JsonUtils::GetBool(json, AltGrAliasingKey, _altGrAliasing); - - JsonUtils::GetUInt(json, CursorHeightKey, _cursorHeight); - - if (json.isMember(JsonKey(CursorShapeKey))) - { - auto cursorShape{ json[JsonKey(CursorShapeKey)] }; - _cursorShape = _ParseCursorShape(GetWstringFromJson(cursorShape)); - } - JsonUtils::GetOptionalString(json, TabTitleKey, _tabTitle); + JsonUtils::GetValueForKey(json, HistorySizeKey, _historySize); + JsonUtils::GetValueForKey(json, SnapOnInputKey, _snapOnInput); + JsonUtils::GetValueForKey(json, AltGrAliasingKey, _altGrAliasing); + JsonUtils::GetValueForKey(json, CursorHeightKey, _cursorHeight); + JsonUtils::GetValueForKey(json, CursorShapeKey, _cursorShape); + JsonUtils::GetValueForKey(json, TabTitleKey, _tabTitle); // Control Settings - JsonUtils::GetOptionalGuid(json, ConnectionTypeKey, _connectionType); - - JsonUtils::GetWstring(json, CommandlineKey, _commandline); - - JsonUtils::GetWstring(json, FontFaceKey, _fontFace); - - JsonUtils::GetInt(json, FontSizeKey, _fontSize); - - if (json.isMember(JsonKey(FontWeightKey))) - { - auto fontWeight{ json[JsonKey(FontWeightKey)] }; - _fontWeight = _ParseFontWeight(fontWeight); - } - - JsonUtils::GetDouble(json, AcrylicTransparencyKey, _acrylicTransparency); - - JsonUtils::GetBool(json, UseAcrylicKey, _useAcrylic); - - JsonUtils::GetBool(json, SuppressApplicationTitleKey, _suppressApplicationTitle); - - if (json.isMember(JsonKey(CloseOnExitKey))) - { - auto closeOnExit{ json[JsonKey(CloseOnExitKey)] }; - _closeOnExitMode = ParseCloseOnExitMode(closeOnExit); - } - - JsonUtils::GetWstring(json, PaddingKey, _padding); - - JsonUtils::GetOptionalString(json, ScrollbarStateKey, _scrollbarState); - - JsonUtils::GetOptionalString(json, StartingDirectoryKey, _startingDirectory); - - JsonUtils::GetOptionalString(json, IconKey, _icon); - - JsonUtils::GetOptionalString(json, BackgroundImageKey, _backgroundImage); - - JsonUtils::GetOptionalDouble(json, BackgroundImageOpacityKey, _backgroundImageOpacity); - - JsonUtils::GetOptionalValue(json, BackgroundImageStretchModeKey, _backgroundImageStretchMode, &Profile::_ConvertJsonToStretchMode); - - JsonUtils::GetOptionalValue(json, BackgroundImageAlignmentKey, _backgroundImageAlignment, &Profile::_ConvertJsonToAlignment); - - JsonUtils::GetOptionalValue(json, RetroTerminalEffectKey, _retroTerminalEffect, Profile::_ConvertJsonToBool); - - if (json.isMember(JsonKey(AntialiasingModeKey))) - { - auto antialiasingMode{ json[JsonKey(AntialiasingModeKey)] }; - _antialiasingMode = ParseTextAntialiasingMode(GetWstringFromJson(antialiasingMode)); - } + JsonUtils::GetValueForKey(json, FontWeightKey, _fontWeight); + JsonUtils::GetValueForKey(json, ConnectionTypeKey, _connectionType); + JsonUtils::GetValueForKey(json, CommandlineKey, _commandline); + JsonUtils::GetValueForKey(json, FontFaceKey, _fontFace); + JsonUtils::GetValueForKey(json, FontSizeKey, _fontSize); + JsonUtils::GetValueForKey(json, AcrylicTransparencyKey, _acrylicTransparency); + JsonUtils::GetValueForKey(json, UseAcrylicKey, _useAcrylic); + JsonUtils::GetValueForKey(json, SuppressApplicationTitleKey, _suppressApplicationTitle); + JsonUtils::GetValueForKey(json, CloseOnExitKey, _closeOnExitMode); + JsonUtils::GetValueForKey(json, PaddingKey, _padding); + JsonUtils::GetValueForKey(json, ScrollbarStateKey, _scrollbarState); + JsonUtils::GetValueForKey(json, StartingDirectoryKey, _startingDirectory); + JsonUtils::GetValueForKey(json, IconKey, _icon); + JsonUtils::GetValueForKey(json, BackgroundImageKey, _backgroundImage); + JsonUtils::GetValueForKey(json, BackgroundImageOpacityKey, _backgroundImageOpacity); + JsonUtils::GetValueForKey(json, BackgroundImageStretchModeKey, _backgroundImageStretchMode); + JsonUtils::GetValueForKey(json, BackgroundImageAlignmentKey, _backgroundImageAlignment); + JsonUtils::GetValueForKey(json, RetroTerminalEffectKey, _retroTerminalEffect); + JsonUtils::GetValueForKey(json, AntialiasingModeKey, _antialiasingMode); } void Profile::SetFontFace(std::wstring fontFace) noexcept @@ -770,249 +635,6 @@ std::wstring Profile::EvaluateStartingDirectory(const std::wstring& directory) } } -// Method Description: -// - Helper function for converting a user-specified font weight value to its corresponding enum -// Arguments: -// - The value from the settings.json file -// Return Value: -// - The corresponding value which maps to the string provided by the user -winrt::Windows::UI::Text::FontWeight Profile::_ParseFontWeight(const Json::Value& json) -{ - if (json.isUInt()) - { - winrt::Windows::UI::Text::FontWeight weight; - weight.Weight = static_cast(json.asUInt()); - - // We're only accepting variable values between 100 and 990 so we don't go too crazy. - if (weight.Weight >= 100 && weight.Weight <= 990) - { - return weight; - } - } - - if (json.isString()) - { - auto fontWeight = json.asString(); - if (fontWeight == FontWeightThin) - { - return winrt::Windows::UI::Text::FontWeights::Thin(); - } - else if (fontWeight == FontWeightExtraLight) - { - return winrt::Windows::UI::Text::FontWeights::ExtraLight(); - } - else if (fontWeight == FontWeightLight) - { - return winrt::Windows::UI::Text::FontWeights::Light(); - } - else if (fontWeight == FontWeightSemiLight) - { - return winrt::Windows::UI::Text::FontWeights::SemiLight(); - } - else if (fontWeight == FontWeightNormal) - { - return winrt::Windows::UI::Text::FontWeights::Normal(); - } - else if (fontWeight == FontWeightMedium) - { - return winrt::Windows::UI::Text::FontWeights::Medium(); - } - else if (fontWeight == FontWeightSemiBold) - { - return winrt::Windows::UI::Text::FontWeights::SemiBold(); - } - else if (fontWeight == FontWeightBold) - { - return winrt::Windows::UI::Text::FontWeights::Bold(); - } - else if (fontWeight == FontWeightExtraBold) - { - return winrt::Windows::UI::Text::FontWeights::ExtraBold(); - } - else if (fontWeight == FontWeightBlack) - { - return winrt::Windows::UI::Text::FontWeights::Black(); - } - else if (fontWeight == FontWeightExtraBlack) - { - return winrt::Windows::UI::Text::FontWeights::ExtraBlack(); - } - } - - return winrt::Windows::UI::Text::FontWeights::Normal(); -} - -// Method Description: -// - Helper function for converting a user-specified closeOnExit value to its corresponding enum -// Arguments: -// - The value from the settings.json file -// Return Value: -// - The corresponding enum value which maps to the string provided by the user -CloseOnExitMode Profile::ParseCloseOnExitMode(const Json::Value& json) -{ - if (json.isBool()) - { - return json.asBool() ? CloseOnExitMode::Graceful : CloseOnExitMode::Never; - } - - if (json.isString()) - { - auto closeOnExit = json.asString(); - if (closeOnExit == CloseOnExitAlways) - { - return CloseOnExitMode::Always; - } - else if (closeOnExit == CloseOnExitGraceful) - { - return CloseOnExitMode::Graceful; - } - else if (closeOnExit == CloseOnExitNever) - { - return CloseOnExitMode::Never; - } - } - - return CloseOnExitMode::Graceful; -} - -// Method Description: -// - Helper function for converting a user-specified scrollbar state to its corresponding enum -// Arguments: -// - The value from the settings.json file -// Return Value: -// - The corresponding enum value which maps to the string provided by the user -ScrollbarState Profile::ParseScrollbarState(const std::wstring& scrollbarState) -{ - if (scrollbarState == AlwaysVisible) - { - return ScrollbarState::Visible; - } - else if (scrollbarState == AlwaysHide) - { - return ScrollbarState::Hidden; - } - else - { - return ScrollbarState::Visible; - } -} - -// Method Description: -// - Helper function for converting a user-specified image stretch mode -// to the appropriate enum value -// Arguments: -// - The value from the settings.json file -// Return Value: -// - The corresponding enum value which maps to the string provided by the user -Media::Stretch Profile::ParseImageStretchMode(const std::string_view imageStretchMode) -{ - if (imageStretchMode == ImageStretchModeNone) - { - return Media::Stretch::None; - } - else if (imageStretchMode == ImageStretchModeFill) - { - return Media::Stretch::Fill; - } - else if (imageStretchMode == ImageStretchModeUniform) - { - return Media::Stretch::Uniform; - } - else // Fall through to default behavior - { - return Media::Stretch::UniformToFill; - } -} - -// Method Description: -// - Helper function for converting a user-specified image horizontal and vertical -// alignment to the appropriate enum values tuple -// Arguments: -// - The value from the settings.json file -// Return Value: -// - The corresponding enum values tuple which maps to the string provided by the user -std::tuple Profile::ParseImageAlignment(const std::string_view imageAlignment) -{ - if (imageAlignment == ImageAlignmentTopLeft) - { - return std::make_tuple(HorizontalAlignment::Left, - VerticalAlignment::Top); - } - else if (imageAlignment == ImageAlignmentBottomLeft) - { - return std::make_tuple(HorizontalAlignment::Left, - VerticalAlignment::Bottom); - } - else if (imageAlignment == ImageAlignmentLeft) - { - return std::make_tuple(HorizontalAlignment::Left, - VerticalAlignment::Center); - } - else if (imageAlignment == ImageAlignmentTopRight) - { - return std::make_tuple(HorizontalAlignment::Right, - VerticalAlignment::Top); - } - else if (imageAlignment == ImageAlignmentBottomRight) - { - return std::make_tuple(HorizontalAlignment::Right, - VerticalAlignment::Bottom); - } - else if (imageAlignment == ImageAlignmentRight) - { - return std::make_tuple(HorizontalAlignment::Right, - VerticalAlignment::Center); - } - else if (imageAlignment == ImageAlignmentTop) - { - return std::make_tuple(HorizontalAlignment::Center, - VerticalAlignment::Top); - } - else if (imageAlignment == ImageAlignmentBottom) - { - return std::make_tuple(HorizontalAlignment::Center, - VerticalAlignment::Bottom); - } - else // Fall through to default alignment - { - return std::make_tuple(HorizontalAlignment::Center, - VerticalAlignment::Center); - } -} - -// Method Description: -// - Helper function for converting a user-specified cursor style corresponding -// CursorStyle enum value -// Arguments: -// - cursorShapeString: The string value from the settings file to parse -// Return Value: -// - The corresponding enum value which maps to the string provided by the user -CursorStyle Profile::_ParseCursorShape(const std::wstring& cursorShapeString) -{ - if (cursorShapeString == CursorShapeVintage) - { - return CursorStyle::Vintage; - } - else if (cursorShapeString == CursorShapeBar) - { - return CursorStyle::Bar; - } - else if (cursorShapeString == CursorShapeUnderscore) - { - return CursorStyle::Underscore; - } - else if (cursorShapeString == CursorShapeFilledbox) - { - return CursorStyle::FilledBox; - } - else if (cursorShapeString == CursorShapeEmptybox) - { - return CursorStyle::EmptyBox; - } - // default behavior for invalid data - return CursorStyle::Bar; -} - // Method Description: // - If this profile never had a GUID set for it, generate a runtime GUID for // the profile. If a profile had their guid manually set to {0}, this method @@ -1078,17 +700,13 @@ GUID Profile::_GenerateGuidForProfile(const std::wstring& name, const std::optio // - The json's `guid`, or a guid synthesized for it. GUID Profile::GetGuidOrGenerateForJson(const Json::Value& json) noexcept { - std::optional guid{ std::nullopt }; - - JsonUtils::GetOptionalGuid(json, GuidKey, guid); - if (guid) + if (const auto guid{ JsonUtils::GetValueForKey>(json, GuidKey) }) { return guid.value(); } - const auto name = GetWstringFromJson(json[JsonKey(NameKey)]); - std::optional source{ std::nullopt }; - JsonUtils::GetOptionalString(json, SourceKey, source); + const auto name{ JsonUtils::GetValueForKey(json, NameKey) }; + const auto source{ JsonUtils::GetValueForKey>(json, SourceKey) }; return Profile::_GenerateGuidForProfile(name, source); } @@ -1097,28 +715,3 @@ void Profile::SetRetroTerminalEffect(bool value) noexcept { _retroTerminalEffect = value; } - -// Method Description: -// - Helper function for converting a user-specified antialiasing mode -// corresponding TextAntialiasingMode enum value -// Arguments: -// - antialiasingMode: The string value from the settings file to parse -// Return Value: -// - The corresponding enum value which maps to the string provided by the user -TextAntialiasingMode Profile::ParseTextAntialiasingMode(const std::wstring& antialiasingMode) -{ - if (antialiasingMode == AntialiasingModeCleartype) - { - return TextAntialiasingMode::Cleartype; - } - else if (antialiasingMode == AntialiasingModeAliased) - { - return TextAntialiasingMode::Aliased; - } - else if (antialiasingMode == AntialiasingModeGrayscale) - { - return TextAntialiasingMode::Grayscale; - } - // default behavior for invalid data - return TextAntialiasingMode::Grayscale; -} diff --git a/src/cascadia/TerminalApp/Profile.h b/src/cascadia/TerminalApp/Profile.h index bd48592157c..17edad98bb6 100644 --- a/src/cascadia/TerminalApp/Profile.h +++ b/src/cascadia/TerminalApp/Profile.h @@ -15,6 +15,7 @@ Author(s): --*/ #pragma once #include "ColorScheme.h" +#include "SettingsTypes.h" // fwdecl unittest classes namespace TerminalAppLocalTests @@ -35,14 +36,7 @@ constexpr GUID RUNTIME_GENERATED_PROFILE_NAMESPACE_GUID = { 0xf65ddb7e, 0x706b, namespace TerminalApp { class Profile; - - enum class CloseOnExitMode - { - Never = 0, - Graceful, - Always - }; -}; +} class TerminalApp::Profile final { @@ -107,24 +101,8 @@ class TerminalApp::Profile final private: static std::wstring EvaluateStartingDirectory(const std::wstring& directory); - static winrt::Microsoft::Terminal::Settings::ScrollbarState ParseScrollbarState(const std::wstring& scrollbarState); - static winrt::Windows::UI::Xaml::Media::Stretch ParseImageStretchMode(const std::string_view imageStretchMode); - static winrt::Windows::UI::Xaml::Media::Stretch _ConvertJsonToStretchMode(const Json::Value& json); - static std::tuple ParseImageAlignment(const std::string_view imageAlignment); - static std::tuple _ConvertJsonToAlignment(const Json::Value& json); - - static winrt::Windows::UI::Text::FontWeight _ParseFontWeight(const Json::Value& json); - - static CloseOnExitMode ParseCloseOnExitMode(const Json::Value& json); - - static winrt::Microsoft::Terminal::Settings::CursorStyle _ParseCursorShape(const std::wstring& cursorShapeString); - - static winrt::Microsoft::Terminal::Settings::TextAntialiasingMode ParseTextAntialiasingMode(const std::wstring& antialiasingMode); - static GUID _GenerateGuidForProfile(const std::wstring& name, const std::optional& source) noexcept; - static bool _ConvertJsonToBool(const Json::Value& json); - std::optional _guid{ std::nullopt }; std::optional _source{ std::nullopt }; std::wstring _name; @@ -159,7 +137,7 @@ class TerminalApp::Profile final std::optional _backgroundImageStretchMode; std::optional> _backgroundImageAlignment; - std::optional _scrollbarState; + std::optional<::winrt::Microsoft::Terminal::Settings::ScrollbarState> _scrollbarState; CloseOnExitMode _closeOnExitMode; std::wstring _padding; diff --git a/src/cascadia/TerminalApp/SettingsTypes.h b/src/cascadia/TerminalApp/SettingsTypes.h new file mode 100644 index 00000000000..66903ab41a4 --- /dev/null +++ b/src/cascadia/TerminalApp/SettingsTypes.h @@ -0,0 +1,28 @@ +/*++ +Copyright (c) Microsoft Corporation +Licensed under the MIT license. + +Module Name: +- SettingsTypes.h + +Abstract: +- Types used in the settings model (non-exported) +--*/ + +#pragma once + +namespace TerminalApp +{ + enum class CloseOnExitMode + { + Never = 0, + Graceful, + Always + }; + + struct LaunchPosition + { + std::optional x; + std::optional y; + }; +}; diff --git a/src/cascadia/TerminalApp/TerminalSettingsSerializationHelpers.h b/src/cascadia/TerminalApp/TerminalSettingsSerializationHelpers.h new file mode 100644 index 00000000000..40de89d2258 --- /dev/null +++ b/src/cascadia/TerminalApp/TerminalSettingsSerializationHelpers.h @@ -0,0 +1,272 @@ +/*++ +Copyright (c) Microsoft Corporation +Licensed under the MIT license. + +Module Name: +- TerminalSettingsSerializationHelpers.h + +Abstract: +- Specializations of the JsonUtils helpers for things that might end up in a + settings document. + +--*/ + +#pragma once + +#include "pch.h" + +#include "JsonUtils.h" +#include "SettingsTypes.h" + +#include +#include + +JSON_ENUM_MAPPER(::winrt::Microsoft::Terminal::Settings::CursorStyle) +{ + static constexpr std::array mappings = { + pair_type{ "bar", ValueType::Bar }, + pair_type{ "vintage", ValueType::Vintage }, + pair_type{ "underscore", ValueType::Underscore }, + pair_type{ "filledBox", ValueType::FilledBox }, + pair_type{ "emptyBox", ValueType::EmptyBox } + }; +}; + +JSON_ENUM_MAPPER(::winrt::Windows::UI::Xaml::Media::Stretch) +{ + static constexpr std::array mappings = { + pair_type{ "uniformToFill", ValueType::UniformToFill }, + pair_type{ "none", ValueType::None }, + pair_type{ "fill", ValueType::Fill }, + pair_type{ "uniform", ValueType::Uniform } + }; +}; + +JSON_ENUM_MAPPER(::winrt::Microsoft::Terminal::Settings::ScrollbarState) +{ + static constexpr std::array mappings = { + pair_type{ "visible", ValueType::Visible }, + pair_type{ "hidden", ValueType::Hidden } + }; +}; + +JSON_ENUM_MAPPER(std::tuple<::winrt::Windows::UI::Xaml::HorizontalAlignment, ::winrt::Windows::UI::Xaml::VerticalAlignment>) +{ + // reduce repetition + using HA = ::winrt::Windows::UI::Xaml::HorizontalAlignment; + using VA = ::winrt::Windows::UI::Xaml::VerticalAlignment; + static constexpr std::array mappings = { + pair_type{ "center", std::make_tuple(HA::Center, VA::Center) }, + pair_type{ "topLeft", std::make_tuple(HA::Left, VA::Top) }, + pair_type{ "bottomLeft", std::make_tuple(HA::Left, VA::Bottom) }, + pair_type{ "left", std::make_tuple(HA::Left, VA::Center) }, + pair_type{ "topRight", std::make_tuple(HA::Right, VA::Top) }, + pair_type{ "bottomRight", std::make_tuple(HA::Right, VA::Bottom) }, + pair_type{ "right", std::make_tuple(HA::Right, VA::Center) }, + pair_type{ "top", std::make_tuple(HA::Center, VA::Top) }, + pair_type{ "bottom", std::make_tuple(HA::Center, VA::Bottom) } + }; +}; + +JSON_ENUM_MAPPER(::winrt::Microsoft::Terminal::Settings::TextAntialiasingMode) +{ + static constexpr std::array mappings = { + pair_type{ "grayscale", ValueType::Grayscale }, + pair_type{ "cleartype", ValueType::Cleartype }, + pair_type{ "aliased", ValueType::Aliased } + }; +}; + +// Type Description: +// - Helper for converting a user-specified closeOnExit value to its corresponding enum +JSON_ENUM_MAPPER(::TerminalApp::CloseOnExitMode) +{ + JSON_MAPPINGS(3) = { + pair_type{ "always", ValueType::Always }, + pair_type{ "graceful", ValueType::Graceful }, + pair_type{ "never", ValueType::Never }, + }; + + // Override mapping parser to add boolean parsing + CloseOnExitMode FromJson(const Json::Value& json) + { + if (json.isBool()) + { + return json.asBool() ? ValueType::Graceful : ValueType::Never; + } + return EnumMapper::FromJson(json); + } + + bool CanConvert(const Json::Value& json) + { + return EnumMapper::CanConvert(json) || json.isBool(); + } +}; + +// This specialization isn't using JSON_ENUM_MAPPER because we need to have a different +// value type (unsinged int) and return type (FontWeight struct). JSON_ENUM_MAPPER +// expects that the value type _is_ the return type. +template<> +struct ::TerminalApp::JsonUtils::ConversionTrait<::winrt::Windows::UI::Text::FontWeight> : + public ::TerminalApp::JsonUtils::EnumMapper< + unsigned int, + ::TerminalApp::JsonUtils::ConversionTrait<::winrt::Windows::UI::Text::FontWeight>> +{ + // The original parser used the font weight getters Bold(), Normal(), etc. + // They were both cumbersome and *not constant expressions* + JSON_MAPPINGS(11) = { + pair_type{ "thin", 100u }, + pair_type{ "extra-light", 200u }, + pair_type{ "light", 300u }, + pair_type{ "semi-light", 350u }, + pair_type{ "normal", 400u }, + pair_type{ "medium", 500u }, + pair_type{ "semi-bold", 600u }, + pair_type{ "bold", 700u }, + pair_type{ "extra-bold", 800u }, + pair_type{ "black", 900u }, + pair_type{ "extra-black", 950u }, + }; + + // Override mapping parser to add boolean parsing + auto FromJson(const Json::Value& json) + { + unsigned int value{ 400 }; + if (json.isUInt()) + { + value = json.asUInt(); + } + else + { + value = BaseEnumMapper::FromJson(json); + } + + ::winrt::Windows::UI::Text::FontWeight weight{ + static_cast(std::clamp(value, 100u, 990u)) + }; + return weight; + } + + bool CanConvert(const Json::Value& json) + { + return BaseEnumMapper::CanConvert(json) || json.isUInt(); + } +}; + +JSON_ENUM_MAPPER(::winrt::Windows::UI::Xaml::ElementTheme) +{ + JSON_MAPPINGS(3) = { + pair_type{ "system", ValueType::Default }, + pair_type{ "light", ValueType::Light }, + pair_type{ "dark", ValueType::Dark }, + }; +}; + +JSON_ENUM_MAPPER(::winrt::TerminalApp::LaunchMode) +{ + JSON_MAPPINGS(3) = { + pair_type{ "default", ValueType::DefaultMode }, + pair_type{ "maximized", ValueType::MaximizedMode }, + pair_type{ "fullscreen", ValueType::FullscreenMode }, + }; +}; + +JSON_ENUM_MAPPER(::winrt::Microsoft::UI::Xaml::Controls::TabViewWidthMode) +{ + JSON_MAPPINGS(3) = { + pair_type{ "equal", ValueType::Equal }, + pair_type{ "titleLength", ValueType::SizeToContent }, + pair_type{ "compact", ValueType::Compact }, + }; +}; + +// Type Description: +// - Helper for converting the initial position string into +// 2 coordinate values. We allow users to only provide one coordinate, +// thus, we use comma as the separator: +// (100, 100): standard input string +// (, 100), (100, ): if a value is missing, we set this value as a default +// (,): both x and y are set to default +// (abc, 100): if a value is not valid, we treat it as default +// (100, 100, 100): we only read the first two values, this is equivalent to (100, 100) +template<> +struct ::TerminalApp::JsonUtils::ConversionTrait<::TerminalApp::LaunchPosition> +{ + ::TerminalApp::LaunchPosition FromJson(const Json::Value& json) + { + ::TerminalApp::LaunchPosition ret; + std::string initialPosition{ json.asString() }; + static constexpr char singleCharDelim = ','; + std::stringstream tokenStream(initialPosition); + std::string token; + uint8_t initialPosIndex = 0; + + // Get initial position values till we run out of delimiter separated values in the stream + // or we hit max number of allowable values (= 2) + // Non-numeral values or empty string will be caught as exception and we do not assign them + for (; std::getline(tokenStream, token, singleCharDelim) && (initialPosIndex < 2); initialPosIndex++) + { + try + { + int32_t position = std::stoi(token); + if (initialPosIndex == 0) + { + ret.x.emplace(position); + } + + if (initialPosIndex == 1) + { + ret.y.emplace(position); + } + } + catch (...) + { + // Do nothing + } + } + return ret; + } + + bool CanConvert(const Json::Value& json) + { + return json.isString(); + } +}; + +// Possible Direction values +JSON_ENUM_MAPPER(::winrt::TerminalApp::Direction) +{ + JSON_MAPPINGS(4) = { + pair_type{ "left", ValueType::Left }, + pair_type{ "right", ValueType::Right }, + pair_type{ "up", ValueType::Up }, + pair_type{ "down", ValueType::Down }, + }; +}; + +// Possible SplitState values +JSON_ENUM_MAPPER(::winrt::TerminalApp::SplitState) +{ + JSON_MAPPINGS(3) = { + pair_type{ "vertical", ValueType::Vertical }, + pair_type{ "horizontal", ValueType::Horizontal }, + pair_type{ "auto", ValueType::Automatic }, + }; +}; + +// Possible SplitType values +JSON_ENUM_MAPPER(::winrt::TerminalApp::SplitType) +{ + JSON_MAPPINGS(1) = { + pair_type{ "duplicate", ValueType::Duplicate }, + }; +}; + +JSON_ENUM_MAPPER(::winrt::TerminalApp::SettingsTarget) +{ + JSON_MAPPINGS(3) = { + pair_type{ "settingsFile", ValueType::SettingsFile }, + pair_type{ "defaultsFile", ValueType::DefaultsFile }, + pair_type{ "allFiles", ValueType::AllFiles }, + }; +}; diff --git a/src/cascadia/TerminalApp/Utils.cpp b/src/cascadia/TerminalApp/Utils.cpp deleted file mode 100644 index 01fa28dfdd1..00000000000 --- a/src/cascadia/TerminalApp/Utils.cpp +++ /dev/null @@ -1,18 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT license. - -#include "pch.h" -#include "Utils.h" - -// Method Description: -// - Constructs a wstring from a given Json::Value object. Reads the object as -// a std::string using asString, then builds an hstring from that std::string, -// then converts that hstring into a std::wstring. -// Arguments: -// - json: the Json::Value to parse as a string -// Return Value: -// - the wstring equivalent of the value in json -std::wstring GetWstringFromJson(const Json::Value& json) -{ - return winrt::to_hstring(json.asString()).c_str(); -} diff --git a/src/cascadia/TerminalApp/Utils.h b/src/cascadia/TerminalApp/Utils.h index bba97694282..cb23bac450d 100644 --- a/src/cascadia/TerminalApp/Utils.h +++ b/src/cascadia/TerminalApp/Utils.h @@ -13,8 +13,6 @@ Author(s): --*/ #pragma once -std::wstring GetWstringFromJson(const Json::Value& json); - // Method Description: // - Create a std::string from a string_view. We do this because we can't look // up a key in a Json::Value with a string_view directly, so instead we'll use diff --git a/src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj b/src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj index 6c9dc3323b7..0fb6b823c4c 100644 --- a/src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj +++ b/src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj @@ -109,6 +109,7 @@ + @@ -178,8 +179,6 @@ - - diff --git a/src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj.filters b/src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj.filters index 5f856a6d4a8..d716860a4af 100644 --- a/src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj.filters +++ b/src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj.filters @@ -8,7 +8,6 @@ - @@ -50,9 +49,6 @@ json - - json - tab @@ -92,6 +88,9 @@ settings + + settings + settings @@ -199,4 +198,4 @@ app - \ No newline at end of file + diff --git a/src/cascadia/ut_app/JsonTests.cpp b/src/cascadia/ut_app/JsonTests.cpp index 9fd573134f7..1afbeaeddff 100644 --- a/src/cascadia/ut_app/JsonTests.cpp +++ b/src/cascadia/ut_app/JsonTests.cpp @@ -28,8 +28,6 @@ namespace TerminalAppUnitTests TEST_METHOD(ParseSimpleColorScheme); TEST_METHOD(ProfileGeneratesGuid); - TEST_METHOD(TestWrongValueType); - TEST_CLASS_SETUP(ClassSetup) { InitializeJsonReader(); @@ -169,58 +167,4 @@ namespace TerminalAppUnitTests VERIFY_ARE_EQUAL(profile3.GetGuid(), nullGuid); VERIFY_ARE_EQUAL(profile4.GetGuid(), cmdGuid); } - - void JsonTests::TestWrongValueType() - { - // This json blob has a whole bunch of settings with the wrong value - // types - strings for int values, ints for strings, floats for ints, - // etc. When we encounter data that's the wrong data type, we should - // gracefully ignore it, as opposed to throwing an exception, causing us - // to fail to load the settings at all. - - const std::string settings0String{ R"( - { - "defaultProfile" : "{00000000-1111-0000-0000-000000000000}", - "profiles": [ - { - "guid" : "{00000000-1111-0000-0000-000000000000}", - "acrylicOpacity" : "0.5", - "closeOnExit" : "true", - "fontSize" : "10", - "historySize" : 1234.5678, - "padding" : 20, - "snapOnInput" : "false", - "icon" : 4, - "backgroundImageOpacity": false, - "useAcrylic" : 14 - } - ] - })" }; - - const auto settings0Json = VerifyParseSucceeded(settings0String); - - CascadiaSettings settings; - - settings._ParseJsonString(settings0String, false); - // We should not throw an exception trying to parse the settings here. - settings.LayerJson(settings._userSettings); - - VERIFY_ARE_EQUAL(1u, settings._profiles.size()); - auto& profile = settings._profiles.at(0); - Profile defaults{}; - - VERIFY_ARE_EQUAL(defaults._acrylicTransparency, profile._acrylicTransparency); - VERIFY_ARE_EQUAL(defaults._closeOnExitMode, profile._closeOnExitMode); - VERIFY_ARE_EQUAL(defaults._fontSize, profile._fontSize); - VERIFY_ARE_EQUAL(defaults._historySize, profile._historySize); - // A 20 as an int can still be treated as a json string - VERIFY_ARE_EQUAL(L"20", profile._padding); - VERIFY_ARE_EQUAL(defaults._snapOnInput, profile._snapOnInput); - // 4 is a valid string value - VERIFY_ARE_EQUAL(L"4", profile._icon); - // false is not a valid optional - VERIFY_IS_FALSE(profile._backgroundImageOpacity.has_value()); - VERIFY_ARE_EQUAL(defaults._useAcrylic, profile._useAcrylic); - } - } diff --git a/src/cascadia/ut_app/JsonUtilsTests.cpp b/src/cascadia/ut_app/JsonUtilsTests.cpp index 1016fb282a1..f3f3c7c5b2c 100644 --- a/src/cascadia/ut_app/JsonUtilsTests.cpp +++ b/src/cascadia/ut_app/JsonUtilsTests.cpp @@ -3,7 +3,7 @@ #include "precomp.h" -#include "../TerminalApp/JsonUtilsNew.h" +#include "../TerminalApp/JsonUtils.h" using namespace Microsoft::Console; using namespace WEX::Logging; From 1f8264d86b39a83f8cae26be0f7a006d7ebf16a9 Mon Sep 17 00:00:00 2001 From: Dan Thompson Date: Fri, 17 Jul 2020 08:50:23 -0700 Subject: [PATCH 10/33] Tweaks: normalize TextAttribute method names (adjective form) (#6951) ## Summary of the Pull Request Text can have various attributes, such as "bold", "italic", "underlined", etc. The TextAttribute class embodies this. It has methods to set/query these attributes. This change tweaks a few of the method names to make them match. I.e. for an imaginary text property "Foo", we should have methods along the lines of: ``` IsFoo SetFoo(bool isFoo) ``` And variations should match: we should have "Foo" and "OverFoo", not "Fooey" and "OverFoo". I chose to standardize on the adjective form, since that's what we are closest to already. The attributes I attacked here are: SetItalic**s** --> SetItalic SetUnderline --> SetUnderline**d** SetOverline --> SetOverline**d** ("italic" is an adjective; "italics" is a plural noun, representing letters or words in an italic typeface) And I also added methods for "DoublyUnderlined" for good measure. I stopped short of renaming the GraphicsOptions enum values to match, too; but I'd be willing to do that in a follow-up change if people wanted it. ## Validation Steps Performed It builds, and tests still pass. --- src/buffer/out/TextAttribute.cpp | 6 +++--- src/buffer/out/TextAttribute.hpp | 11 ++++++----- src/buffer/out/textBuffer.cpp | 2 +- src/buffer/out/textBuffer.hpp | 2 +- .../TerminalCore/TerminalDispatchGraphics.cpp | 12 ++++++------ src/host/ut_host/ScreenBufferTests.cpp | 18 +++++++++--------- src/host/ut_host/VtRendererTests.cpp | 10 +++++----- src/renderer/vt/VtSequences.cpp | 6 +++--- src/renderer/vt/Xterm256Engine.cpp | 12 ++++++------ src/renderer/vt/XtermEngine.cpp | 4 ++-- src/renderer/vt/vtrenderer.hpp | 6 +++--- src/terminal/adapter/adaptDispatchGraphics.cpp | 12 ++++++------ .../adapter/ut_adapter/adapterTest.cpp | 3 +-- 13 files changed, 52 insertions(+), 52 deletions(-) diff --git a/src/buffer/out/TextAttribute.cpp b/src/buffer/out/TextAttribute.cpp index b58975f9a85..371fedb2b64 100644 --- a/src/buffer/out/TextAttribute.cpp +++ b/src/buffer/out/TextAttribute.cpp @@ -270,7 +270,7 @@ void TextAttribute::SetFaint(bool isFaint) noexcept WI_UpdateFlag(_extendedAttrs, ExtendedAttributes::Faint, isFaint); } -void TextAttribute::SetItalics(bool isItalic) noexcept +void TextAttribute::SetItalic(bool isItalic) noexcept { WI_UpdateFlag(_extendedAttrs, ExtendedAttributes::Italics, isItalic); } @@ -290,13 +290,13 @@ void TextAttribute::SetCrossedOut(bool isCrossedOut) noexcept WI_UpdateFlag(_extendedAttrs, ExtendedAttributes::CrossedOut, isCrossedOut); } -void TextAttribute::SetUnderline(bool isUnderlined) noexcept +void TextAttribute::SetUnderlined(bool isUnderlined) noexcept { // TODO:GH#2915 Treat underline separately from LVB_UNDERSCORE WI_UpdateFlag(_wAttrLegacy, COMMON_LVB_UNDERSCORE, isUnderlined); } -void TextAttribute::SetOverline(bool isOverlined) noexcept +void TextAttribute::SetOverlined(bool isOverlined) noexcept { WI_UpdateFlag(_wAttrLegacy, COMMON_LVB_GRID_HORIZONTAL, isOverlined); } diff --git a/src/buffer/out/TextAttribute.hpp b/src/buffer/out/TextAttribute.hpp index cccd9aaff7c..7cec03f75e6 100644 --- a/src/buffer/out/TextAttribute.hpp +++ b/src/buffer/out/TextAttribute.hpp @@ -100,12 +100,12 @@ class TextAttribute final void SetBold(bool isBold) noexcept; void SetFaint(bool isFaint) noexcept; - void SetItalics(bool isItalic) noexcept; + void SetItalic(bool isItalic) noexcept; void SetBlinking(bool isBlinking) noexcept; void SetInvisible(bool isInvisible) noexcept; void SetCrossedOut(bool isCrossedOut) noexcept; - void SetUnderline(bool isUnderlined) noexcept; - void SetOverline(bool isOverlined) noexcept; + void SetUnderlined(bool isUnderlined) noexcept; + void SetOverlined(bool isOverlined) noexcept; void SetReverseVideo(bool isReversed) noexcept; ExtendedAttributes GetExtendedAttributes() const noexcept; @@ -218,11 +218,12 @@ namespace WEX static WEX::Common::NoThrowString ToString(const TextAttribute& attr) { return WEX::Common::NoThrowString().Format( - L"{FG:%s,BG:%s,bold:%d,wLegacy:(0x%04x)}", + L"{FG:%s,BG:%s,bold:%d,wLegacy:(0x%04x),ext:(0x%02x)}", VerifyOutputTraits::ToString(attr._foreground).GetBuffer(), VerifyOutputTraits::ToString(attr._background).GetBuffer(), attr.IsBold(), - attr._wAttrLegacy); + attr._wAttrLegacy, + static_cast(attr._extendedAttrs)); } }; } diff --git a/src/buffer/out/textBuffer.cpp b/src/buffer/out/textBuffer.cpp index faee76caf0e..6ecb989f2f0 100644 --- a/src/buffer/out/textBuffer.cpp +++ b/src/buffer/out/textBuffer.cpp @@ -787,7 +787,7 @@ const Cursor& TextBuffer::GetCursor() const noexcept return _currentAttributes; } -void TextBuffer::SetCurrentAttributes(const TextAttribute currentAttributes) noexcept +void TextBuffer::SetCurrentAttributes(const TextAttribute& currentAttributes) noexcept { _currentAttributes = currentAttributes; } diff --git a/src/buffer/out/textBuffer.hpp b/src/buffer/out/textBuffer.hpp index 269bb6911e6..9ed2ce8b1af 100644 --- a/src/buffer/out/textBuffer.hpp +++ b/src/buffer/out/textBuffer.hpp @@ -118,7 +118,7 @@ class TextBuffer final [[nodiscard]] TextAttribute GetCurrentAttributes() const noexcept; - void SetCurrentAttributes(const TextAttribute currentAttributes) noexcept; + void SetCurrentAttributes(const TextAttribute& currentAttributes) noexcept; void Reset(); diff --git a/src/cascadia/TerminalCore/TerminalDispatchGraphics.cpp b/src/cascadia/TerminalCore/TerminalDispatchGraphics.cpp index b03cae1c7b8..f8ff0d129da 100644 --- a/src/cascadia/TerminalCore/TerminalDispatchGraphics.cpp +++ b/src/cascadia/TerminalCore/TerminalDispatchGraphics.cpp @@ -126,10 +126,10 @@ bool TerminalDispatch::SetGraphicsRendition(const gsl::span Date: Fri, 17 Jul 2020 10:11:45 -0700 Subject: [PATCH 11/33] Set memory order on slow atomics (#6920) By default, the memory order on atomics is `seq_cst`. This is a relatively expensive ordering and it shows in situations where we're rapidly signaling a consumer to pick up something from a producer. I've instead attempted to switch these to `release` (producer) and `acquire` (consumer) to improve the performance of these signals. ## Validation Steps Performed - Run `time cat big.txt` and `time cat ls.txt` under VS Performance Profiler. ## PR Checklist * [x] Closes perf itch * [x] I work here * [x] Manual test * [x] Documentation irrelevant. * [x] Schema irrelevant. * [x] Am core contributor. --- .github/actions/spell-check/patterns/patterns.txt | 1 + src/cascadia/TerminalControl/ThrottledFunc.cpp | 4 ++-- src/renderer/base/thread.cpp | 12 ++++++------ 3 files changed, 9 insertions(+), 8 deletions(-) diff --git a/.github/actions/spell-check/patterns/patterns.txt b/.github/actions/spell-check/patterns/patterns.txt index 413709e1202..f8c3d65534a 100644 --- a/.github/actions/spell-check/patterns/patterns.txt +++ b/.github/actions/spell-check/patterns/patterns.txt @@ -19,3 +19,4 @@ TestUtils::VerifyExpectedString\(tb, L"[^"]+" Base64::s_(?:En|De)code\(L"[^"]+" VERIFY_ARE_EQUAL\(L"[^"]+" L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\+/" +std::memory_order_[\w]+ diff --git a/src/cascadia/TerminalControl/ThrottledFunc.cpp b/src/cascadia/TerminalControl/ThrottledFunc.cpp index 41c60b7b2bc..e72d86297e6 100644 --- a/src/cascadia/TerminalControl/ThrottledFunc.cpp +++ b/src/cascadia/TerminalControl/ThrottledFunc.cpp @@ -29,7 +29,7 @@ ThrottledFunc<>::ThrottledFunc(ThrottledFunc::Func func, TimeSpan delay, CoreDis // - void ThrottledFunc<>::Run() { - if (_isRunPending.test_and_set()) + if (_isRunPending.test_and_set(std::memory_order_acquire)) { // already pending return; @@ -44,7 +44,7 @@ void ThrottledFunc<>::Run() if (auto self{ weakThis.lock() }) { timer.Stop(); - self->_isRunPending.clear(); + self->_isRunPending.clear(std::memory_order_release); self->_func(); } }); diff --git a/src/renderer/base/thread.cpp b/src/renderer/base/thread.cpp index c4d4bc36c7d..65fedba6cfb 100644 --- a/src/renderer/base/thread.cpp +++ b/src/renderer/base/thread.cpp @@ -162,17 +162,17 @@ DWORD WINAPI RenderThread::_ThreadProc() { WaitForSingleObject(_hPaintEnabledEvent, INFINITE); - if (!_fNextFrameRequested.exchange(false)) + if (!_fNextFrameRequested.exchange(false, std::memory_order_acq_rel)) { // <-- // If `NotifyPaint` is called at this point, then it will not // set the event because `_fWaiting` is not `true` yet so we have // to check again below. - _fWaiting.store(true); + _fWaiting.store(true, std::memory_order_release); // check again now (see comment above) - if (!_fNextFrameRequested.exchange(false)) + if (!_fNextFrameRequested.exchange(false, std::memory_order_acq_rel)) { // Wait until a next frame is requested. WaitForSingleObject(_hEvent, INFINITE); @@ -193,7 +193,7 @@ DWORD WINAPI RenderThread::_ThreadProc() // expensive operation, we should reset the event to not render // again if nothing changed. - _fWaiting.store(false); + _fWaiting.store(false, std::memory_order_release); // see comment above ResetEvent(_hEvent); @@ -218,13 +218,13 @@ DWORD WINAPI RenderThread::_ThreadProc() void RenderThread::NotifyPaint() { - if (_fWaiting.load()) + if (_fWaiting.load(std::memory_order_acquire)) { SetEvent(_hEvent); } else { - _fNextFrameRequested.store(true); + _fNextFrameRequested.store(true, std::memory_order_release); } } From 4351f32f5de74992f8aee94cdf894fbaede2c4b3 Mon Sep 17 00:00:00 2001 From: Michael Niksa Date: Fri, 17 Jul 2020 10:53:01 -0700 Subject: [PATCH 12/33] Commit attr runs less frequently by accumulating length of color run (#6919) The act of calling `InsertAttrRuns` is relatively slow. Instead of calling it a bunch of times to meddle with colors one cell at a time, we'll accumulate a length of color and call it to make it act all at once. This is great for when one color full line is getting replaced with another color full line OR when a line is being replaced with the same color all at once. There's significantly fewer checks to be made inside `InsertAttrRuns` if we can help it out by accumulating the length of each color before asking it to stitch it into the storage. Validation ---------- - Run `time cat big.txt` and `time cat ls.txt` under VS Performance Profiler. --- src/buffer/out/Row.cpp | 122 ++++++++++++++++++++++++++--------------- 1 file changed, 77 insertions(+), 45 deletions(-) diff --git a/src/buffer/out/Row.cpp b/src/buffer/out/Row.cpp index 6c82b718fb9..2718aa14229 100644 --- a/src/buffer/out/Row.cpp +++ b/src/buffer/out/Row.cpp @@ -160,66 +160,98 @@ OutputCellIterator ROW::WriteCells(OutputCellIterator it, const size_t index, co // If we're given a right-side column limit, use it. Otherwise, the write limit is the final column index available in the char row. const auto finalColumnInRow = limitRight.value_or(_charRow.size() - 1); - while (it && currentIndex <= finalColumnInRow) + if (it) { - // Fill the color if the behavior isn't set to keeping the current color. - if (it->TextAttrBehavior() != TextAttributeBehavior::Current) - { - const TextAttributeRun attrRun{ 1, it->TextAttr() }; - LOG_IF_FAILED(_attrRow.InsertAttrRuns({ &attrRun, 1 }, - currentIndex, - currentIndex, - _charRow.size())); - } + // Accumulate usages of the same color so we can spend less time in InsertAttrRuns rewriting it. + auto currentColor = it->TextAttr(); + size_t colorUses = 0; + size_t colorStarts = index; - // Fill the text if the behavior isn't set to saying there's only a color stored in this iterator. - if (it->TextAttrBehavior() != TextAttributeBehavior::StoredOnly) + while (it && currentIndex <= finalColumnInRow) { - const bool fillingLastColumn = currentIndex == finalColumnInRow; - - // TODO: MSFT: 19452170 - We need to ensure when writing any trailing byte that the one to the left - // is a matching leading byte. Likewise, if we're writing a leading byte, we need to make sure we still have space in this loop - // for the trailing byte coming up before writing it. - - // If we're trying to fill the first cell with a trailing byte, pad it out instead by clearing it. - // Don't increment iterator. We'll advance the index and try again with this value on the next round through the loop. - if (currentIndex == 0 && it->DbcsAttr().IsTrailing()) + // Fill the color if the behavior isn't set to keeping the current color. + if (it->TextAttrBehavior() != TextAttributeBehavior::Current) { - _charRow.ClearCell(currentIndex); + // If the color of this cell is the same as the run we're currently on, + // just increment the counter. + if (currentColor == it->TextAttr()) + { + ++colorUses; + } + else + { + // Otherwise, commit this color into the run and save off the new one. + const TextAttributeRun run{ colorUses, currentColor }; + // Now commit the new color runs into the attr row. + LOG_IF_FAILED(_attrRow.InsertAttrRuns({ &run, 1 }, + colorStarts, + currentIndex - 1, + _charRow.size())); + currentColor = it->TextAttr(); + colorUses = 1; + colorStarts = currentIndex; + } } - // If we're trying to fill the last cell with a leading byte, pad it out instead by clearing it. - // Don't increment iterator. We'll exit because we couldn't write a lead at the end of a line. - else if (fillingLastColumn && it->DbcsAttr().IsLeading()) + + // Fill the text if the behavior isn't set to saying there's only a color stored in this iterator. + if (it->TextAttrBehavior() != TextAttributeBehavior::StoredOnly) { - _charRow.ClearCell(currentIndex); - _charRow.SetDoubleBytePadded(true); + const bool fillingLastColumn = currentIndex == finalColumnInRow; + + // TODO: MSFT: 19452170 - We need to ensure when writing any trailing byte that the one to the left + // is a matching leading byte. Likewise, if we're writing a leading byte, we need to make sure we still have space in this loop + // for the trailing byte coming up before writing it. + + // If we're trying to fill the first cell with a trailing byte, pad it out instead by clearing it. + // Don't increment iterator. We'll advance the index and try again with this value on the next round through the loop. + if (currentIndex == 0 && it->DbcsAttr().IsTrailing()) + { + _charRow.ClearCell(currentIndex); + } + // If we're trying to fill the last cell with a leading byte, pad it out instead by clearing it. + // Don't increment iterator. We'll exit because we couldn't write a lead at the end of a line. + else if (fillingLastColumn && it->DbcsAttr().IsLeading()) + { + _charRow.ClearCell(currentIndex); + _charRow.SetDoubleBytePadded(true); + } + // Otherwise, copy the data given and increment the iterator. + else + { + _charRow.DbcsAttrAt(currentIndex) = it->DbcsAttr(); + _charRow.GlyphAt(currentIndex) = it->Chars(); + ++it; + } + + // If we're asked to (un)set the wrap status and we just filled the last column with some text... + // NOTE: + // - wrap = std::nullopt --> don't change the wrap value + // - wrap = true --> we're filling cells as a steam, consider this a wrap + // - wrap = false --> we're filling cells as a block, unwrap + if (wrap.has_value() && fillingLastColumn) + { + // set wrap status on the row to parameter's value. + _charRow.SetWrapForced(wrap.value()); + } } - // Otherwise, copy the data given and increment the iterator. else { - _charRow.DbcsAttrAt(currentIndex) = it->DbcsAttr(); - _charRow.GlyphAt(currentIndex) = it->Chars(); ++it; } - // If we're asked to (un)set the wrap status and we just filled the last column with some text... - // NOTE: - // - wrap = std::nullopt --> don't change the wrap value - // - wrap = true --> we're filling cells as a steam, consider this a wrap - // - wrap = false --> we're filling cells as a block, unwrap - if (wrap.has_value() && fillingLastColumn) - { - // set wrap status on the row to parameter's value. - _charRow.SetWrapForced(wrap.value()); - } + // Move to the next cell for the next time through the loop. + ++currentIndex; } - else + + // Now commit the final color into the attr row + if (colorUses) { - ++it; + const TextAttributeRun run{ colorUses, currentColor }; + LOG_IF_FAILED(_attrRow.InsertAttrRuns({ &run, 1 }, + colorStarts, + currentIndex - 1, + _charRow.size())); } - - // Move to the next cell for the next time through the loop. - ++currentIndex; } return it; From 0c3841a8b007566a1ba431374b3886b945e0d5b1 Mon Sep 17 00:00:00 2001 From: jtippet Date: Fri, 17 Jul 2020 12:27:32 -0700 Subject: [PATCH 13/33] Add gutter to Command Palette to avoid overlapping with scrollbar (#6965) The command palette has some content that can overlap with its scrollbar. This PR adds a 16px gutter for the scrollbar, as recommended [here](https://docs.microsoft.com/en-us/windows/uwp/design/controls-and-patterns/scroll-controls#:~:text=leave%2016px%20of%20padding%20on%20the%20edge%20of%20the%20viewport). ## Detailed Description of the Pull Request / Additional comments You can repro the overlap in the default configuration by grabbing the scrollbar with the mouse pointer. But there's an accessibility option that makes this more obvious: Settings > Display > Automatically hide scroll bars. With that option enabled, the text is _always_ overlapping. The gutter does look slightly larger than it needs to be when the scrollbar is thin or completely hidden. Dynamic reflow may help, but unfortunately, I don't know enough XAML to wire that up. MUX has a promising visual state named `ScrollBarsSeparatorExpanded`, so the scientists suggest we _could_, while the designers are still pondering whether we _should_. ## Validation Steps Performed Old appearance: ![image](https://user-images.githubusercontent.com/10259764/87817879-94d85100-c81e-11ea-956c-ca0e23576fef.png) New appearance with fat scrollbars: ![image](https://user-images.githubusercontent.com/10259764/87817914-a4579a00-c81e-11ea-9e9d-195969e6da95.png) New appearance with thin scrollbars: ![image](https://user-images.githubusercontent.com/10259764/87818061-dff26400-c81e-11ea-866e-088f72276343.png) New appearance with no scrollbar: ![image](https://user-images.githubusercontent.com/10259764/87819674-7758b680-c821-11ea-98b7-dddd1573c242.png) --- src/cascadia/TerminalApp/CommandPalette.xaml | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/cascadia/TerminalApp/CommandPalette.xaml b/src/cascadia/TerminalApp/CommandPalette.xaml index e3d89d3e00a..39b0e1a25be 100644 --- a/src/cascadia/TerminalApp/CommandPalette.xaml +++ b/src/cascadia/TerminalApp/CommandPalette.xaml @@ -195,9 +195,10 @@ the MIT License. See LICENSE in the project root for license information. --> - - - + + + + From 3a91fc0ab4a9fad4033bc3999f07fbb4839163d9 Mon Sep 17 00:00:00 2001 From: Michael Niksa Date: Fri, 17 Jul 2020 12:32:36 -0700 Subject: [PATCH 14/33] Skip DX invalidation if we've already scrolled an entire screen worth of height (#6922) We spend a lot of time invalidating in the DX Renderer. This is a creative trick to not bother invalidating any further if we can tell that the bitmap is already completely invalidated. That is, if we've scrolled at least an entire screen in height... then the entire bitmap had to have been marked as invalid as the new areas were "uncovered" by the `InvalidateScroll` command. So further setting invalid bits on top of a fully invalid map is pointless. Note: I didn't use `bitmap::all()` here because it is significantly slower to check all the bits than it is to just reason out that the bitmap was already fully marked. ## Validation Steps Performed - Run `time cat big.txt`. Checked average time before/after, WPR traces before/after. --- .../actions/spell-check/dictionary/apis.txt | 1 + src/renderer/dx/DxRenderer.cpp | 46 ++++++++++++++----- src/renderer/dx/DxRenderer.hpp | 2 + 3 files changed, 38 insertions(+), 11 deletions(-) diff --git a/.github/actions/spell-check/dictionary/apis.txt b/.github/actions/spell-check/dictionary/apis.txt index 88494b86f64..298b869c186 100644 --- a/.github/actions/spell-check/dictionary/apis.txt +++ b/.github/actions/spell-check/dictionary/apis.txt @@ -21,6 +21,7 @@ IExplorer IMap IObject IStorage +llabs LCID LSHIFT NCHITTEST diff --git a/src/renderer/dx/DxRenderer.cpp b/src/renderer/dx/DxRenderer.cpp index 1714b6e10bd..e5d3d848e18 100644 --- a/src/renderer/dx/DxRenderer.cpp +++ b/src/renderer/dx/DxRenderer.cpp @@ -68,6 +68,7 @@ DxEngine::DxEngine() : _invalidateFullRows{ true }, _invalidMap{}, _invalidScroll{}, + _allInvalid{ false }, _firstFrame{ true }, _presentParams{ 0 }, _presentReady{ false }, @@ -847,6 +848,11 @@ void DxEngine::_InvalidateRectangle(const til::rectangle& rc) _invalidMap.set(invalidate); } +bool DxEngine::_IsAllInvalid() const noexcept +{ + return std::llabs(_invalidScroll.y()) >= _invalidMap.size().height(); +} + // Routine Description: // - Invalidates a rectangle described in characters // Arguments: @@ -858,7 +864,10 @@ try { RETURN_HR_IF_NULL(E_INVALIDARG, psrRegion); - _InvalidateRectangle(Viewport::FromExclusive(*psrRegion).ToInclusive()); + if (!_allInvalid) + { + _InvalidateRectangle(Viewport::FromExclusive(*psrRegion).ToInclusive()); + } return S_OK; } @@ -875,7 +884,10 @@ try { RETURN_HR_IF_NULL(E_INVALIDARG, pcoordCursor); - _InvalidateRectangle(til::rectangle{ *pcoordCursor, til::size{ 1, 1 } }); + if (!_allInvalid) + { + _InvalidateRectangle(til::rectangle{ *pcoordCursor, til::size{ 1, 1 } }); + } return S_OK; } @@ -892,9 +904,12 @@ try { RETURN_HR_IF_NULL(E_INVALIDARG, prcDirtyClient); - // Dirty client is in pixels. Use divide specialization against glyph factor to make conversion - // to cells. - _InvalidateRectangle(til::rectangle{ *prcDirtyClient }.scale_down(_glyphCell)); + if (!_allInvalid) + { + // Dirty client is in pixels. Use divide specialization against glyph factor to make conversion + // to cells. + _InvalidateRectangle(til::rectangle{ *prcDirtyClient }.scale_down(_glyphCell)); + } return S_OK; } @@ -908,9 +923,12 @@ CATCH_RETURN(); // - S_OK [[nodiscard]] HRESULT DxEngine::InvalidateSelection(const std::vector& rectangles) noexcept { - for (const auto& rect : rectangles) + if (!_allInvalid) { - RETURN_IF_FAILED(Invalidate(&rect)); + for (const auto& rect : rectangles) + { + RETURN_IF_FAILED(Invalidate(&rect)); + } } return S_OK; } @@ -930,11 +948,15 @@ try const til::point deltaCells{ *pcoordDelta }; - if (deltaCells != til::point{ 0, 0 }) + if (!_allInvalid) { - // Shift the contents of the map and fill in revealed area. - _invalidMap.translate(deltaCells, true); - _invalidScroll += deltaCells; + if (deltaCells != til::point{ 0, 0 }) + { + // Shift the contents of the map and fill in revealed area. + _invalidMap.translate(deltaCells, true); + _invalidScroll += deltaCells; + _allInvalid = _IsAllInvalid(); + } } return S_OK; @@ -951,6 +973,7 @@ CATCH_RETURN(); try { _invalidMap.set_all(); + _allInvalid = true; // Since everything is invalidated here, mark this as a "first frame", so // that we won't use incremental drawing on it. The caller of this intended @@ -1209,6 +1232,7 @@ try } _invalidMap.reset_all(); + _allInvalid = false; _invalidScroll = {}; diff --git a/src/renderer/dx/DxRenderer.hpp b/src/renderer/dx/DxRenderer.hpp index 708f3418e87..c56262d7d28 100644 --- a/src/renderer/dx/DxRenderer.hpp +++ b/src/renderer/dx/DxRenderer.hpp @@ -157,6 +157,7 @@ namespace Microsoft::Console::Render bool _invalidateFullRows; til::bitmap _invalidMap; til::point _invalidScroll; + bool _allInvalid; bool _presentReady; std::vector _presentDirty; @@ -271,6 +272,7 @@ namespace Microsoft::Console::Render [[nodiscard]] til::size _GetClientSize() const; void _InvalidateRectangle(const til::rectangle& rc); + bool _IsAllInvalid() const noexcept; [[nodiscard]] D2D1_COLOR_F _ColorFFromColorRef(const COLORREF color) noexcept; From d0ff5f6b5e7687c438e0a8b120280be307eda778 Mon Sep 17 00:00:00 2001 From: Mike Griese Date: Fri, 17 Jul 2020 16:05:29 -0500 Subject: [PATCH 15/33] Add support for running a `wt` commandline in the curent window WITH A KEYBINDING (#6537) ## Summary of the Pull Request Adds a execute commandline action (`wt`), which lets a user bind a key to a specific `wt` commandline. This commandline will get parsed and run _in the current window_. ## References * Related to #4472 * Related to #5400 - I need this for the commandline mode of the Command Palette * Related to #5970 ## PR Checklist * [x] Closes oh, there's not actually an issue for this. * [x] I work here * [x] Tests added/passed * [ ] Requires documentation to be updated - yes it does ## Detailed Description of the Pull Request / Additional comments One important part of this change concerns how panes are initialized at runtime. We've had some persistent trouble with initializing multiple panes, because they rely on knowing how big they'll actually be, to be able to determine if they can split again. We previously worked around this by ignoring the size check when we were in "startup", processing an initial commandline. This PR however requires us to be able to know the initial size of a pane at runtime, but before the parents have necessarily been added to the tree, or had their renderer's set up. This led to the development of `Pane::PreCalculateCanSplit`, which is very highly similar to `Pane::PreCalculateAutoSplit`. This method attempts to figure out how big a pane _will_ take, before the parent has necessarily laid out. This also involves a small change to `TermControl`, because if its renderer hasn't been set up yet, it'll always think the font is `{0, fontHeight}`, which will let the Terminal keep splitting in the x direction. This change also makes the TermControl set up a renderer to get the real font size when it hasn't yet been initialized. ## Validation Steps Performed This was what the json blob I was using for testing evolved into ```json { "command": { "action":"wt", "commandline": "new-tab cmd.exe /k #work 15 ; split-pane cmd.exe /k #work 15 ; split-pane cmd.exe /k media-commandline ; new-tab powershell dev\\symbols.ps1 ; new-tab -p \"Ubuntu\" ; new-tab -p \"haunter.gif\" ; focus-tab -t 0", }, "keys": ["ctrl+shift+n"] } ``` I also added some tests. # TODO * [x] Creating a `{ "command": "wt" }` action without a commandline will spawn a new `wt.exe` process? - Probably should just do nothing for the empty string --- doc/cascadia/profiles.schema.json | 19 +++ .../CommandlineTest.cpp | 68 +++++++++++ .../LocalTests_TerminalApp/SettingsTests.cpp | 53 +++++++++ src/cascadia/TerminalApp/ActionAndArgs.cpp | 5 + src/cascadia/TerminalApp/ActionArgs.cpp | 14 +++ src/cascadia/TerminalApp/ActionArgs.h | 34 ++++++ src/cascadia/TerminalApp/ActionArgs.idl | 5 + .../TerminalApp/AppActionHandlers.cpp | 17 +++ .../TerminalApp/AppCommandlineArgs.cpp | 54 ++++++++- src/cascadia/TerminalApp/AppCommandlineArgs.h | 6 +- src/cascadia/TerminalApp/AppLogic.cpp | 55 +-------- src/cascadia/TerminalApp/AppLogic.h | 2 +- src/cascadia/TerminalApp/AppLogic.idl | 3 +- .../TerminalApp/GlobalAppSettings.cpp | 1 - src/cascadia/TerminalApp/Pane.cpp | 97 +++++++++++++++ src/cascadia/TerminalApp/Pane.h | 4 +- .../Resources/en-US/Resources.resw | 4 + .../TerminalApp/ShortcutActionDispatch.cpp | 4 + .../TerminalApp/ShortcutActionDispatch.h | 1 + .../TerminalApp/ShortcutActionDispatch.idl | 4 +- src/cascadia/TerminalApp/Tab.cpp | 4 + src/cascadia/TerminalApp/Tab.h | 1 + src/cascadia/TerminalApp/TerminalPage.cpp | 106 +++++++++++++---- src/cascadia/TerminalApp/TerminalPage.h | 8 +- src/cascadia/TerminalApp/lib/pch.h | 1 + src/cascadia/TerminalControl/TermControl.cpp | 112 +++++++++++++----- src/cascadia/TerminalControl/TermControl.h | 9 +- src/cascadia/TerminalControl/TermControl.idl | 2 +- src/cascadia/WindowsTerminal/AppHost.cpp | 4 +- 29 files changed, 582 insertions(+), 115 deletions(-) diff --git a/doc/cascadia/profiles.schema.json b/doc/cascadia/profiles.schema.json index 3df0f2d5604..0ca40b685bd 100644 --- a/doc/cascadia/profiles.schema.json +++ b/doc/cascadia/profiles.schema.json @@ -63,6 +63,7 @@ "openTabColorPicker", "renameTab", "commandPalette", + "wt", "unbound" ], "type": "string" @@ -280,6 +281,23 @@ } ] }, + "WtAction": { + "description": "Arguments corresponding to a wt Action", + "allOf": [ + { "$ref": "#/definitions/ShortcutAction" }, + { + "properties": { + "action": { "type": "string", "pattern": "wt" }, + "commandline": { + "type": "string", + "default": "", + "description": "a `wt` commandline to run in the current window" + } + } + } + ], + "required": [ "commandline" ] + }, "Keybinding": { "additionalProperties": false, "properties": { @@ -296,6 +314,7 @@ { "$ref": "#/definitions/SplitPaneAction" }, { "$ref": "#/definitions/OpenSettingsAction" }, { "$ref": "#/definitions/SetTabColorAction" }, + { "$ref": "#/definitions/WtAction" }, { "type": "null" } ] }, diff --git a/src/cascadia/LocalTests_TerminalApp/CommandlineTest.cpp b/src/cascadia/LocalTests_TerminalApp/CommandlineTest.cpp index e9191a4f2f5..d9735e2ccd4 100644 --- a/src/cascadia/LocalTests_TerminalApp/CommandlineTest.cpp +++ b/src/cascadia/LocalTests_TerminalApp/CommandlineTest.cpp @@ -4,7 +4,9 @@ #include "pch.h" #include +#include "../TerminalApp/TerminalPage.h" #include "../TerminalApp/AppCommandlineArgs.h" +#include "../TerminalApp/ActionArgs.h" using namespace WEX::Logging; using namespace WEX::Common; @@ -52,6 +54,10 @@ namespace TerminalAppLocalTests TEST_METHOD(CheckTypos); + TEST_METHOD(TestSimpleExecuteCommandlineAction); + TEST_METHOD(TestMultipleCommandExecuteCommandlineAction); + TEST_METHOD(TestInvalidExecuteCommandlineAction); + private: void _buildCommandlinesHelper(AppCommandlineArgs& appArgs, const size_t expectedSubcommands, @@ -1067,4 +1073,66 @@ namespace TerminalAppLocalTests VERIFY_ARE_EQUAL(L"C:\\", myArgs.TerminalArgs().StartingDirectory()); } } + + void CommandlineTest::TestSimpleExecuteCommandlineAction() + { + auto args = winrt::make_self(); + args->Commandline(L"new-tab"); + auto actions = implementation::TerminalPage::ConvertExecuteCommandlineToActions(*args); + VERIFY_ARE_EQUAL(1u, actions.size()); + auto actionAndArgs = actions.at(0); + VERIFY_ARE_EQUAL(ShortcutAction::NewTab, actionAndArgs.Action()); + VERIFY_IS_NOT_NULL(actionAndArgs.Args()); + auto myArgs = actionAndArgs.Args().try_as(); + VERIFY_IS_NOT_NULL(myArgs); + VERIFY_IS_NOT_NULL(myArgs.TerminalArgs()); + VERIFY_IS_TRUE(myArgs.TerminalArgs().Commandline().empty()); + VERIFY_IS_TRUE(myArgs.TerminalArgs().StartingDirectory().empty()); + VERIFY_IS_TRUE(myArgs.TerminalArgs().TabTitle().empty()); + VERIFY_IS_TRUE(myArgs.TerminalArgs().ProfileIndex() == nullptr); + VERIFY_IS_TRUE(myArgs.TerminalArgs().Profile().empty()); + } + + void CommandlineTest::TestMultipleCommandExecuteCommandlineAction() + { + auto args = winrt::make_self(); + args->Commandline(L"new-tab ; split-pane"); + auto actions = implementation::TerminalPage::ConvertExecuteCommandlineToActions(*args); + VERIFY_ARE_EQUAL(2u, actions.size()); + { + auto actionAndArgs = actions.at(0); + VERIFY_ARE_EQUAL(ShortcutAction::NewTab, actionAndArgs.Action()); + VERIFY_IS_NOT_NULL(actionAndArgs.Args()); + auto myArgs = actionAndArgs.Args().try_as(); + VERIFY_IS_NOT_NULL(myArgs); + VERIFY_IS_NOT_NULL(myArgs.TerminalArgs()); + VERIFY_IS_TRUE(myArgs.TerminalArgs().Commandline().empty()); + VERIFY_IS_TRUE(myArgs.TerminalArgs().StartingDirectory().empty()); + VERIFY_IS_TRUE(myArgs.TerminalArgs().TabTitle().empty()); + VERIFY_IS_TRUE(myArgs.TerminalArgs().ProfileIndex() == nullptr); + VERIFY_IS_TRUE(myArgs.TerminalArgs().Profile().empty()); + } + { + auto actionAndArgs = actions.at(1); + VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action()); + VERIFY_IS_NOT_NULL(actionAndArgs.Args()); + auto myArgs = actionAndArgs.Args().try_as(); + VERIFY_IS_NOT_NULL(myArgs); + VERIFY_IS_NOT_NULL(myArgs.TerminalArgs()); + VERIFY_IS_TRUE(myArgs.TerminalArgs().Commandline().empty()); + VERIFY_IS_TRUE(myArgs.TerminalArgs().StartingDirectory().empty()); + VERIFY_IS_TRUE(myArgs.TerminalArgs().TabTitle().empty()); + VERIFY_IS_TRUE(myArgs.TerminalArgs().ProfileIndex() == nullptr); + VERIFY_IS_TRUE(myArgs.TerminalArgs().Profile().empty()); + } + } + + void CommandlineTest::TestInvalidExecuteCommandlineAction() + { + auto args = winrt::make_self(); + // -H and -V cannot be combined. + args->Commandline(L"split-pane -H -V"); + auto actions = implementation::TerminalPage::ConvertExecuteCommandlineToActions(*args); + VERIFY_ARE_EQUAL(0u, actions.size()); + } } diff --git a/src/cascadia/LocalTests_TerminalApp/SettingsTests.cpp b/src/cascadia/LocalTests_TerminalApp/SettingsTests.cpp index ecd58743f56..cdfb08415f5 100644 --- a/src/cascadia/LocalTests_TerminalApp/SettingsTests.cpp +++ b/src/cascadia/LocalTests_TerminalApp/SettingsTests.cpp @@ -76,6 +76,8 @@ namespace TerminalAppLocalTests TEST_METHOD(ValidateKeybindingsWarnings); + TEST_METHOD(ValidateExecuteCommandlineWarning); + TEST_METHOD(ValidateLegacyGlobalsWarning); TEST_METHOD(TestTrailingCommas); @@ -2254,6 +2256,57 @@ namespace TerminalAppLocalTests VERIFY_ARE_EQUAL(::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter, settings->_warnings.at(3)); } + void SettingsTests::ValidateExecuteCommandlineWarning() + { + Log::Comment(L"This test is affected by GH#6949, so we're just skipping it for now."); + Log::Result(WEX::Logging::TestResults::Skipped); + return; + + // const std::string badSettings{ R"( + // { + // "defaultProfile": "{6239a42c-2222-49a3-80bd-e8fdd045185c}", + // "profiles": [ + // { + // "name" : "profile0", + // "guid": "{6239a42c-2222-49a3-80bd-e8fdd045185c}" + // }, + // { + // "name" : "profile1", + // "guid": "{6239a42c-3333-49a3-80bd-e8fdd045185c}" + // } + // ], + // "keybindings": [ + // { "name":null, "command": { "action": "wt" }, "keys": [ "ctrl+a" ] }, + // { "name":null, "command": { "action": "wt", "commandline":"" }, "keys": [ "ctrl+b" ] }, + // { "name":null, "command": { "action": "wt", "commandline":null }, "keys": [ "ctrl+c" ] } + // ] + // })" }; + + // const auto settingsObject = VerifyParseSucceeded(badSettings); + + // auto settings = CascadiaSettings::FromJson(settingsObject); + + // VERIFY_ARE_EQUAL(0u, settings->_globals._keybindings->_keyShortcuts.size()); + + // for (const auto& warning : settings->_globals._keybindingsWarnings) + // { + // Log::Comment(NoThrowString().Format( + // L"warning:%d", warning)); + // } + // VERIFY_ARE_EQUAL(3u, settings->_globals._keybindingsWarnings.size()); + // VERIFY_ARE_EQUAL(::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter, settings->_globals._keybindingsWarnings.at(0)); + // VERIFY_ARE_EQUAL(::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter, settings->_globals._keybindingsWarnings.at(1)); + // VERIFY_ARE_EQUAL(::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter, settings->_globals._keybindingsWarnings.at(2)); + + // settings->_ValidateKeybindings(); + + // VERIFY_ARE_EQUAL(4u, settings->_warnings.size()); + // VERIFY_ARE_EQUAL(::TerminalApp::SettingsLoadWarnings::AtLeastOneKeybindingWarning, settings->_warnings.at(0)); + // VERIFY_ARE_EQUAL(::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter, settings->_warnings.at(1)); + // VERIFY_ARE_EQUAL(::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter, settings->_warnings.at(2)); + // VERIFY_ARE_EQUAL(::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter, settings->_warnings.at(3)); + } + void SettingsTests::ValidateLegacyGlobalsWarning() { const std::string badSettings{ R"( diff --git a/src/cascadia/TerminalApp/ActionAndArgs.cpp b/src/cascadia/TerminalApp/ActionAndArgs.cpp index a5d98e89bd2..f28bfcca8a6 100644 --- a/src/cascadia/TerminalApp/ActionAndArgs.cpp +++ b/src/cascadia/TerminalApp/ActionAndArgs.cpp @@ -38,6 +38,7 @@ static constexpr std::string_view ToggleAlwaysOnTopKey{ "toggleAlwaysOnTop" }; static constexpr std::string_view SetTabColorKey{ "setTabColor" }; static constexpr std::string_view OpenTabColorPickerKey{ "openTabColorPicker" }; static constexpr std::string_view RenameTabKey{ "renameTab" }; +static constexpr std::string_view ExecuteCommandlineKey{ "wt" }; static constexpr std::string_view ToggleCommandPaletteKey{ "commandPalette" }; static constexpr std::string_view ActionKey{ "action" }; @@ -89,6 +90,7 @@ namespace winrt::TerminalApp::implementation { UnboundKey, ShortcutAction::Invalid }, { FindKey, ShortcutAction::Find }, { RenameTabKey, ShortcutAction::RenameTab }, + { ExecuteCommandlineKey, ShortcutAction::ExecuteCommandline }, { ToggleCommandPaletteKey, ShortcutAction::ToggleCommandPalette }, }; @@ -121,6 +123,8 @@ namespace winrt::TerminalApp::implementation { ShortcutAction::RenameTab, winrt::TerminalApp::implementation::RenameTabArgs::FromJson }, + { ShortcutAction::ExecuteCommandline, winrt::TerminalApp::implementation::ExecuteCommandlineArgs::FromJson }, + { ShortcutAction::Invalid, nullptr }, }; @@ -268,6 +272,7 @@ namespace winrt::TerminalApp::implementation { ShortcutAction::SetTabColor, RS_(L"ResetTabColorCommandKey") }, { ShortcutAction::OpenTabColorPicker, RS_(L"OpenTabColorPickerCommandKey") }, { ShortcutAction::RenameTab, RS_(L"ResetTabNameCommandKey") }, + { ShortcutAction::ExecuteCommandline, RS_(L"ExecuteCommandlineCommandKey") }, { ShortcutAction::ToggleCommandPalette, RS_(L"ToggleCommandPaletteCommandKey") }, }; }(); diff --git a/src/cascadia/TerminalApp/ActionArgs.cpp b/src/cascadia/TerminalApp/ActionArgs.cpp index 012eacd7f22..a5a83203afa 100644 --- a/src/cascadia/TerminalApp/ActionArgs.cpp +++ b/src/cascadia/TerminalApp/ActionArgs.cpp @@ -17,6 +17,7 @@ #include "OpenSettingsArgs.g.cpp" #include "SetTabColorArgs.g.cpp" #include "RenameTabArgs.g.cpp" +#include "ExecuteCommandlineArgs.g.cpp" #include @@ -258,4 +259,17 @@ namespace winrt::TerminalApp::implementation return RS_(L"ResetTabNameCommandKey"); } + winrt::hstring ExecuteCommandlineArgs::GenerateName() const + { + // "Run commandline "{_Commandline}" in this window" + if (!_Commandline.empty()) + { + return winrt::hstring{ + fmt::format(std::wstring_view(RS_(L"ExecuteCommandlineCommandKey")), + _Commandline.c_str()) + }; + } + return L""; + } + } diff --git a/src/cascadia/TerminalApp/ActionArgs.h b/src/cascadia/TerminalApp/ActionArgs.h index 93e2b5baf3e..091774230d1 100644 --- a/src/cascadia/TerminalApp/ActionArgs.h +++ b/src/cascadia/TerminalApp/ActionArgs.h @@ -17,6 +17,7 @@ #include "OpenSettingsArgs.g.h" #include "SetTabColorArgs.g.h" #include "RenameTabArgs.g.h" +#include "ExecuteCommandlineArgs.g.h" #include "../../cascadia/inc/cppwinrt_utils.h" #include "Utils.h" @@ -387,6 +388,39 @@ namespace winrt::TerminalApp::implementation return { *args, {} }; } }; + + struct ExecuteCommandlineArgs : public ExecuteCommandlineArgsT + { + ExecuteCommandlineArgs() = default; + GETSET_PROPERTY(winrt::hstring, Commandline, L""); + + static constexpr std::string_view CommandlineKey{ "commandline" }; + + public: + hstring GenerateName() const; + + bool Equals(const IActionArgs& other) + { + auto otherAsUs = other.try_as(); + if (otherAsUs) + { + return otherAsUs->_Commandline == _Commandline; + } + return false; + }; + static FromJsonResult FromJson(const Json::Value& json) + { + // LOAD BEARING: Not using make_self here _will_ break you in the future! + auto args = winrt::make_self(); + JsonUtils::GetValueForKey(json, CommandlineKey, args->_Commandline); + if (args->_Commandline.empty()) + { + return { nullptr, { ::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter } }; + } + return { *args, {} }; + } + }; + } namespace winrt::TerminalApp::factory_implementation diff --git a/src/cascadia/TerminalApp/ActionArgs.idl b/src/cascadia/TerminalApp/ActionArgs.idl index 36d5025bb4a..84e5588bf2d 100644 --- a/src/cascadia/TerminalApp/ActionArgs.idl +++ b/src/cascadia/TerminalApp/ActionArgs.idl @@ -115,4 +115,9 @@ namespace TerminalApp { String Title { get; }; }; + + [default_interface] runtimeclass ExecuteCommandlineArgs : IActionArgs + { + String Commandline; + }; } diff --git a/src/cascadia/TerminalApp/AppActionHandlers.cpp b/src/cascadia/TerminalApp/AppActionHandlers.cpp index 271513d4e58..63a2743d80b 100644 --- a/src/cascadia/TerminalApp/AppActionHandlers.cpp +++ b/src/cascadia/TerminalApp/AppActionHandlers.cpp @@ -11,6 +11,7 @@ using namespace winrt::Windows::ApplicationModel::DataTransfer; using namespace winrt::Windows::UI::Xaml; using namespace winrt::Windows::UI::Text; using namespace winrt::Windows::UI::Core; +using namespace winrt::Windows::Foundation::Collections; using namespace winrt::Windows::System; using namespace winrt::Microsoft::Terminal; using namespace winrt::Microsoft::Terminal::Settings; @@ -334,4 +335,20 @@ namespace winrt::TerminalApp::implementation } args.Handled(true); } + + void TerminalPage::_HandleExecuteCommandline(const IInspectable& /*sender*/, + const TerminalApp::ActionEventArgs& actionArgs) + { + if (const auto& realArgs = actionArgs.ActionArgs().try_as()) + { + auto actions = winrt::single_threaded_vector(std::move( + TerminalPage::ConvertExecuteCommandlineToActions(realArgs))); + + if (_startupActions.Size() != 0) + { + actionArgs.Handled(true); + _ProcessStartupActions(actions, false); + } + } + } } diff --git a/src/cascadia/TerminalApp/AppCommandlineArgs.cpp b/src/cascadia/TerminalApp/AppCommandlineArgs.cpp index 753afb2fe6e..70e6df6940b 100644 --- a/src/cascadia/TerminalApp/AppCommandlineArgs.cpp +++ b/src/cascadia/TerminalApp/AppCommandlineArgs.cpp @@ -599,7 +599,7 @@ void AppCommandlineArgs::_addCommandsForArg(std::vector& commands, // - // Return Value: // - the deque of actions we've buffered as a result of parsing commands. -std::deque& AppCommandlineArgs::GetStartupActions() +std::vector& AppCommandlineArgs::GetStartupActions() { return _startupActions; } @@ -658,7 +658,8 @@ void AppCommandlineArgs::ValidateStartupCommands() auto newTerminalArgs = winrt::make_self(); args->TerminalArgs(*newTerminalArgs); newTabAction->Args(*args); - _startupActions.push_front(*newTabAction); + // push the arg onto the front + _startupActions.insert(_startupActions.begin(), 1, *newTabAction); } } @@ -666,3 +667,52 @@ std::optional AppCommandlineArgs::GetLaunchMode( { return _launchMode; } + +// Method Description: +// - Attempts to parse an array of commandline args into a list of +// commands to execute, and then parses these commands. As commands are +// successfully parsed, they will generate ShortcutActions for us to be +// able to execute. If we fail to parse any commands, we'll return the +// error code from the failure to parse that command, and stop processing +// additional commands. +// - The first arg in args should be the program name "wt" (or some variant). It +// will be ignored during parsing. +// Arguments: +// - args: an array of strings to process as a commandline. These args can contain spaces +// Return Value: +// - 0 if the commandline was successfully parsed +int AppCommandlineArgs::ParseArgs(winrt::array_view& args) +{ + auto commands = ::TerminalApp::AppCommandlineArgs::BuildCommands(args); + + for (auto& cmdBlob : commands) + { + // On one hand, it seems like we should be able to have one + // AppCommandlineArgs for parsing all of them, and collect the + // results one at a time. + // + // On the other hand, re-using a CLI::App seems to leave state from + // previous parsings around, so we could get mysterious behavior + // where one command affects the values of the next. + // + // From https://cliutils.github.io/CLI11/book/chapters/options.html: + // > If that option is not given, CLI11 will not touch the initial + // > value. This allows you to set up defaults by simply setting + // > your value beforehand. + // + // So we pretty much need the to either manually reset the state + // each command, or build new ones. + const auto result = ParseCommand(cmdBlob); + + // If this succeeded, result will be 0. Otherwise, the caller should + // exit(result), to exit the program. + if (result != 0) + { + return result; + } + } + + // If all the args were successfully parsed, we'll have some commands + // built in _appArgs, which we'll use when the application starts up. + return 0; +} diff --git a/src/cascadia/TerminalApp/AppCommandlineArgs.h b/src/cascadia/TerminalApp/AppCommandlineArgs.h index 00c7f3cd904..a0d87ffc6b8 100644 --- a/src/cascadia/TerminalApp/AppCommandlineArgs.h +++ b/src/cascadia/TerminalApp/AppCommandlineArgs.h @@ -28,13 +28,15 @@ class TerminalApp::AppCommandlineArgs final AppCommandlineArgs(); ~AppCommandlineArgs() = default; + int ParseCommand(const Commandline& command); + int ParseArgs(winrt::array_view& args); static std::vector BuildCommands(const std::vector& args); static std::vector BuildCommands(winrt::array_view& args); void ValidateStartupCommands(); - std::deque& GetStartupActions(); + std::vector& GetStartupActions(); const std::string& GetExitMessage(); bool ShouldExitEarly() const noexcept; @@ -90,7 +92,7 @@ class TerminalApp::AppCommandlineArgs final std::optional _launchMode{ std::nullopt }; // Are you adding more args here? Make sure to reset them in _resetStateToDefault - std::deque _startupActions; + std::vector _startupActions; std::string _exitMessage; bool _shouldExitEarly{ false }; diff --git a/src/cascadia/TerminalApp/AppLogic.cpp b/src/cascadia/TerminalApp/AppLogic.cpp index e036bd9ee2c..5a6ec188703 100644 --- a/src/cascadia/TerminalApp/AppLogic.cpp +++ b/src/cascadia/TerminalApp/AppLogic.cpp @@ -474,7 +474,7 @@ namespace winrt::TerminalApp::implementation // - // Return Value: // - a point containing the requested dimensions in pixels. - winrt::Windows::Foundation::Point AppLogic::GetLaunchDimensions(uint32_t dpi) + winrt::Windows::Foundation::Size AppLogic::GetLaunchDimensions(uint32_t dpi) { if (!_loadedInitialSettings) { @@ -504,7 +504,7 @@ namespace winrt::TerminalApp::implementation // of the height calculation here. auto titlebar = TitlebarControl{ static_cast(0) }; titlebar.Measure({ SHRT_MAX, SHRT_MAX }); - proposedSize.Y += (titlebar.DesiredSize().Height) * scale; + proposedSize.Height += (titlebar.DesiredSize().Height) * scale; } else if (_settings->GlobalSettings().AlwaysShowTabs()) { @@ -519,7 +519,7 @@ namespace winrt::TerminalApp::implementation // For whatever reason, there's about 6px of unaccounted-for space // in the application. I couldn't tell you where these 6px are // coming from, but they need to be included in this math. - proposedSize.Y += (tabControl.DesiredSize().Height + 6) * scale; + proposedSize.Width += (tabControl.DesiredSize().Height + 6) * scale; } return proposedSize; @@ -974,7 +974,7 @@ namespace winrt::TerminalApp::implementation // or 0. (see AppLogic::_ParseArgs) int32_t AppLogic::SetStartupCommandline(array_view args) { - const auto result = _ParseArgs(args); + const auto result = _appArgs.ParseArgs(args); if (result == 0) { _appArgs.ValidateStartupCommands(); @@ -984,53 +984,6 @@ namespace winrt::TerminalApp::implementation return result; } - // Method Description: - // - Attempts to parse an array of commandline args into a list of - // commands to execute, and then parses these commands. As commands are - // successfully parsed, they will generate ShortcutActions for us to be - // able to execute. If we fail to parse any commands, we'll return the - // error code from the failure to parse that command, and stop processing - // additional commands. - // Arguments: - // - args: an array of strings to process as a commandline. These args can contain spaces - // Return Value: - // - 0 if the commandline was successfully parsed - int AppLogic::_ParseArgs(winrt::array_view& args) - { - auto commands = ::TerminalApp::AppCommandlineArgs::BuildCommands(args); - - for (auto& cmdBlob : commands) - { - // On one hand, it seems like we should be able to have one - // AppCommandlineArgs for parsing all of them, and collect the - // results one at a time. - // - // On the other hand, re-using a CLI::App seems to leave state from - // previous parsings around, so we could get mysterious behavior - // where one command affects the values of the next. - // - // From https://cliutils.github.io/CLI11/book/chapters/options.html: - // > If that option is not given, CLI11 will not touch the initial - // > value. This allows you to set up defaults by simply setting - // > your value beforehand. - // - // So we pretty much need the to either manually reset the state - // each command, or build new ones. - const auto result = _appArgs.ParseCommand(cmdBlob); - - // If this succeeded, result will be 0. Otherwise, the caller should - // exit(result), to exit the program. - if (result != 0) - { - return result; - } - } - - // If all the args were successfully parsed, we'll have some commands - // built in _appArgs, which we'll use when the application starts up. - return 0; - } - // Method Description: // - If there were any errors parsing the commandline that was used to // initialize the terminal, this will return a string containing that diff --git a/src/cascadia/TerminalApp/AppLogic.h b/src/cascadia/TerminalApp/AppLogic.h index c879a6f1876..de2b225f81f 100644 --- a/src/cascadia/TerminalApp/AppLogic.h +++ b/src/cascadia/TerminalApp/AppLogic.h @@ -37,7 +37,7 @@ namespace winrt::TerminalApp::implementation bool Fullscreen() const; bool AlwaysOnTop() const; - Windows::Foundation::Point GetLaunchDimensions(uint32_t dpi); + Windows::Foundation::Size GetLaunchDimensions(uint32_t dpi); winrt::Windows::Foundation::Point GetLaunchInitialPositions(int32_t defaultInitialX, int32_t defaultInitialY); winrt::Windows::UI::Xaml::ElementTheme GetRequestedTheme(); LaunchMode GetLaunchMode(); diff --git a/src/cascadia/TerminalApp/AppLogic.idl b/src/cascadia/TerminalApp/AppLogic.idl index 071a5ce84cc..00006608ef1 100644 --- a/src/cascadia/TerminalApp/AppLogic.idl +++ b/src/cascadia/TerminalApp/AppLogic.idl @@ -45,7 +45,8 @@ namespace TerminalApp Boolean Fullscreen { get; }; Boolean AlwaysOnTop { get; }; - Windows.Foundation.Point GetLaunchDimensions(UInt32 dpi); + Windows.Foundation.Size GetLaunchDimensions(UInt32 dpi); + Windows.Foundation.Point GetLaunchInitialPositions(Int32 defaultInitialX, Int32 defaultInitialY); Windows.UI.Xaml.ElementTheme GetRequestedTheme(); LaunchMode GetLaunchMode(); diff --git a/src/cascadia/TerminalApp/GlobalAppSettings.cpp b/src/cascadia/TerminalApp/GlobalAppSettings.cpp index c214c04896d..dd3b17ae723 100644 --- a/src/cascadia/TerminalApp/GlobalAppSettings.cpp +++ b/src/cascadia/TerminalApp/GlobalAppSettings.cpp @@ -199,7 +199,6 @@ void GlobalAppSettings::LayerJson(const Json::Value& json) warnings = winrt::TerminalApp::implementation::Command::LayerJson(_commands, bindings); // It's possible that the user provided commands have some warnings // in them, similar to the keybindings. - _keybindingsWarnings.insert(_keybindingsWarnings.end(), warnings.begin(), warnings.end()); } }; parseBindings(LegacyKeybindingsKey); diff --git a/src/cascadia/TerminalApp/Pane.cpp b/src/cascadia/TerminalApp/Pane.cpp index b931755c1e3..f8e61ae8379 100644 --- a/src/cascadia/TerminalApp/Pane.cpp +++ b/src/cascadia/TerminalApp/Pane.cpp @@ -7,6 +7,7 @@ #include "CascadiaSettings.h" using namespace winrt::Windows::Foundation; +using namespace winrt::Windows::Graphics::Display; using namespace winrt::Windows::UI; using namespace winrt::Windows::UI::Xaml; using namespace winrt::Windows::UI::Core; @@ -921,6 +922,102 @@ bool Pane::CanSplit(SplitState splitType) return false; } +// Method Description: +// - This is a helper to determine if a given Pane can be split, but without +// using the ActualWidth() and ActualHeight() methods. This is used during +// processing of many "split-pane" commands, which could happen _before_ we've +// laid out a Pane for the first time. When this happens, the Pane's don't +// have an actual size yet. However, we'd still like to figure out if the pane +// could be split, once they're all laid out. +// - This method assumes that the Pane we're attempting to split is `target`, +// and this method should be called on the root of a tree of Panes. +// - We'll walk down the tree attempting to find `target`. As we traverse the +// tree, we'll reduce the size passed to each subsequent recursive call. The +// size passed to this method represents how much space this Pane _will_ have +// to use. +// * If this pane is a leaf, and it's the pane we're looking for, use the +// available space to calculate which direction to split in. +// * If this pane is _any other leaf_, then just return nullopt, to indicate +// that the `target` Pane is not down this branch. +// * If this pane is a parent, calculate how much space our children will be +// able to use, and recurse into them. +// Arguments: +// - target: The Pane we're attempting to split. +// - splitType: The direction we're attempting to split in. +// - availableSpace: The theoretical space that's available for this pane to be able to split. +// Return Value: +// - nullopt if `target` is not this pane or a child of this pane, otherwise +// true iff we could split this pane, given `availableSpace` +// Note: +// - This method is highly similar to Pane::PreCalculateAutoSplit +std::optional Pane::PreCalculateCanSplit(const std::shared_ptr target, + SplitState splitType, + const winrt::Windows::Foundation::Size availableSpace) const +{ + if (_IsLeaf()) + { + if (target.get() == this) + { + // If this pane is a leaf, and it's the pane we're looking for, use + // the available space to calculate which direction to split in. + const Size minSize = _GetMinSize(); + + if (splitType == SplitState::None) + { + return { false }; + } + + else if (splitType == SplitState::Vertical) + { + const auto widthMinusSeparator = availableSpace.Width - CombinedPaneBorderSize; + const auto newWidth = widthMinusSeparator * Half; + + return { newWidth > minSize.Width }; + } + + else if (splitType == SplitState::Horizontal) + { + const auto heightMinusSeparator = availableSpace.Height - CombinedPaneBorderSize; + const auto newHeight = heightMinusSeparator * Half; + + return { newHeight > minSize.Height }; + } + } + else + { + // If this pane is _any other leaf_, then just return nullopt, to + // indicate that the `target` Pane is not down this branch. + return std::nullopt; + } + } + else + { + // If this pane is a parent, calculate how much space our children will + // be able to use, and recurse into them. + + const bool isVerticalSplit = _splitState == SplitState::Vertical; + const float firstWidth = isVerticalSplit ? + (availableSpace.Width * _desiredSplitPosition) - PaneBorderSize : + availableSpace.Width; + const float secondWidth = isVerticalSplit ? + (availableSpace.Width - firstWidth) - PaneBorderSize : + availableSpace.Width; + const float firstHeight = !isVerticalSplit ? + (availableSpace.Height * _desiredSplitPosition) - PaneBorderSize : + availableSpace.Height; + const float secondHeight = !isVerticalSplit ? + (availableSpace.Height - firstHeight) - PaneBorderSize : + availableSpace.Height; + + const auto firstResult = _firstChild->PreCalculateCanSplit(target, splitType, { firstWidth, firstHeight }); + return firstResult.has_value() ? firstResult : _secondChild->PreCalculateCanSplit(target, splitType, { secondWidth, secondHeight }); + } + + // We should not possibly be getting here - both the above branches should + // return a value. + FAIL_FAST(); +} + // Method Description: // - Split the focused pane in our tree of panes, and place the given // TermControl into the newly created pane. If we're the focused pane, then diff --git a/src/cascadia/TerminalApp/Pane.h b/src/cascadia/TerminalApp/Pane.h index 7041db1f0cb..a9c7bd9cebb 100644 --- a/src/cascadia/TerminalApp/Pane.h +++ b/src/cascadia/TerminalApp/Pane.h @@ -64,7 +64,9 @@ class Pane : public std::enable_shared_from_this const winrt::Microsoft::Terminal::TerminalControl::TermControl& control); float CalcSnappedDimension(const bool widthOrHeight, const float dimension) const; std::optional PreCalculateAutoSplit(const std::shared_ptr target, const winrt::Windows::Foundation::Size parentSize) const; - + std::optional PreCalculateCanSplit(const std::shared_ptr target, + winrt::TerminalApp::SplitState splitType, + const winrt::Windows::Foundation::Size availableSpace) const; void Shutdown(); void Close(); diff --git a/src/cascadia/TerminalApp/Resources/en-US/Resources.resw b/src/cascadia/TerminalApp/Resources/en-US/Resources.resw index 09283b55c6d..6ca22a39ff0 100644 --- a/src/cascadia/TerminalApp/Resources/en-US/Resources.resw +++ b/src/cascadia/TerminalApp/Resources/en-US/Resources.resw @@ -543,6 +543,10 @@ Reset tab title + + Run commandline "{0}" in this window + {0} will be replaced with user-defined commandline + Crimson diff --git a/src/cascadia/TerminalApp/ShortcutActionDispatch.cpp b/src/cascadia/TerminalApp/ShortcutActionDispatch.cpp index a040106e24c..571b4589516 100644 --- a/src/cascadia/TerminalApp/ShortcutActionDispatch.cpp +++ b/src/cascadia/TerminalApp/ShortcutActionDispatch.cpp @@ -194,6 +194,10 @@ namespace winrt::TerminalApp::implementation _RenameTabHandlers(*this, *eventArgs); break; } + case ShortcutAction::ExecuteCommandline: + { + _ExecuteCommandlineHandlers(*this, *eventArgs); + } default: return false; } diff --git a/src/cascadia/TerminalApp/ShortcutActionDispatch.h b/src/cascadia/TerminalApp/ShortcutActionDispatch.h index 9b930db980d..9c1dff1575c 100644 --- a/src/cascadia/TerminalApp/ShortcutActionDispatch.h +++ b/src/cascadia/TerminalApp/ShortcutActionDispatch.h @@ -54,6 +54,7 @@ namespace winrt::TerminalApp::implementation TYPED_EVENT(SetTabColor, TerminalApp::ShortcutActionDispatch, TerminalApp::ActionEventArgs); TYPED_EVENT(OpenTabColorPicker, TerminalApp::ShortcutActionDispatch, TerminalApp::ActionEventArgs); TYPED_EVENT(RenameTab, TerminalApp::ShortcutActionDispatch, TerminalApp::ActionEventArgs); + TYPED_EVENT(ExecuteCommandline, TerminalApp::ShortcutActionDispatch, TerminalApp::ActionEventArgs); // clang-format on private: diff --git a/src/cascadia/TerminalApp/ShortcutActionDispatch.idl b/src/cascadia/TerminalApp/ShortcutActionDispatch.idl index 2588c3258b2..8306c04fc46 100644 --- a/src/cascadia/TerminalApp/ShortcutActionDispatch.idl +++ b/src/cascadia/TerminalApp/ShortcutActionDispatch.idl @@ -35,10 +35,11 @@ namespace TerminalApp ToggleFocusMode, ToggleFullscreen, ToggleAlwaysOnTop, + OpenSettings, SetTabColor, OpenTabColorPicker, - OpenSettings, RenameTab, + ExecuteCommandline, ToggleCommandPalette }; @@ -84,5 +85,6 @@ namespace TerminalApp event Windows.Foundation.TypedEventHandler SetTabColor; event Windows.Foundation.TypedEventHandler OpenTabColorPicker; event Windows.Foundation.TypedEventHandler RenameTab; + event Windows.Foundation.TypedEventHandler ExecuteCommandline; } } diff --git a/src/cascadia/TerminalApp/Tab.cpp b/src/cascadia/TerminalApp/Tab.cpp index 0e9838ec69c..51e54be09ee 100644 --- a/src/cascadia/TerminalApp/Tab.cpp +++ b/src/cascadia/TerminalApp/Tab.cpp @@ -875,6 +875,10 @@ namespace winrt::TerminalApp::implementation return _rootPane->PreCalculateAutoSplit(_activePane, availableSpace).value_or(SplitState::Vertical); } + bool Tab::PreCalculateCanSplit(SplitState splitType, winrt::Windows::Foundation::Size availableSpace) const + { + return _rootPane->PreCalculateCanSplit(_activePane, splitType, availableSpace).value_or(false); + } DEFINE_EVENT(Tab, ActivePaneChanged, _ActivePaneChangedHandlers, winrt::delegate<>); DEFINE_EVENT(Tab, ColorSelected, _colorSelected, winrt::delegate); DEFINE_EVENT(Tab, ColorCleared, _colorCleared, winrt::delegate<>); diff --git a/src/cascadia/TerminalApp/Tab.h b/src/cascadia/TerminalApp/Tab.h index be76c1b7912..a6752fe6bbe 100644 --- a/src/cascadia/TerminalApp/Tab.h +++ b/src/cascadia/TerminalApp/Tab.h @@ -40,6 +40,7 @@ namespace winrt::TerminalApp::implementation float CalcSnappedDimension(const bool widthOrHeight, const float dimension) const; SplitState PreCalculateAutoSplit(winrt::Windows::Foundation::Size rootSize) const; + bool PreCalculateCanSplit(SplitState splitType, winrt::Windows::Foundation::Size availableSpace) const; void ResizeContent(const winrt::Windows::Foundation::Size& newSize); void ResizePane(const winrt::TerminalApp::Direction& direction); diff --git a/src/cascadia/TerminalApp/TerminalPage.cpp b/src/cascadia/TerminalApp/TerminalPage.cpp index 6ed6d8e9716..81cfaf1735c 100644 --- a/src/cascadia/TerminalApp/TerminalPage.cpp +++ b/src/cascadia/TerminalApp/TerminalPage.cpp @@ -46,7 +46,8 @@ namespace winrt namespace winrt::TerminalApp::implementation { TerminalPage::TerminalPage() : - _tabs{ winrt::single_threaded_observable_vector() } + _tabs{ winrt::single_threaded_observable_vector() }, + _startupActions{ winrt::single_threaded_vector() } { InitializeComponent(); } @@ -223,7 +224,7 @@ namespace winrt::TerminalApp::implementation if (_startupState == StartupState::NotInitialized) { _startupState = StartupState::InStartup; - if (_startupActions.empty()) + if (_startupActions.Size() == 0) { _OpenNewTab(nullptr); @@ -231,22 +232,27 @@ namespace winrt::TerminalApp::implementation } else { - _ProcessStartupActions(); + _ProcessStartupActions(_startupActions, true); } } } // Method Description: - // - Process all the startup actions in our list of startup actions. We'll - // do this all at once here. + // - Process all the startup actions in the provided list of startup + // actions. We'll do this all at once here. // Arguments: - // - + // - actions: a winrt vector of actions to process. Note that this must NOT + // be an IVector&, because we need the collection to be accessible on the + // other side of the co_await. + // - initial: if true, we're parsing these args during startup, and we + // should fire an Initialized event. // Return Value: // - - winrt::fire_and_forget TerminalPage::_ProcessStartupActions() + winrt::fire_and_forget TerminalPage::_ProcessStartupActions(Windows::Foundation::Collections::IVector actions, + const bool initial) { // If there are no actions left, do nothing. - if (_startupActions.empty()) + if (actions.Size() == 0) { return; } @@ -256,11 +262,20 @@ namespace winrt::TerminalApp::implementation co_await winrt::resume_foreground(Dispatcher(), CoreDispatcherPriority::Normal); if (auto page{ weakThis.get() }) { - for (const auto& action : _startupActions) + for (const auto& action : actions) { - _actionDispatch->DoAction(action); + if (auto page{ weakThis.get() }) + { + _actionDispatch->DoAction(action); + } + else + { + return; + } } - + } + if (initial) + { _CompleteInitialization(); } } @@ -857,6 +872,7 @@ namespace winrt::TerminalApp::implementation _actionDispatch->SetTabColor({ this, &TerminalPage::_HandleSetTabColor }); _actionDispatch->OpenTabColorPicker({ this, &TerminalPage::_HandleOpenTabColorPicker }); _actionDispatch->RenameTab({ this, &TerminalPage::_HandleRenameTab }); + _actionDispatch->ExecuteCommandline({ this, &TerminalPage::_HandleExecuteCommandline }); } // Method Description: @@ -1364,19 +1380,20 @@ namespace winrt::TerminalApp::implementation const auto controlConnection = _CreateConnectionFromSettings(realGuid, controlSettings); - const auto canSplit = focusedTab->CanSplitPane(splitType); + const float contentWidth = ::base::saturated_cast(_tabContent.ActualWidth()); + const float contentHeight = ::base::saturated_cast(_tabContent.ActualHeight()); + const winrt::Windows::Foundation::Size availableSpace{ contentWidth, contentHeight }; - if (!canSplit && _startupState == StartupState::Initialized) + auto realSplitType = splitType; + if (realSplitType == SplitState::Automatic) { - return; + realSplitType = focusedTab->PreCalculateAutoSplit(availableSpace); } - auto realSplitType = splitType; - if (realSplitType == SplitState::Automatic && _startupState < StartupState::Initialized) + const auto canSplit = focusedTab->PreCalculateCanSplit(realSplitType, availableSpace); + if (!canSplit) { - float contentWidth = gsl::narrow_cast(_tabContent.ActualWidth()); - float contentHeight = gsl::narrow_cast(_tabContent.ActualHeight()); - realSplitType = focusedTab->PreCalculateAutoSplit({ contentWidth, contentHeight }); + return; } TermControl newControl{ controlSettings, controlConnection }; @@ -1930,9 +1947,13 @@ namespace winrt::TerminalApp::implementation // - actions: a list of Actions to process on startup. // Return Value: // - - void TerminalPage::SetStartupActions(std::deque& actions) + void TerminalPage::SetStartupActions(std::vector& actions) { - _startupActions = actions; + // The fastest way to copy all the actions out of the std::vector and + // put them into a winrt::IVector is by making a copy, then moving the + // copy into the winrt vector ctor. + auto listCopy = actions; + _startupActions = winrt::single_threaded_vector(std::move(listCopy)); } winrt::TerminalApp::IDialogPresenter TerminalPage::DialogPresenter() const @@ -2192,6 +2213,49 @@ namespace winrt::TerminalApp::implementation // TODO GH#3327: Look at what to do with the NC area when we have XAML theming } + // Function Description: + // - This is a helper method to get the commandline out of a + // ExecuteCommandline action, break it into subcommands, and attempt to + // parse it into actions. This is used by _HandleExecuteCommandline for + // processing commandlines in the current WT window. + // Arguments: + // - args: the ExecuteCommandlineArgs to synthesize a list of startup actions for. + // Return Value: + // - an empty list if we failed to parse, otherwise a list of actions to execute. + std::vector TerminalPage::ConvertExecuteCommandlineToActions(const TerminalApp::ExecuteCommandlineArgs& args) + { + if (!args || args.Commandline().empty()) + { + return {}; + } + // Convert the commandline into an array of args with + // CommandLineToArgvW, similar to how the app typically does when + // called from the commandline. + int argc = 0; + wil::unique_any argv{ CommandLineToArgvW(args.Commandline().c_str(), &argc) }; + if (argv) + { + std::vector args; + + // Make sure the first argument is wt.exe, because ParseArgs will + // always skip the program name. The particular value of this first + // string doesn't terribly matter. + args.emplace_back(L"wt.exe"); + for (auto& elem : wil::make_range(argv.get(), argc)) + { + args.emplace_back(elem); + } + winrt::array_view argsView{ args }; + + ::TerminalApp::AppCommandlineArgs appArgs; + if (appArgs.ParseArgs(argsView) == 0) + { + return appArgs.GetStartupActions(); + } + } + return {}; + } + void TerminalPage::_CommandPaletteClosed(const IInspectable& /*sender*/, const RoutedEventArgs& /*eventArgs*/) { diff --git a/src/cascadia/TerminalApp/TerminalPage.h b/src/cascadia/TerminalApp/TerminalPage.h index 2aa717cfacd..f78cfe86f23 100644 --- a/src/cascadia/TerminalApp/TerminalPage.h +++ b/src/cascadia/TerminalApp/TerminalPage.h @@ -56,7 +56,8 @@ namespace winrt::TerminalApp::implementation bool Fullscreen() const; bool AlwaysOnTop() const; - void SetStartupActions(std::deque& actions); + void SetStartupActions(std::vector& actions); + static std::vector ConvertExecuteCommandlineToActions(const TerminalApp::ExecuteCommandlineArgs& args); winrt::TerminalApp::IDialogPresenter DialogPresenter() const; void DialogPresenter(winrt::TerminalApp::IDialogPresenter dialogPresenter); @@ -106,8 +107,8 @@ namespace winrt::TerminalApp::implementation winrt::Windows::UI::Xaml::Controls::Grid::LayoutUpdated_revoker _layoutUpdatedRevoker; StartupState _startupState{ StartupState::NotInitialized }; - std::deque _startupActions; - winrt::fire_and_forget _ProcessStartupActions(); + Windows::Foundation::Collections::IVector _startupActions; + winrt::fire_and_forget _ProcessStartupActions(Windows::Foundation::Collections::IVector actions, const bool initial); void _ShowAboutDialog(); void _ShowCloseWarningDialog(); @@ -221,6 +222,7 @@ namespace winrt::TerminalApp::implementation void _HandleSetTabColor(const IInspectable& sender, const TerminalApp::ActionEventArgs& args); void _HandleOpenTabColorPicker(const IInspectable& sender, const TerminalApp::ActionEventArgs& args); void _HandleRenameTab(const IInspectable& sender, const TerminalApp::ActionEventArgs& args); + void _HandleExecuteCommandline(const IInspectable& sender, const TerminalApp::ActionEventArgs& args); void _HandleToggleCommandPalette(const IInspectable& sender, const TerminalApp::ActionEventArgs& args); // Make sure to hook new actions up in _RegisterActionCallbacks! #pragma endregion diff --git a/src/cascadia/TerminalApp/lib/pch.h b/src/cascadia/TerminalApp/lib/pch.h index 52a51a3bd53..4cb7a49f1e3 100644 --- a/src/cascadia/TerminalApp/lib/pch.h +++ b/src/cascadia/TerminalApp/lib/pch.h @@ -29,6 +29,7 @@ #include #include #include +#include #include #include #include diff --git a/src/cascadia/TerminalControl/TermControl.cpp b/src/cascadia/TerminalControl/TermControl.cpp index 9578166b14d..8838eb5df11 100644 --- a/src/cascadia/TerminalControl/TermControl.cpp +++ b/src/cascadia/TerminalControl/TermControl.cpp @@ -17,6 +17,7 @@ using namespace ::Microsoft::Console::Types; using namespace ::Microsoft::Terminal::Core; +using namespace winrt::Windows::Graphics::Display; using namespace winrt::Windows::UI::Xaml; using namespace winrt::Windows::UI::Xaml::Input; using namespace winrt::Windows::UI::Xaml::Automation::Peers; @@ -628,7 +629,7 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation // Then, using the font, get the number of characters that can fit. // Resize our terminal connection to match that size, and initialize the terminal with that size. const auto viewInPixels = Viewport::FromDimensions({ 0, 0 }, windowSize); - THROW_IF_FAILED(dxEngine->SetWindowSize({ viewInPixels.Width(), viewInPixels.Height() })); + LOG_IF_FAILED(dxEngine->SetWindowSize({ viewInPixels.Width(), viewInPixels.Height() })); // Update DxEngine's SelectionBackground dxEngine->SetSelectionBackground(_settings.SelectionBackground()); @@ -2274,28 +2275,65 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation // as font size, scrollbar and other control scaling, etc. Make sure the // caller knows what monitor the control is about to appear on. // Return Value: - // - a point containing the requested dimensions in pixels. - winrt::Windows::Foundation::Point TermControl::GetProposedDimensions(IControlSettings const& settings, const uint32_t dpi) + // - a size containing the requested dimensions in pixels. + winrt::Windows::Foundation::Size TermControl::GetProposedDimensions(IControlSettings const& settings, const uint32_t dpi) { + // If the settings have negative or zero row or column counts, ignore those counts. + // (The lower TerminalCore layer also has upper bounds as well, but at this layer + // we may eventually impose different ones depending on how many pixels we can address.) + const auto cols = ::base::saturated_cast(std::max(settings.InitialCols(), 1)); + const auto rows = ::base::saturated_cast(std::max(settings.InitialRows(), 1)); + + const winrt::Windows::Foundation::Size initialSize{ cols, rows }; + + return GetProposedDimensions(initialSize, + settings.FontSize(), + settings.FontWeight(), + settings.FontFace(), + settings.ScrollState(), + settings.Padding(), + dpi); + } + + // Function Description: + // - Determines how much space (in pixels) an app would need to reserve to + // create a control with the settings stored in the settings param. This + // accounts for things like the font size and face, the initialRows and + // initialCols, and scrollbar visibility. The returned sized is based upon + // the provided DPI value + // Arguments: + // - initialSizeInChars: The size to get the proposed dimensions for. + // - fontHeight: The font height to use to calculate the proposed size for. + // - fontWeight: The font weight to use to calculate the proposed size for. + // - fontFace: The font name to use to calculate the proposed size for. + // - scrollState: The ScrollbarState to use to calculate the proposed size for. + // - padding: The padding to use to calculate the proposed size for. + // - dpi: The DPI we should create the terminal at. This affects things such + // as font size, scrollbar and other control scaling, etc. Make sure the + // caller knows what monitor the control is about to appear on. + // Return Value: + // - a size containing the requested dimensions in pixels. + winrt::Windows::Foundation::Size TermControl::GetProposedDimensions(const winrt::Windows::Foundation::Size& initialSizeInChars, + const int32_t& fontHeight, + const winrt::Windows::UI::Text::FontWeight& fontWeight, + const winrt::hstring& fontFace, + const Microsoft::Terminal::Settings::ScrollbarState& scrollState, + const winrt::hstring& padding, + const uint32_t dpi) + { + const auto cols = ::base::saturated_cast(initialSizeInChars.Width); + const auto rows = ::base::saturated_cast(initialSizeInChars.Height); + // Initialize our font information. - const auto fontFace = settings.FontFace(); - const short fontHeight = gsl::narrow_cast(settings.FontSize()); - const auto fontWeight = settings.FontWeight(); // The font width doesn't terribly matter, we'll only be using the // height to look it up // The other params here also largely don't matter. // The family is only used to determine if the font is truetype or // not, but DX doesn't use that info at all. // The Codepage is additionally not actually used by the DX engine at all. - FontInfo actualFont = { fontFace, 0, fontWeight.Weight, { 0, fontHeight }, CP_UTF8, false }; + FontInfo actualFont = { fontFace, 0, fontWeight.Weight, { 0, gsl::narrow_cast(fontHeight) }, CP_UTF8, false }; FontInfoDesired desiredFont = { actualFont }; - // If the settings have negative or zero row or column counts, ignore those counts. - // (The lower TerminalCore layer also has upper bounds as well, but at this layer - // we may eventually impose different ones depending on how many pixels we can address.) - const auto cols = std::max(settings.InitialCols(), 1); - const auto rows = std::max(settings.InitialRows(), 1); - // Create a DX engine and initialize it with our font and DPI. We'll // then use it to measure how much space the requested rows and columns // will take up. @@ -2315,13 +2353,13 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation double width = cols * fontSize.X; // Reserve additional space if scrollbar is intended to be visible - if (settings.ScrollState() == ScrollbarState::Visible) + if (scrollState == ScrollbarState::Visible) { width += scrollbarSize; } double height = rows * fontSize.Y; - auto thickness = _ParseThicknessFromPadding(settings.Padding()); + auto thickness = _ParseThicknessFromPadding(padding); // GH#2061 - make sure to account for the size the padding _will be_ scaled to width += scale * (thickness.Left + thickness.Right); height += scale * (thickness.Top + thickness.Bottom); @@ -2354,21 +2392,41 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation // have a visible character. winrt::Windows::Foundation::Size TermControl::MinimumSize() { - const auto fontSize = _actualFont.GetSize(); - double width = fontSize.X; - double height = fontSize.Y; - // Reserve additional space if scrollbar is intended to be visible - if (_settings.ScrollState() == ScrollbarState::Visible) + if (_initializedTerminal) { - width += ScrollBar().ActualWidth(); - } + const auto fontSize = _actualFont.GetSize(); + double width = fontSize.X; + double height = fontSize.Y; + // Reserve additional space if scrollbar is intended to be visible + if (_settings.ScrollState() == ScrollbarState::Visible) + { + width += ScrollBar().ActualWidth(); + } - // Account for the size of any padding - const auto padding = GetPadding(); - width += padding.Left + padding.Right; - height += padding.Top + padding.Bottom; + // Account for the size of any padding + const auto padding = GetPadding(); + width += padding.Left + padding.Right; + height += padding.Top + padding.Bottom; - return { gsl::narrow_cast(width), gsl::narrow_cast(height) }; + return { gsl::narrow_cast(width), gsl::narrow_cast(height) }; + } + else + { + // If the terminal hasn't been initialized yet, then the font size will + // have dimensions {1, fontSize.Y}, which can mess with consumers of + // this method. In that case, we'll need to pre-calculate the font + // width, before we actually have a renderer or swapchain. + const winrt::Windows::Foundation::Size minSize{ 1, 1 }; + const double scaleFactor = DisplayInformation::GetForCurrentView().RawPixelsPerViewPixel(); + const auto dpi = ::base::saturated_cast(USER_DEFAULT_SCREEN_DPI * scaleFactor); + return GetProposedDimensions(minSize, + _settings.FontSize(), + _settings.FontWeight(), + _settings.FontFace(), + _settings.ScrollState(), + _settings.Padding(), + dpi); + } } // Method Description: diff --git a/src/cascadia/TerminalControl/TermControl.h b/src/cascadia/TerminalControl/TermControl.h index 3879c4b3835..783ca85d967 100644 --- a/src/cascadia/TerminalControl/TermControl.h +++ b/src/cascadia/TerminalControl/TermControl.h @@ -100,7 +100,14 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation TerminalConnection::ConnectionState ConnectionState() const; - static Windows::Foundation::Point GetProposedDimensions(Microsoft::Terminal::Settings::IControlSettings const& settings, const uint32_t dpi); + static Windows::Foundation::Size GetProposedDimensions(Microsoft::Terminal::Settings::IControlSettings const& settings, const uint32_t dpi); + static Windows::Foundation::Size GetProposedDimensions(const winrt::Windows::Foundation::Size& initialSizeInChars, + const int32_t& fontSize, + const winrt::Windows::UI::Text::FontWeight& fontWeight, + const winrt::hstring& fontFace, + const Microsoft::Terminal::Settings::ScrollbarState& scrollState, + const winrt::hstring& padding, + const uint32_t dpi); // clang-format off // -------------------------------- WinRT Events --------------------------------- diff --git a/src/cascadia/TerminalControl/TermControl.idl b/src/cascadia/TerminalControl/TermControl.idl index 0d99a87b530..d5454e50578 100644 --- a/src/cascadia/TerminalControl/TermControl.idl +++ b/src/cascadia/TerminalControl/TermControl.idl @@ -35,7 +35,7 @@ namespace Microsoft.Terminal.TerminalControl TermControl(); TermControl(Microsoft.Terminal.Settings.IControlSettings settings, Microsoft.Terminal.TerminalConnection.ITerminalConnection connection); - static Windows.Foundation.Point GetProposedDimensions(Microsoft.Terminal.Settings.IControlSettings settings, UInt32 dpi); + static Windows.Foundation.Size GetProposedDimensions(Microsoft.Terminal.Settings.IControlSettings settings, UInt32 dpi); void UpdateSettings(Microsoft.Terminal.Settings.IControlSettings newSettings); diff --git a/src/cascadia/WindowsTerminal/AppHost.cpp b/src/cascadia/WindowsTerminal/AppHost.cpp index b2c3c32a3b5..36ec74db1a7 100644 --- a/src/cascadia/WindowsTerminal/AppHost.cpp +++ b/src/cascadia/WindowsTerminal/AppHost.cpp @@ -286,9 +286,9 @@ void AppHost::_HandleCreateWindow(const HWND hwnd, RECT proposedRect, winrt::Ter auto initialSize = _logic.GetLaunchDimensions(dpix); const short islandWidth = Utils::ClampToShortMax( - static_cast(ceil(initialSize.X)), 1); + static_cast(ceil(initialSize.Width)), 1); const short islandHeight = Utils::ClampToShortMax( - static_cast(ceil(initialSize.Y)), 1); + static_cast(ceil(initialSize.Height)), 1); // Get the size of a window we'd need to host that client rect. This will // add the titlebar space. From 04f5ee7ebf6da648f16cbc592829b0420e93662b Mon Sep 17 00:00:00 2001 From: "Dustin L. Howett" Date: Mon, 20 Jul 2020 13:50:50 -0700 Subject: [PATCH 16/33] Swap brightBlack/black in the Solarized color schemes (#6985) Original notes from @M-Pixel: > Console applications assume that backgrounds are black, and that > `lightBlack`/`DarkGrey` are lighter than `black`/`Black`. This > assumption is accounted for by all color schemes in `defaults.json`, > except for the Solarized themes. > > The Solarized Dark theme, in particular, makes `-Parameters` invisible > against the background in PowerShell, which is obviously an unacceptable > usability flaw. > > This change makes `black` and `background` to the same (which is common > throughout the color schemes), and makes `brightBlack` (`DarkGray` in > .NET) lighter than black (which is obviously more correct given the > meanings of those words). Out of the box, we ship a pretty bad behavior. If I look at all of the existing shipped color schemes--and that includes things like Tango and One Half--we are universally following a `background` == `black` rule. If I consult gnome-terminal or xterm, they do the same thing; Xterm by default, gnome-terminal for solarized. The background generally matches color index `0` across all their **dark** schemes. Konsole and lxterminal disagree and map background to `0 intense` for Solarized. I want to put our Solarized schemes on a deprecation path, but unfortunately we still need to ship _something_ for users who we're going to strand on them. I'm going to have to swallow my bitter and say that yes, we should probably just change the index mapping and go with something that works right out of the box while we figure out how to do perceptual color nudging and eventually remove bad defaults (like Solarized). From #6618. Fixes #4047. Closes #6618. --- src/cascadia/TerminalApp/defaults.json | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/cascadia/TerminalApp/defaults.json b/src/cascadia/TerminalApp/defaults.json index b4167968f79..a05668723f8 100644 --- a/src/cascadia/TerminalApp/defaults.json +++ b/src/cascadia/TerminalApp/defaults.json @@ -187,7 +187,7 @@ "foreground": "#839496", "background": "#002B36", "cursorColor": "#FFFFFF", - "black": "#073642", + "black": "#002B36", "red": "#DC322F", "green": "#859900", "yellow": "#B58900", @@ -195,7 +195,7 @@ "purple": "#D33682", "cyan": "#2AA198", "white": "#EEE8D5", - "brightBlack": "#002B36", + "brightBlack": "#073642", "brightRed": "#CB4B16", "brightGreen": "#586E75", "brightYellow": "#657B83", @@ -209,7 +209,7 @@ "foreground": "#657B83", "background": "#FDF6E3", "cursorColor": "#002B36", - "black": "#073642", + "black": "#002B36", "red": "#DC322F", "green": "#859900", "yellow": "#B58900", @@ -217,7 +217,7 @@ "purple": "#D33682", "cyan": "#2AA198", "white": "#EEE8D5", - "brightBlack": "#002B36", + "brightBlack": "#073642", "brightRed": "#CB4B16", "brightGreen": "#586E75", "brightYellow": "#657B83", From c390b6164871b59bc1520dd7838889c45a569dec Mon Sep 17 00:00:00 2001 From: Carlos Zamora Date: Mon, 20 Jul 2020 16:10:55 -0700 Subject: [PATCH 17/33] UIA: use full buffer comparison in rects and endpoint setter (#6447) In UiaTextRange, `_getBufferSize` returns an optimized version of the size of the buffer to be the origin and the last character in the buffer. This is to improve performance on search or checking if you are currently on the last word/line. When setting the endpoint and drawing the bounding rectangles, we should be retrieving the true buffer size. This is because it is still possible to create UiaTextRanges that are outside of this optimized size. The main source of this is `ExpandToEnclosingUnit()` when the unit is `Document`. The end _should_ be the last visible character, but it isn't because that would break our tests. This is an incomplete solution. #6986 is a follow up to completely test and implement the solution. The crash in #6402 was caused by getting the document range (a range of the full text buffer), then moving the end by one character. When we get the document range, we get the optimized size of the buffer (the position of the last character). Moving by one character is valid because the buffer still has more to explore. We then crash from checking if the new position is valid on the **optimized size**, not the **real size**. REFERENCES #6986 - follow up to properly handle/test this "end of buffer" problem Closes #6402 --- src/types/UiaTextRangeBase.cpp | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/types/UiaTextRangeBase.cpp b/src/types/UiaTextRangeBase.cpp index 3245620e369..7d12fb42762 100644 --- a/src/types/UiaTextRangeBase.cpp +++ b/src/types/UiaTextRangeBase.cpp @@ -145,7 +145,9 @@ const COORD UiaTextRangeBase::GetEndpoint(TextPatternRangeEndpoint endpoint) con // - true if range is degenerate, false otherwise. bool UiaTextRangeBase::SetEndpoint(TextPatternRangeEndpoint endpoint, const COORD val) noexcept { - const auto bufferSize = _getBufferSize(); + // GH#6402: Get the actual buffer size here, instead of the one + // constrained by the virtual bottom. + const auto bufferSize = _pData->GetTextBuffer().GetSize(); switch (endpoint) { case TextPatternRangeEndpoint_End: @@ -284,6 +286,8 @@ IFACEMETHODIMP UiaTextRangeBase::ExpandToEnclosingUnit(_In_ TextUnit unit) noexc } else { + // TODO GH#6986: properly handle "end of buffer" as last character + // instead of last cell // expand to document _start = bufferSize.Origin(); _end = bufferSize.EndExclusive(); @@ -393,7 +397,9 @@ IFACEMETHODIMP UiaTextRangeBase::GetBoundingRectangles(_Outptr_result_maybenull_ // set of coords. std::vector coords; - const auto bufferSize = _getBufferSize(); + // GH#6402: Get the actual buffer size here, instead of the one + // constrained by the virtual bottom. + const auto bufferSize = _pData->GetTextBuffer().GetSize(); // these viewport vars are converted to the buffer coordinate space const auto viewport = bufferSize.ConvertToOrigin(_pData->GetViewport()); From 76de2aedc2d805481ae323bba6f34cb41878a461 Mon Sep 17 00:00:00 2001 From: "Dustin L. Howett" Date: Mon, 20 Jul 2020 16:13:20 -0700 Subject: [PATCH 18/33] wpf: fix a handful of issues with the wpf control (#6983) * send alt/F10 through the control We were not listening for WM_SYSKEY{UP,DOWN} * extract the actual scancode during WM_CHAR, not the bitfield We were accidentally sending some of the additional keypress data in with the character event in Win32 Input Mode * set default fg/bg to campbell The WPF control starts up in PowerShell blue even though it's not typically used in PowerShell blue. * don't rely on the font to determine wideness This is a cross-port of #2928 to the WPF control * deterministic shutdown In testing, I saw a handful of crashes on teardown because we were not shutting down the render thread properly. * don't pass 10 for the font weight ... When Cascadia Code is set, it just looks silly. * trigger render when selection is cleared, do it under lock Fixes #6966. --- .../PublicTerminalCore/HwndTerminal.cpp | 94 ++++++++++++++++--- .../PublicTerminalCore/HwndTerminal.hpp | 5 +- .../WpfTerminalControl/NativeMethods.cs | 10 ++ .../WpfTerminalControl/TerminalContainer.cs | 12 ++- 4 files changed, 102 insertions(+), 19 deletions(-) diff --git a/src/cascadia/PublicTerminalCore/HwndTerminal.cpp b/src/cascadia/PublicTerminalCore/HwndTerminal.cpp index d5a151f3bf4..16e41fef05f 100644 --- a/src/cascadia/PublicTerminalCore/HwndTerminal.cpp +++ b/src/cascadia/PublicTerminalCore/HwndTerminal.cpp @@ -24,6 +24,25 @@ static constexpr bool _IsMouseMessage(UINT uMsg) uMsg == WM_MOUSEMOVE || uMsg == WM_MOUSEWHEEL; } +// Helper static function to ensure that all ambiguous-width glyphs are reported as narrow. +// See microsoft/terminal#2066 for more info. +static bool _IsGlyphWideForceNarrowFallback(const std::wstring_view /* glyph */) noexcept +{ + return false; // glyph is not wide. +} + +static bool _EnsureStaticInitialization() +{ + // use C++11 magic statics to make sure we only do this once. + static bool initialized = []() { + // *** THIS IS A SINGLETON *** + SetGlyphWidthFallback(_IsGlyphWideForceNarrowFallback); + + return true; + }(); + return initialized; +} + LRESULT CALLBACK HwndTerminal::HwndTerminalWndProc( HWND hwnd, UINT uMsg, @@ -72,7 +91,7 @@ try { const auto bufferData = terminal->_terminal->RetrieveSelectedTextFromBuffer(false); LOG_IF_FAILED(terminal->_CopyTextToSystemClipboard(bufferData, true)); - terminal->_terminal->ClearSelection(); + TerminalClearSelection(terminal); } CATCH_LOG(); } @@ -81,6 +100,11 @@ try terminal->_PasteTextFromClipboard(); } return 0; + case WM_DESTROY: + // Release Terminal's hwnd so Teardown doesn't try to destroy it again + terminal->_hwnd.release(); + terminal->Teardown(); + return 0; } } return DefWindowProc(hwnd, uMsg, wParam, lParam); @@ -114,14 +138,16 @@ static bool RegisterTermClass(HINSTANCE hInstance) noexcept } HwndTerminal::HwndTerminal(HWND parentHwnd) : - _desiredFont{ L"Consolas", 0, 10, { 0, 14 }, CP_UTF8 }, - _actualFont{ L"Consolas", 0, 10, { 0, 14 }, CP_UTF8, false }, + _desiredFont{ L"Consolas", 0, DEFAULT_FONT_WEIGHT, { 0, 14 }, CP_UTF8 }, + _actualFont{ L"Consolas", 0, DEFAULT_FONT_WEIGHT, { 0, 14 }, CP_UTF8, false }, _uiaProvider{ nullptr }, _uiaProviderInitialized{ false }, _currentDpi{ USER_DEFAULT_SCREEN_DPI }, _pfnWriteCallback{ nullptr }, _multiClickTime{ 500 } // this will be overwritten by the windows system double-click time { + _EnsureStaticInitialization(); + HINSTANCE hInstance = wil::GetModuleInstanceHandle(); if (RegisterTermClass(hInstance)) @@ -148,6 +174,11 @@ HwndTerminal::HwndTerminal(HWND parentHwnd) : } } +HwndTerminal::~HwndTerminal() +{ + Teardown(); +} + HRESULT HwndTerminal::Initialize() { _terminal = std::make_unique<::Microsoft::Terminal::Core::Terminal>(); @@ -162,9 +193,6 @@ HRESULT HwndTerminal::Initialize() RETURN_IF_FAILED(dxEngine->Enable()); _renderer->AddRenderEngine(dxEngine.get()); - const auto pfn = std::bind(&::Microsoft::Console::Render::Renderer::IsGlyphWideByFont, _renderer.get(), std::placeholders::_1); - SetGlyphWidthFallback(pfn); - _UpdateFont(USER_DEFAULT_SCREEN_DPI); RECT windowRect; GetWindowRect(_hwnd.get(), &windowRect); @@ -181,8 +209,8 @@ HRESULT HwndTerminal::Initialize() _terminal->SetBackgroundCallback([](auto) {}); _terminal->Create(COORD{ 80, 25 }, 1000, *_renderer); - _terminal->SetDefaultBackground(RGB(5, 27, 80)); - _terminal->SetDefaultForeground(RGB(255, 255, 255)); + _terminal->SetDefaultBackground(RGB(12, 12, 12)); + _terminal->SetDefaultForeground(RGB(204, 204, 204)); _terminal->SetWriteInputCallback([=](std::wstring & input) noexcept { _WriteTextToConnection(input); }); localPointerToThread->EnablePainting(); @@ -191,6 +219,33 @@ HRESULT HwndTerminal::Initialize() return S_OK; } +void HwndTerminal::Teardown() noexcept +try +{ + // As a rule, detach resources from the Terminal before shutting them down. + // This ensures that teardown is reentrant. + + // Shut down the renderer (and therefore the thread) before we implode + if (auto localRenderEngine{ std::exchange(_renderEngine, nullptr) }) + { + if (auto localRenderer{ std::exchange(_renderer, nullptr) }) + { + localRenderer->TriggerTeardown(); + // renderer is destroyed + } + // renderEngine is destroyed + } + + if (auto localHwnd{ _hwnd.release() }) + { + // If we're being called through WM_DESTROY, we won't get here (hwnd is already released) + // If we're not, we may end up in Teardown _again_... but by the time we do, all other + // resources have been released and will not be released again. + DestroyWindow(localHwnd); + } +} +CATCH_LOG(); + void HwndTerminal::RegisterScrollCallback(std::function callback) { _terminal->SetScrollPositionChangedCallback(callback); @@ -467,11 +522,21 @@ try } CATCH_RETURN(); +void HwndTerminal::_ClearSelection() noexcept +try +{ + auto lock{ _terminal->LockForWriting() }; + _terminal->ClearSelection(); + _renderer->TriggerSelection(); +} +CATCH_LOG(); + void _stdcall TerminalClearSelection(void* terminal) { - const auto publicTerminal = static_cast(terminal); - publicTerminal->_terminal->ClearSelection(); + auto publicTerminal = static_cast(terminal); + publicTerminal->_ClearSelection(); } + bool _stdcall TerminalIsSelectionActive(void* terminal) { const auto publicTerminal = static_cast(terminal); @@ -482,9 +547,10 @@ bool _stdcall TerminalIsSelectionActive(void* terminal) // Returns the selected text in the terminal. const wchar_t* _stdcall TerminalGetSelection(void* terminal) { - const auto publicTerminal = static_cast(terminal); + auto publicTerminal = static_cast(terminal); const auto bufferData = publicTerminal->_terminal->RetrieveSelectedTextFromBuffer(false); + publicTerminal->_ClearSelection(); // convert text: vector --> string std::wstring selectedText; @@ -494,8 +560,6 @@ const wchar_t* _stdcall TerminalGetSelection(void* terminal) } auto returnText = wil::make_cotaskmem_string_nothrow(selectedText.c_str()); - TerminalClearSelection(terminal); - return returnText.release(); } @@ -574,7 +638,7 @@ try { if (_terminal->IsSelectionActive()) { - _terminal->ClearSelection(); + _ClearSelection(); if (ch == UNICODE_ESC) { // ESC should clear any selection before it triggers input. @@ -632,7 +696,7 @@ void _stdcall TerminalSetTheme(void* terminal, TerminalTheme theme, LPCWSTR font publicTerminal->_terminal->SetCursorStyle(theme.CursorStyle); - publicTerminal->_desiredFont = { fontFamily, 0, 10, { 0, fontSize }, CP_UTF8 }; + publicTerminal->_desiredFont = { fontFamily, 0, DEFAULT_FONT_WEIGHT, { 0, fontSize }, CP_UTF8 }; publicTerminal->_UpdateFont(newDpi); // When the font changes the terminal dimensions need to be recalculated since the available row and column diff --git a/src/cascadia/PublicTerminalCore/HwndTerminal.hpp b/src/cascadia/PublicTerminalCore/HwndTerminal.hpp index 90b4cc50ac8..f904f526cad 100644 --- a/src/cascadia/PublicTerminalCore/HwndTerminal.hpp +++ b/src/cascadia/PublicTerminalCore/HwndTerminal.hpp @@ -51,9 +51,10 @@ struct HwndTerminal : ::Microsoft::Console::Types::IControlAccessibilityInfo HwndTerminal(HwndTerminal&&) = default; HwndTerminal& operator=(const HwndTerminal&) = default; HwndTerminal& operator=(HwndTerminal&&) = default; - ~HwndTerminal() = default; + ~HwndTerminal(); HRESULT Initialize(); + void Teardown() noexcept; void SendOutput(std::wstring_view data); HRESULT Refresh(const SIZE windowSize, _Out_ COORD* dimensions); void RegisterScrollCallback(std::function callback); @@ -112,6 +113,8 @@ struct HwndTerminal : ::Microsoft::Console::Types::IControlAccessibilityInfo HRESULT _MoveSelection(LPARAM lParam) noexcept; IRawElementProviderSimple* _GetUiaProvider() noexcept; + void _ClearSelection() noexcept; + bool _CanSendVTMouseInput() const noexcept; bool _SendMouseEvent(UINT uMsg, WPARAM wParam, LPARAM lParam) noexcept; diff --git a/src/cascadia/WpfTerminalControl/NativeMethods.cs b/src/cascadia/WpfTerminalControl/NativeMethods.cs index 98ea4790c29..3ba2a78f094 100644 --- a/src/cascadia/WpfTerminalControl/NativeMethods.cs +++ b/src/cascadia/WpfTerminalControl/NativeMethods.cs @@ -62,6 +62,16 @@ public enum WindowMessage : int /// WM_CHAR = 0x0102, + ///

+ /// The WM_SYSKEYDOWN message is posted to the window with the keyboard focus when a system key is pressed. A system key is F10 or Alt+Something. + /// + WM_SYSKEYDOWN = 0x0104, + + /// + /// The WM_SYSKEYDOWN message is posted to the window with the keyboard focus when a system key is released. A system key is F10 or Alt+Something. + /// + WM_SYSKEYUP = 0x0105, + /// /// The WM_MOUSEMOVE message is posted to a window when the cursor moves. If the mouse is not captured, the message is posted to the window that contains the cursor. Otherwise, the message is posted to the window that has captured the mouse. /// diff --git a/src/cascadia/WpfTerminalControl/TerminalContainer.cs b/src/cascadia/WpfTerminalControl/TerminalContainer.cs index e7938bb2611..cf1db1d4019 100644 --- a/src/cascadia/WpfTerminalControl/TerminalContainer.cs +++ b/src/cascadia/WpfTerminalControl/TerminalContainer.cs @@ -235,6 +235,7 @@ private IntPtr TerminalContainer_MessageHook(IntPtr hwnd, int msg, IntPtr wParam this.Focus(); NativeMethods.SetFocus(this.hwnd); break; + case NativeMethods.WindowMessage.WM_SYSKEYDOWN: // fallthrough case NativeMethods.WindowMessage.WM_KEYDOWN: { // WM_KEYDOWN lParam layout documentation: https://docs.microsoft.com/en-us/windows/win32/inputdev/wm-keydown @@ -246,6 +247,7 @@ private IntPtr TerminalContainer_MessageHook(IntPtr hwnd, int msg, IntPtr wParam break; } + case NativeMethods.WindowMessage.WM_SYSKEYUP: // fallthrough case NativeMethods.WindowMessage.WM_KEYUP: { // WM_KEYUP lParam layout documentation: https://docs.microsoft.com/en-us/windows/win32/inputdev/wm-keyup @@ -255,9 +257,13 @@ private IntPtr TerminalContainer_MessageHook(IntPtr hwnd, int msg, IntPtr wParam } case NativeMethods.WindowMessage.WM_CHAR: - // WM_CHAR lParam layout documentation: https://docs.microsoft.com/en-us/windows/win32/inputdev/wm-char - NativeMethods.TerminalSendCharEvent(this.terminal, (char)wParam, (ushort)((uint)lParam >> 16)); - break; + { + // WM_CHAR lParam layout documentation: https://docs.microsoft.com/en-us/windows/win32/inputdev/wm-char + ulong scanCode = (((ulong)lParam) & 0x00FF0000) >> 16; + NativeMethods.TerminalSendCharEvent(this.terminal, (char)wParam, (ushort)scanCode); + break; + } + case NativeMethods.WindowMessage.WM_WINDOWPOSCHANGED: var windowpos = (NativeMethods.WINDOWPOS)Marshal.PtrToStructure(lParam, typeof(NativeMethods.WINDOWPOS)); if (((NativeMethods.SetWindowPosFlags)windowpos.flags).HasFlag(NativeMethods.SetWindowPosFlags.SWP_NOSIZE)) From f486a6504c060af3f505a79259dec41a4e17b78c Mon Sep 17 00:00:00 2001 From: Javier Date: Thu, 30 Jul 2020 11:55:07 -0500 Subject: [PATCH 19/33] Expose text selection through terminal WPF control API (#7121) We've been trying to improve the copy/paste experience with the terminal in Visual Studio. Once of our problematic scenarios is when the terminal is connected to a remote environment and the user attempts to copy/paste. This gets forwarded to the remote shell that copy/paste into the remote clipboard instead of the local one. So we opted to add ctrl+shift+c/v to the terminal and need access to the selected text via the terminal control VALIDATION Tested with Visual Studio integrated terminal --- .../WpfTerminalControl/TerminalContainer.cs | 14 ++++++++++++++ .../WpfTerminalControl/TerminalControl.xaml.cs | 9 +++++++++ 2 files changed, 23 insertions(+) diff --git a/src/cascadia/WpfTerminalControl/TerminalContainer.cs b/src/cascadia/WpfTerminalControl/TerminalContainer.cs index cf1db1d4019..86549a9e05c 100644 --- a/src/cascadia/WpfTerminalControl/TerminalContainer.cs +++ b/src/cascadia/WpfTerminalControl/TerminalContainer.cs @@ -124,6 +124,20 @@ internal void SetTheme(TerminalTheme theme, string fontFamily, short fontSize) this.TriggerResize(this.RenderSize); } + /// + /// Gets the selected text from the terminal renderer and clears the selection. + /// + /// The selected text, empty if no text is selected. + internal string GetSelectedText() + { + if (NativeMethods.TerminalIsSelectionActive(this.terminal)) + { + return NativeMethods.TerminalGetSelection(this.terminal); + } + + return string.Empty; + } + /// /// Triggers a refresh of the terminal with the given size. /// diff --git a/src/cascadia/WpfTerminalControl/TerminalControl.xaml.cs b/src/cascadia/WpfTerminalControl/TerminalControl.xaml.cs index f068d0edfd3..ef8f6b30ae0 100644 --- a/src/cascadia/WpfTerminalControl/TerminalControl.xaml.cs +++ b/src/cascadia/WpfTerminalControl/TerminalControl.xaml.cs @@ -70,6 +70,15 @@ public void SetTheme(TerminalTheme theme, string fontFamily, short fontSize) this.termContainer.SetTheme(theme, fontFamily, fontSize); } + /// + /// Gets the selected text in the terminal, clearing the selection. Otherwise returns an empty string. + /// + /// Selected text, empty string if no content is selected. + public string GetSelectedText() + { + return this.termContainer.GetSelectedText(); + } + /// /// Resizes the terminal to the specified rows and columns. /// From bf90869f300791fce98f39287bedecbfbec8a3ab Mon Sep 17 00:00:00 2001 From: PankajBhojwani Date: Thu, 30 Jul 2020 14:58:28 -0400 Subject: [PATCH 20/33] Fixed window title not updating with tab rename (#7119) * Fixed window title not updating with tab rename * pass the correct title to event handler instead --- src/cascadia/TerminalApp/TerminalPage.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cascadia/TerminalApp/TerminalPage.cpp b/src/cascadia/TerminalApp/TerminalPage.cpp index 81cfaf1735c..8fc907ca89f 100644 --- a/src/cascadia/TerminalApp/TerminalPage.cpp +++ b/src/cascadia/TerminalApp/TerminalPage.cpp @@ -1795,7 +1795,7 @@ namespace winrt::TerminalApp::implementation tab->SetFocused(true); // Raise an event that our title changed - _titleChangeHandlers(*this, Title()); + _titleChangeHandlers(*this, tab->GetActiveTitle()); // Raise an event that our titlebar color changed std::optional color = tab->GetTabColor(); From 2f5ba9471da3580db86c41555bd5f63bdeedaabf Mon Sep 17 00:00:00 2001 From: PankajBhojwani Date: Thu, 30 Jul 2020 18:24:59 -0400 Subject: [PATCH 21/33] Implement SetCursorColor in Terminal (#7123) This was never hooked up to the TerminalCore implementation. Closes #7102 --- src/cascadia/TerminalCore/ITerminalApi.hpp | 1 + src/cascadia/TerminalCore/Terminal.hpp | 1 + src/cascadia/TerminalCore/TerminalApi.cpp | 8 ++++++++ src/cascadia/TerminalCore/TerminalDispatch.cpp | 7 +++++++ src/cascadia/TerminalCore/TerminalDispatch.hpp | 1 + 5 files changed, 18 insertions(+) diff --git a/src/cascadia/TerminalCore/ITerminalApi.hpp b/src/cascadia/TerminalCore/ITerminalApi.hpp index d92a536c9d6..98945de1cfe 100644 --- a/src/cascadia/TerminalCore/ITerminalApi.hpp +++ b/src/cascadia/TerminalCore/ITerminalApi.hpp @@ -39,6 +39,7 @@ namespace Microsoft::Terminal::Core virtual bool SetColorTableEntry(const size_t tableIndex, const DWORD color) noexcept = 0; virtual bool SetCursorStyle(const ::Microsoft::Console::VirtualTerminal::DispatchTypes::CursorStyle cursorStyle) noexcept = 0; + virtual bool SetCursorColor(const DWORD color) noexcept = 0; virtual bool SetDefaultForeground(const DWORD color) noexcept = 0; virtual bool SetDefaultBackground(const DWORD color) noexcept = 0; diff --git a/src/cascadia/TerminalCore/Terminal.hpp b/src/cascadia/TerminalCore/Terminal.hpp index 64232ef963d..ac8d59d3e02 100644 --- a/src/cascadia/TerminalCore/Terminal.hpp +++ b/src/cascadia/TerminalCore/Terminal.hpp @@ -93,6 +93,7 @@ class Microsoft::Terminal::Core::Terminal final : bool SetWindowTitle(std::wstring_view title) noexcept override; bool SetColorTableEntry(const size_t tableIndex, const COLORREF color) noexcept override; bool SetCursorStyle(const ::Microsoft::Console::VirtualTerminal::DispatchTypes::CursorStyle cursorStyle) noexcept override; + bool SetCursorColor(const COLORREF color) noexcept override; bool SetDefaultForeground(const COLORREF color) noexcept override; bool SetDefaultBackground(const COLORREF color) noexcept override; diff --git a/src/cascadia/TerminalCore/TerminalApi.cpp b/src/cascadia/TerminalCore/TerminalApi.cpp index 4c7f27a88ea..1e27a59702c 100644 --- a/src/cascadia/TerminalCore/TerminalApi.cpp +++ b/src/cascadia/TerminalCore/TerminalApi.cpp @@ -64,6 +64,14 @@ COORD Terminal::GetCursorPosition() noexcept return newPos; } +bool Terminal::SetCursorColor(const COLORREF color) noexcept +try +{ + _buffer->GetCursor().SetColor(color); + return true; +} +CATCH_LOG_RETURN_FALSE() + // Method Description: // - Moves the cursor down one line, and possibly also to the leftmost column. // Arguments: diff --git a/src/cascadia/TerminalCore/TerminalDispatch.cpp b/src/cascadia/TerminalCore/TerminalDispatch.cpp index cf79384f70c..f119cc266c7 100644 --- a/src/cascadia/TerminalCore/TerminalDispatch.cpp +++ b/src/cascadia/TerminalCore/TerminalDispatch.cpp @@ -146,6 +146,13 @@ try } CATCH_LOG_RETURN_FALSE() +bool TerminalDispatch::SetCursorColor(const DWORD color) noexcept +try +{ + return _terminalApi.SetCursorColor(color); +} +CATCH_LOG_RETURN_FALSE() + bool TerminalDispatch::SetClipboard(std::wstring_view content) noexcept try { diff --git a/src/cascadia/TerminalCore/TerminalDispatch.hpp b/src/cascadia/TerminalCore/TerminalDispatch.hpp index 640f8eb242f..4f3dc8e7371 100644 --- a/src/cascadia/TerminalCore/TerminalDispatch.hpp +++ b/src/cascadia/TerminalCore/TerminalDispatch.hpp @@ -35,6 +35,7 @@ class TerminalDispatch : public Microsoft::Console::VirtualTerminal::TermDispatc bool SetColorTableEntry(const size_t tableIndex, const DWORD color) noexcept override; bool SetCursorStyle(const ::Microsoft::Console::VirtualTerminal::DispatchTypes::CursorStyle cursorStyle) noexcept override; + bool SetCursorColor(const DWORD color) noexcept override; bool SetClipboard(std::wstring_view content) noexcept override; From 6ee8099a2c92b99b87d5062e06835a9b3d75f183 Mon Sep 17 00:00:00 2001 From: James Holderness Date: Thu, 30 Jul 2020 23:43:37 +0100 Subject: [PATCH 22/33] Refactor grid line renderers with support for more line types (#7107) This is a refactoring of the grid line renderers, adjusting the line widths to scale with the font size, and optimising the implementation to cut down on the number of draw calls. It also extends the supported grid line types to include true underlines and strike-through lines in the style of the active font. The main gist of the optimisation was to render the horizontal lines with a single draw call, instead of a loop with lots of little strokes joined together. In the case of the vertical lines, which still needed to be handled in a loop, I've tried to move the majority of static calculations outside the loop, so there is bit of optimisation there too. At the same time this code was updated to support a variable stroke width for the lines, instead of having them hardcoded to 1 pixel. The width is now calculated as a fraction of the font size (0.025 "em"), which is still going to be 1 pixel wide in most typical usage, but will scale up appropriately if you zoom in far enough. And in preparation for supporting the SGR strike-through attribute, and true underlines, I've extended the grid line renders with options for handling those line types as well. The offset and thickness of the lines is obtained from the font metrics (rounded to a pixel width, with a minimum of one pixel), so they match the style of the font. VALIDATION For now we're still only rendering grid lines, and only the top and bottom lines in the case of the DirectX renderer in Windows Terminal. So to test, I hacked in some code to force the renderer to use all the different options, confirming that they were working in both the GDI and DirectX renderers. I've tested the output with a number of different fonts, comparing it with the same text rendered in WordPad. For the most part they match exactly, but there can be slight differences when we adjust the font size for grid alignment. And in the case of the GDI renderer, where we're working with pixel heights rather than points, it's difficult to match the sizes exactly. This is a first step towards supporting the strike-through attribute (#6205) and true underlines (#2915). Closes #6911 --- .../actions/spell-check/dictionary/apis.txt | 3 + src/renderer/dx/DxRenderer.cpp | 135 ++++++++++++------ src/renderer/dx/DxRenderer.hpp | 13 +- src/renderer/gdi/gdirenderer.hpp | 10 ++ src/renderer/gdi/paint.cpp | 64 ++++++--- src/renderer/gdi/state.cpp | 37 +++++ src/renderer/inc/IRenderEngine.hpp | 4 +- 7 files changed, 200 insertions(+), 66 deletions(-) diff --git a/.github/actions/spell-check/dictionary/apis.txt b/.github/actions/spell-check/dictionary/apis.txt index 298b869c186..1e33da10d7e 100644 --- a/.github/actions/spell-check/dictionary/apis.txt +++ b/.github/actions/spell-check/dictionary/apis.txt @@ -23,6 +23,7 @@ IObject IStorage llabs LCID +lround LSHIFT NCHITTEST NCLBUTTONDBLCLK @@ -31,6 +32,8 @@ NOAGGREGATION NOREDIRECTIONBITMAP oaidl ocidl +otms +OUTLINETEXTMETRICW PAGESCROLL RETURNCMD rfind diff --git a/src/renderer/dx/DxRenderer.cpp b/src/renderer/dx/DxRenderer.cpp index e5d3d848e18..cdd1bc72e58 100644 --- a/src/renderer/dx/DxRenderer.cpp +++ b/src/renderer/dx/DxRenderer.cpp @@ -1484,63 +1484,84 @@ try _d2dBrushForeground->SetColor(_ColorFFromColorRef(color)); - const auto font = _glyphCell; - D2D_POINT_2F target = til::point{ coordTarget } * font; + const D2D1_SIZE_F font = _glyphCell; + const D2D_POINT_2F target = { coordTarget.X * font.width, coordTarget.Y * font.height }; + const auto fullRunWidth = font.width * gsl::narrow_cast(cchLine); - D2D_POINT_2F start = { 0 }; - D2D_POINT_2F end = { 0 }; - - for (size_t i = 0; i < cchLine; i++) + const auto DrawLine = [=](const auto x0, const auto y0, const auto x1, const auto y1, const auto strokeWidth) noexcept { - // 0.5 pixel offset for crisp lines - start = { target.x + 0.5f, target.y + 0.5f }; + _d2dDeviceContext->DrawLine({ x0, y0 }, { x1, y1 }, _d2dBrushForeground.Get(), strokeWidth, _strokeStyle.Get()); + }; - if (lines & GridLines::Top) - { - end = start; - end.x += font.width(); + // NOTE: Line coordinates are centered within the line, so they need to be + // offset by half the stroke width. For the start coordinate we add half + // the stroke width, and for the end coordinate we subtract half the width. - _d2dDeviceContext->DrawLine(start, end, _d2dBrushForeground.Get(), 1.0f, _strokeStyle.Get()); - } + if (lines & (GridLines::Left | GridLines::Right)) + { + const auto halfGridlineWidth = _lineMetrics.gridlineWidth / 2.0f; + const auto startY = target.y + halfGridlineWidth; + const auto endY = target.y + font.height - halfGridlineWidth; if (lines & GridLines::Left) { - end = start; - end.y += font.height(); + auto x = target.x + halfGridlineWidth; + for (size_t i = 0; i < cchLine; i++, x += font.width) + { + DrawLine(x, startY, x, endY, _lineMetrics.gridlineWidth); + } + } - _d2dDeviceContext->DrawLine(start, end, _d2dBrushForeground.Get(), 1.0f, _strokeStyle.Get()); + if (lines & GridLines::Right) + { + auto x = target.x + font.width - halfGridlineWidth; + for (size_t i = 0; i < cchLine; i++, x += font.width) + { + DrawLine(x, startY, x, endY, _lineMetrics.gridlineWidth); + } } + } - // NOTE: Watch out for inclusive/exclusive rectangles here. - // We have to remove 1 from the font size for the bottom and right lines to ensure that the - // starting point remains within the clipping rectangle. - // For example, if we're drawing a letter at 0,0 and the font size is 8x16.... - // The bottom left corner inclusive is at 0,15 which is Y (0) + Font Height (16) - 1 = 15. - // The top right corner inclusive is at 7,0 which is X (0) + Font Height (8) - 1 = 7. + if (lines & (GridLines::Top | GridLines::Bottom)) + { + const auto halfGridlineWidth = _lineMetrics.gridlineWidth / 2.0f; + const auto startX = target.x + halfGridlineWidth; + const auto endX = target.x + fullRunWidth - halfGridlineWidth; - // 0.5 pixel offset for crisp lines; -0.5 on the Y to fit _in_ the cell, not outside it. - start = { target.x + 0.5f, target.y + font.height() - 0.5f }; + if (lines & GridLines::Top) + { + const auto y = target.y + halfGridlineWidth; + DrawLine(startX, y, endX, y, _lineMetrics.gridlineWidth); + } if (lines & GridLines::Bottom) { - end = start; - end.x += font.width() - 1.f; - - _d2dDeviceContext->DrawLine(start, end, _d2dBrushForeground.Get(), 1.0f, _strokeStyle.Get()); + const auto y = target.y + font.height - halfGridlineWidth; + DrawLine(startX, y, endX, y, _lineMetrics.gridlineWidth); } + } - start = { target.x + font.width() - 0.5f, target.y + 0.5f }; + // In the case of the underline and strikethrough offsets, the stroke width + // is already accounted for, so they don't require further adjustments. - if (lines & GridLines::Right) - { - end = start; - end.y += font.height() - 1.f; + if (lines & GridLines::Underline) + { + const auto halfUnderlineWidth = _lineMetrics.underlineWidth / 2.0f; + const auto startX = target.x + halfUnderlineWidth; + const auto endX = target.x + fullRunWidth - halfUnderlineWidth; + const auto y = target.y + _lineMetrics.underlineOffset; - _d2dDeviceContext->DrawLine(start, end, _d2dBrushForeground.Get(), 1.0f, _strokeStyle.Get()); - } + DrawLine(startX, y, endX, y, _lineMetrics.underlineWidth); + } - // Move to the next character in this run. - target.x += font.width(); + if (lines & GridLines::Strikethrough) + { + const auto halfStrikethroughWidth = _lineMetrics.strikethroughWidth / 2.0f; + const auto startX = target.x + halfStrikethroughWidth; + const auto endX = target.x + fullRunWidth - halfStrikethroughWidth; + const auto y = target.y + _lineMetrics.strikethroughOffset; + + DrawLine(startX, y, endX, y, _lineMetrics.strikethroughWidth); } return S_OK; @@ -1707,7 +1728,8 @@ try _dpi, _dwriteTextFormat, _dwriteTextAnalyzer, - _dwriteFontFace)); + _dwriteFontFace, + _lineMetrics)); _glyphCell = fiFontInfo.GetSize(); @@ -1796,13 +1818,15 @@ float DxEngine::GetScaling() const noexcept Microsoft::WRL::ComPtr format; Microsoft::WRL::ComPtr analyzer; Microsoft::WRL::ComPtr face; + LineMetrics lineMetrics; return _GetProposedFont(pfiFontInfoDesired, pfiFontInfo, iDpi, format, analyzer, - face); + face, + lineMetrics); } // Routine Description: @@ -2071,7 +2095,8 @@ CATCH_RETURN(); const int dpi, Microsoft::WRL::ComPtr& textFormat, Microsoft::WRL::ComPtr& textAnalyzer, - Microsoft::WRL::ComPtr& fontFace) const noexcept + Microsoft::WRL::ComPtr& fontFace, + LineMetrics& lineMetrics) const noexcept { try { @@ -2234,6 +2259,34 @@ CATCH_RETURN(); false, scaled, unscaled); + + // There is no font metric for the grid line width, so we use a small + // multiple of the font size, which typically rounds to a pixel. + lineMetrics.gridlineWidth = std::round(fontSize * 0.025f); + + // All other line metrics are in design units, so to get a pixel value, + // we scale by the font size divided by the design-units-per-em. + const auto scale = fontSize / fontMetrics.designUnitsPerEm; + lineMetrics.underlineOffset = std::round(fontMetrics.underlinePosition * scale); + lineMetrics.underlineWidth = std::round(fontMetrics.underlineThickness * scale); + lineMetrics.strikethroughOffset = std::round(fontMetrics.strikethroughPosition * scale); + lineMetrics.strikethroughWidth = std::round(fontMetrics.strikethroughThickness * scale); + + // We always want the lines to be visible, so if a stroke width ends up + // at zero after rounding, we need to make it at least 1 pixel. + lineMetrics.gridlineWidth = std::max(lineMetrics.gridlineWidth, 1.0f); + lineMetrics.underlineWidth = std::max(lineMetrics.underlineWidth, 1.0f); + lineMetrics.strikethroughWidth = std::max(lineMetrics.strikethroughWidth, 1.0f); + + // Offsets are relative to the base line of the font, so we subtract + // from the ascent to get an offset relative to the top of the cell. + lineMetrics.underlineOffset = fullPixelAscent - lineMetrics.underlineOffset; + lineMetrics.strikethroughOffset = fullPixelAscent - lineMetrics.strikethroughOffset; + + // We also add half the stroke width to the offset, since the line + // coordinates designate the center of the line. + lineMetrics.underlineOffset += lineMetrics.underlineWidth / 2.0f; + lineMetrics.strikethroughOffset += lineMetrics.strikethroughWidth / 2.0f; } CATCH_RETURN(); diff --git a/src/renderer/dx/DxRenderer.hpp b/src/renderer/dx/DxRenderer.hpp index c56262d7d28..5eeb781a57f 100644 --- a/src/renderer/dx/DxRenderer.hpp +++ b/src/renderer/dx/DxRenderer.hpp @@ -142,6 +142,16 @@ namespace Microsoft::Console::Render bool _isEnabled; bool _isPainting; + struct LineMetrics + { + float gridlineWidth; + float underlineOffset; + float underlineWidth; + float strikethroughOffset; + float strikethroughWidth; + }; + + LineMetrics _lineMetrics; til::size _displaySizePixels; til::size _glyphCell; ::Microsoft::WRL::ComPtr _boxDrawingEffect; @@ -267,7 +277,8 @@ namespace Microsoft::Console::Render const int dpi, ::Microsoft::WRL::ComPtr& textFormat, ::Microsoft::WRL::ComPtr& textAnalyzer, - ::Microsoft::WRL::ComPtr& fontFace) const noexcept; + ::Microsoft::WRL::ComPtr& fontFace, + LineMetrics& lineMetrics) const noexcept; [[nodiscard]] til::size _GetClientSize() const; diff --git a/src/renderer/gdi/gdirenderer.hpp b/src/renderer/gdi/gdirenderer.hpp index c375f8b764a..ad3b7089f09 100644 --- a/src/renderer/gdi/gdirenderer.hpp +++ b/src/renderer/gdi/gdirenderer.hpp @@ -96,6 +96,16 @@ namespace Microsoft::Console::Render std::vector cursorInvertRects; + struct LineMetrics + { + int gridlineWidth; + int underlineOffset; + int underlineWidth; + int strikethroughOffset; + int strikethroughWidth; + }; + + LineMetrics _lineMetrics; COORD _coordFontLast; int _iCurrentDpi; diff --git a/src/renderer/gdi/paint.cpp b/src/renderer/gdi/paint.cpp index b416510f99e..2008b220399 100644 --- a/src/renderer/gdi/paint.cpp +++ b/src/renderer/gdi/paint.cpp @@ -459,40 +459,58 @@ using namespace Microsoft::Console::Render; auto restoreBrushOnExit = wil::scope_exit([&] { hbr.reset(SelectBrush(_hdcMemoryContext, hbrPrev.get())); }); // Get the font size so we know the size of the rectangle lines we'll be inscribing. - COORD const coordFontSize = _GetFontSize(); + const auto fontWidth = _GetFontSize().X; + const auto fontHeight = _GetFontSize().Y; + const auto widthOfAllCells = fontWidth * gsl::narrow_cast(cchLine); + + const auto DrawLine = [=](const auto x, const auto y, const auto w, const auto h) { + return PatBlt(_hdcMemoryContext, x, y, w, h, PATCOPY); + }; - // For each length of the line, inscribe the various lines as specified by the enum - for (size_t i = 0; i < cchLine; i++) + if (lines & GridLines::Left) { - if (lines & GridLines::Top) + auto x = ptTarget.x; + for (size_t i = 0; i < cchLine; i++, x += fontWidth) { - RETURN_HR_IF(E_FAIL, !(PatBlt(_hdcMemoryContext, ptTarget.x, ptTarget.y, coordFontSize.X, 1, PATCOPY))); + RETURN_HR_IF(E_FAIL, !DrawLine(x, ptTarget.y, _lineMetrics.gridlineWidth, fontHeight)); } + } - if (lines & GridLines::Left) + if (lines & GridLines::Right) + { + // NOTE: We have to subtract the stroke width from the cell width + // to ensure the x coordinate remains inside the clipping rectangle. + auto x = ptTarget.x + fontWidth - _lineMetrics.gridlineWidth; + for (size_t i = 0; i < cchLine; i++, x += fontWidth) { - RETURN_HR_IF(E_FAIL, !(PatBlt(_hdcMemoryContext, ptTarget.x, ptTarget.y, 1, coordFontSize.Y, PATCOPY))); + RETURN_HR_IF(E_FAIL, !DrawLine(x, ptTarget.y, _lineMetrics.gridlineWidth, fontHeight)); } + } - // NOTE: Watch out for inclusive/exclusive rectangles here. - // We have to remove 1 from the font size for the bottom and right lines to ensure that the - // starting point remains within the clipping rectangle. - // For example, if we're drawing a letter at 0,0 and the font size is 8x16.... - // The bottom left corner inclusive is at 0,15 which is Y (0) + Font Height (16) - 1 = 15. - // The top right corner inclusive is at 7,0 which is X (0) + Font Height (8) - 1 = 7. + if (lines & GridLines::Top) + { + const auto y = ptTarget.y; + RETURN_HR_IF(E_FAIL, !DrawLine(ptTarget.x, y, widthOfAllCells, _lineMetrics.gridlineWidth)); + } - if (lines & GridLines::Bottom) - { - RETURN_HR_IF(E_FAIL, !(PatBlt(_hdcMemoryContext, ptTarget.x, ptTarget.y + coordFontSize.Y - 1, coordFontSize.X, 1, PATCOPY))); - } + if (lines & GridLines::Bottom) + { + // NOTE: We have to subtract the stroke width from the cell height + // to ensure the y coordinate remains inside the clipping rectangle. + const auto y = ptTarget.y + fontHeight - _lineMetrics.gridlineWidth; + RETURN_HR_IF(E_FAIL, !DrawLine(ptTarget.x, y, widthOfAllCells, _lineMetrics.gridlineWidth)); + } - if (lines & GridLines::Right) - { - RETURN_HR_IF(E_FAIL, !(PatBlt(_hdcMemoryContext, ptTarget.x + coordFontSize.X - 1, ptTarget.y, 1, coordFontSize.Y, PATCOPY))); - } + if (lines & GridLines::Underline) + { + const auto y = ptTarget.y + _lineMetrics.underlineOffset; + RETURN_HR_IF(E_FAIL, !DrawLine(ptTarget.x, y, widthOfAllCells, _lineMetrics.underlineWidth)); + } - // Move to the next character in this run. - ptTarget.x += coordFontSize.X; + if (lines & GridLines::Strikethrough) + { + const auto y = ptTarget.y + _lineMetrics.strikethroughOffset; + RETURN_HR_IF(E_FAIL, !DrawLine(ptTarget.x, y, widthOfAllCells, _lineMetrics.strikethroughWidth)); } return S_OK; diff --git a/src/renderer/gdi/state.cpp b/src/renderer/gdi/state.cpp index 65eec1aaa4e..e7ad9e2f6ef 100644 --- a/src/renderer/gdi/state.cpp +++ b/src/renderer/gdi/state.cpp @@ -232,6 +232,43 @@ GdiEngine::~GdiEngine() // Save off the font metrics for various other calculations RETURN_HR_IF(E_FAIL, !(GetTextMetricsW(_hdcMemoryContext, &_tmFontMetrics))); + // There is no font metric for the grid line width, so we use a small + // multiple of the font size, which typically rounds to a pixel. + const auto fontSize = _tmFontMetrics.tmHeight - _tmFontMetrics.tmInternalLeading; + _lineMetrics.gridlineWidth = std::lround(fontSize * 0.025); + + OUTLINETEXTMETRICW outlineMetrics; + if (GetOutlineTextMetricsW(_hdcMemoryContext, sizeof(outlineMetrics), &outlineMetrics)) + { + // For TrueType fonts, the other line metrics can be obtained from + // the font's outline text metric structure. + _lineMetrics.underlineOffset = outlineMetrics.otmsUnderscorePosition; + _lineMetrics.underlineWidth = outlineMetrics.otmsUnderscoreSize; + _lineMetrics.strikethroughOffset = outlineMetrics.otmsStrikeoutPosition; + _lineMetrics.strikethroughWidth = outlineMetrics.otmsStrikeoutSize; + } + else + { + // If we can't obtain the outline metrics for the font, we just pick + // some reasonable values for the offsets and widths. + _lineMetrics.underlineOffset = -std::lround(fontSize * 0.05); + _lineMetrics.underlineWidth = _lineMetrics.gridlineWidth; + _lineMetrics.strikethroughOffset = std::lround(_tmFontMetrics.tmAscent / 3.0); + _lineMetrics.strikethroughWidth = _lineMetrics.gridlineWidth; + } + + // We always want the lines to be visible, so if a stroke width ends + // up being zero, we need to make it at least 1 pixel. + _lineMetrics.gridlineWidth = std::max(_lineMetrics.gridlineWidth, 1); + _lineMetrics.underlineWidth = std::max(_lineMetrics.underlineWidth, 1); + _lineMetrics.strikethroughWidth = std::max(_lineMetrics.strikethroughWidth, 1); + + // Offsets are relative to the base line of the font, so we subtract + // from the ascent to get an offset relative to the top of the cell. + const auto ascent = _tmFontMetrics.tmAscent; + _lineMetrics.underlineOffset = ascent - _lineMetrics.underlineOffset; + _lineMetrics.strikethroughOffset = ascent - _lineMetrics.strikethroughOffset; + // Now find the size of a 0 in this current font and save it for conversions done later. _coordFontLast = Font.GetSize(); diff --git a/src/renderer/inc/IRenderEngine.hpp b/src/renderer/inc/IRenderEngine.hpp index a70960754c0..388ba308960 100644 --- a/src/renderer/inc/IRenderEngine.hpp +++ b/src/renderer/inc/IRenderEngine.hpp @@ -35,7 +35,9 @@ namespace Microsoft::Console::Render Top = 0x1, Bottom = 0x2, Left = 0x4, - Right = 0x8 + Right = 0x8, + Underline = 0x10, + Strikethrough = 0x20 }; virtual ~IRenderEngine() = 0; From 8b669b5484d39cd777e8dcb6312f4308ee2861a8 Mon Sep 17 00:00:00 2001 From: PankajBhojwani Date: Thu, 30 Jul 2020 21:07:47 -0400 Subject: [PATCH 23/33] Implement split pane with new tab button (#7117) Allows splitting pane (with default settings) by holding down ALT and pressing the new tab button ('+') ## PR Checklist * [X] Closes #6757 * [X] Works here. * [X] Manual test (below) * [X] Is core contributor. ## More detailed description Pretty much exactly the code added in #5928 (all credit to @carlos-zamora), but put at the new tab button event binding ## Validation steps Seems to work - holding ALT while pressing '+' opens a pane instead of a tab. Holding ALT while starting up terminal for the first time does not seem to affect the behaviour. --- src/cascadia/TerminalApp/TerminalPage.cpp | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/src/cascadia/TerminalApp/TerminalPage.cpp b/src/cascadia/TerminalApp/TerminalPage.cpp index 8fc907ca89f..fd613d8a82e 100644 --- a/src/cascadia/TerminalApp/TerminalPage.cpp +++ b/src/cascadia/TerminalApp/TerminalPage.cpp @@ -167,7 +167,28 @@ namespace winrt::TerminalApp::implementation _newTabButton.Click([weakThis{ get_weak() }](auto&&, auto&&) { if (auto page{ weakThis.get() }) { - page->_OpenNewTab(nullptr); + // if alt is pressed, open a pane + const CoreWindow window = CoreWindow::GetForCurrentThread(); + const auto rAltState = window.GetKeyState(VirtualKey::RightMenu); + const auto lAltState = window.GetKeyState(VirtualKey::LeftMenu); + const bool altPressed = WI_IsFlagSet(lAltState, CoreVirtualKeyStates::Down) || + WI_IsFlagSet(rAltState, CoreVirtualKeyStates::Down); + + // Check for DebugTap + bool debugTap = page->_settings->GlobalSettings().DebugFeaturesEnabled() && + WI_IsFlagSet(lAltState, CoreVirtualKeyStates::Down) && + WI_IsFlagSet(rAltState, CoreVirtualKeyStates::Down); + + if (altPressed && !debugTap) + { + page->_SplitPane(TerminalApp::SplitState::Automatic, + TerminalApp::SplitType::Manual, + nullptr); + } + else + { + page->_OpenNewTab(nullptr); + } } }); _tabView.SelectionChanged({ this, &TerminalPage::_OnTabSelectionChanged }); From dd0f7b701a01c93756c26aef001c5b3ee04ac649 Mon Sep 17 00:00:00 2001 From: "Dustin L. Howett" Date: Fri, 31 Jul 2020 10:16:27 -0700 Subject: [PATCH 24/33] Send ENHANCED_KEY in Win32 input mode in the wpf/uwp controls (#7106) When we added support for win32 input mode, we neglected to pass `ENHANCED_KEY` through the two surfaces that would generate events. This broke arrow keys in much the same way was #2397, but in a different layer. While I was working on the WPF control, I took a moment to refactor the message cracking out into a helper. It's a lot easier on the eyes than four lines of bit shifting repeated three times. Fixes #7074 --- .../PublicTerminalCore/HwndTerminal.cpp | 28 ++++++++++++------- .../PublicTerminalCore/HwndTerminal.hpp | 12 ++++---- src/cascadia/TerminalControl/TermControl.cpp | 12 ++++++-- .../WpfTerminalControl/NativeMethods.cs | 4 +-- .../WpfTerminalControl/TerminalContainer.cs | 26 +++++++++++++---- 5 files changed, 56 insertions(+), 26 deletions(-) diff --git a/src/cascadia/PublicTerminalCore/HwndTerminal.cpp b/src/cascadia/PublicTerminalCore/HwndTerminal.cpp index 16e41fef05f..27775bb314d 100644 --- a/src/cascadia/PublicTerminalCore/HwndTerminal.cpp +++ b/src/cascadia/PublicTerminalCore/HwndTerminal.cpp @@ -625,15 +625,19 @@ catch (...) return false; } -void HwndTerminal::_SendKeyEvent(WORD vkey, WORD scanCode, bool keyDown) noexcept +void HwndTerminal::_SendKeyEvent(WORD vkey, WORD scanCode, WORD flags, bool keyDown) noexcept try { - const auto flags = getControlKeyState(); - _terminal->SendKeyEvent(vkey, scanCode, flags, keyDown); + auto modifiers = getControlKeyState(); + if (WI_IsFlagSet(flags, ENHANCED_KEY)) + { + modifiers |= ControlKeyStates::EnhancedKey; + } + _terminal->SendKeyEvent(vkey, scanCode, modifiers, keyDown); } CATCH_LOG(); -void HwndTerminal::_SendCharEvent(wchar_t ch, WORD scanCode) noexcept +void HwndTerminal::_SendCharEvent(wchar_t ch, WORD scanCode, WORD flags) noexcept try { if (_terminal->IsSelectionActive()) @@ -653,21 +657,25 @@ try return; } - const auto flags = getControlKeyState(); - _terminal->SendCharEvent(ch, scanCode, flags); + auto modifiers = getControlKeyState(); + if (WI_IsFlagSet(flags, ENHANCED_KEY)) + { + modifiers |= ControlKeyStates::EnhancedKey; + } + _terminal->SendCharEvent(ch, scanCode, modifiers); } CATCH_LOG(); -void _stdcall TerminalSendKeyEvent(void* terminal, WORD vkey, WORD scanCode, bool keyDown) +void _stdcall TerminalSendKeyEvent(void* terminal, WORD vkey, WORD scanCode, WORD flags, bool keyDown) { const auto publicTerminal = static_cast(terminal); - publicTerminal->_SendKeyEvent(vkey, scanCode, keyDown); + publicTerminal->_SendKeyEvent(vkey, scanCode, flags, keyDown); } -void _stdcall TerminalSendCharEvent(void* terminal, wchar_t ch, WORD scanCode) +void _stdcall TerminalSendCharEvent(void* terminal, wchar_t ch, WORD scanCode, WORD flags) { const auto publicTerminal = static_cast(terminal); - publicTerminal->_SendCharEvent(ch, scanCode); + publicTerminal->_SendCharEvent(ch, scanCode, flags); } void _stdcall DestroyTerminal(void* terminal) diff --git a/src/cascadia/PublicTerminalCore/HwndTerminal.hpp b/src/cascadia/PublicTerminalCore/HwndTerminal.hpp index f904f526cad..47ee1f88dc7 100644 --- a/src/cascadia/PublicTerminalCore/HwndTerminal.hpp +++ b/src/cascadia/PublicTerminalCore/HwndTerminal.hpp @@ -34,8 +34,8 @@ __declspec(dllexport) bool _stdcall TerminalIsSelectionActive(void* terminal); __declspec(dllexport) void _stdcall DestroyTerminal(void* terminal); __declspec(dllexport) void _stdcall TerminalSetTheme(void* terminal, TerminalTheme theme, LPCWSTR fontFamily, short fontSize, int newDpi); __declspec(dllexport) void _stdcall TerminalRegisterWriteCallback(void* terminal, const void __stdcall callback(wchar_t*)); -__declspec(dllexport) void _stdcall TerminalSendKeyEvent(void* terminal, WORD vkey, WORD scanCode, bool keyDown); -__declspec(dllexport) void _stdcall TerminalSendCharEvent(void* terminal, wchar_t ch, WORD scanCode); +__declspec(dllexport) void _stdcall TerminalSendKeyEvent(void* terminal, WORD vkey, WORD scanCode, WORD flags, bool keyDown); +__declspec(dllexport) void _stdcall TerminalSendCharEvent(void* terminal, wchar_t ch, WORD flags, WORD scanCode); __declspec(dllexport) void _stdcall TerminalBlinkCursor(void* terminal); __declspec(dllexport) void _stdcall TerminalSetCursorVisible(void* terminal, const bool visible); __declspec(dllexport) void _stdcall TerminalSetFocus(void* terminal); @@ -93,8 +93,8 @@ struct HwndTerminal : ::Microsoft::Console::Types::IControlAccessibilityInfo friend void _stdcall TerminalClearSelection(void* terminal); friend const wchar_t* _stdcall TerminalGetSelection(void* terminal); friend bool _stdcall TerminalIsSelectionActive(void* terminal); - friend void _stdcall TerminalSendKeyEvent(void* terminal, WORD vkey, WORD scanCode, bool keyDown); - friend void _stdcall TerminalSendCharEvent(void* terminal, wchar_t ch, WORD scanCode); + friend void _stdcall TerminalSendKeyEvent(void* terminal, WORD vkey, WORD scanCode, WORD flags, bool keyDown); + friend void _stdcall TerminalSendCharEvent(void* terminal, wchar_t ch, WORD scanCode, WORD flags); friend void _stdcall TerminalSetTheme(void* terminal, TerminalTheme theme, LPCWSTR fontFamily, short fontSize, int newDpi); friend void _stdcall TerminalBlinkCursor(void* terminal); friend void _stdcall TerminalSetCursorVisible(void* terminal, const bool visible); @@ -118,8 +118,8 @@ struct HwndTerminal : ::Microsoft::Console::Types::IControlAccessibilityInfo bool _CanSendVTMouseInput() const noexcept; bool _SendMouseEvent(UINT uMsg, WPARAM wParam, LPARAM lParam) noexcept; - void _SendKeyEvent(WORD vkey, WORD scanCode, bool keyDown) noexcept; - void _SendCharEvent(wchar_t ch, WORD scanCode) noexcept; + void _SendKeyEvent(WORD vkey, WORD scanCode, WORD flags, bool keyDown) noexcept; + void _SendCharEvent(wchar_t ch, WORD scanCode, WORD flags) noexcept; // Inherited via IControlAccessibilityInfo COORD GetFontSize() const override; diff --git a/src/cascadia/TerminalControl/TermControl.cpp b/src/cascadia/TerminalControl/TermControl.cpp index 8838eb5df11..784275fa324 100644 --- a/src/cascadia/TerminalControl/TermControl.cpp +++ b/src/cascadia/TerminalControl/TermControl.cpp @@ -738,7 +738,11 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation const auto ch = e.Character(); const auto scanCode = gsl::narrow_cast(e.KeyStatus().ScanCode); - const auto modifiers = _GetPressedModifierKeys(); + auto modifiers = _GetPressedModifierKeys(); + if (e.KeyStatus().IsExtendedKey) + { + modifiers |= ControlKeyStates::EnhancedKey; + } const bool handled = _terminal->SendCharEvent(ch, scanCode, modifiers); e.Handled(handled); } @@ -827,9 +831,13 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation return; } - const auto modifiers = _GetPressedModifierKeys(); + auto modifiers = _GetPressedModifierKeys(); const auto vkey = gsl::narrow_cast(e.OriginalKey()); const auto scanCode = gsl::narrow_cast(e.KeyStatus().ScanCode); + if (e.KeyStatus().IsExtendedKey) + { + modifiers |= ControlKeyStates::EnhancedKey; + } // Alt-Numpad# input will send us a character once the user releases // Alt, so we should be ignoring the individual keydowns. The character diff --git a/src/cascadia/WpfTerminalControl/NativeMethods.cs b/src/cascadia/WpfTerminalControl/NativeMethods.cs index 3ba2a78f094..0e40d646652 100644 --- a/src/cascadia/WpfTerminalControl/NativeMethods.cs +++ b/src/cascadia/WpfTerminalControl/NativeMethods.cs @@ -225,10 +225,10 @@ public enum SetWindowPosFlags : uint public static extern void DestroyTerminal(IntPtr terminal); [DllImport("PublicTerminalCore.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall)] - public static extern void TerminalSendKeyEvent(IntPtr terminal, ushort vkey, ushort scanCode, bool keyDown); + public static extern void TerminalSendKeyEvent(IntPtr terminal, ushort vkey, ushort scanCode, ushort flags, bool keyDown); [DllImport("PublicTerminalCore.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall)] - public static extern void TerminalSendCharEvent(IntPtr terminal, char ch, ushort scanCode); + public static extern void TerminalSendCharEvent(IntPtr terminal, char ch, ushort scanCode, ushort flags); [DllImport("PublicTerminalCore.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall)] public static extern void TerminalSetTheme(IntPtr terminal, [MarshalAs(UnmanagedType.Struct)] TerminalTheme theme, string fontFamily, short fontSize, int newDpi); diff --git a/src/cascadia/WpfTerminalControl/TerminalContainer.cs b/src/cascadia/WpfTerminalControl/TerminalContainer.cs index 86549a9e05c..2f5c6839455 100644 --- a/src/cascadia/WpfTerminalControl/TerminalContainer.cs +++ b/src/cascadia/WpfTerminalControl/TerminalContainer.cs @@ -20,6 +20,20 @@ namespace Microsoft.Terminal.Wpf /// public class TerminalContainer : HwndHost { + private static void UnpackKeyMessage(IntPtr wParam, IntPtr lParam, out ushort vkey, out ushort scanCode, out ushort flags) + { + ulong scanCodeAndFlags = (((ulong)lParam) & 0xFFFF0000) >> 16; + scanCode = (ushort)(scanCodeAndFlags & 0x00FFu); + flags = (ushort)(scanCodeAndFlags & 0xFF00u); + vkey = (ushort)wParam; + } + + private static void UnpackCharMessage(IntPtr wParam, IntPtr lParam, out char character, out ushort scanCode, out ushort flags) + { + UnpackKeyMessage(wParam, lParam, out ushort vKey, out scanCode, out flags); + character = (char)vKey; + } + private ITerminalConnection connection; private IntPtr hwnd; private IntPtr terminal; @@ -254,9 +268,9 @@ private IntPtr TerminalContainer_MessageHook(IntPtr hwnd, int msg, IntPtr wParam { // WM_KEYDOWN lParam layout documentation: https://docs.microsoft.com/en-us/windows/win32/inputdev/wm-keydown NativeMethods.TerminalSetCursorVisible(this.terminal, true); - ulong scanCode = (((ulong)lParam) & 0x00FF0000) >> 16; - NativeMethods.TerminalSendKeyEvent(this.terminal, (ushort)wParam, (ushort)scanCode, true); + UnpackKeyMessage(wParam, lParam, out ushort vkey, out ushort scanCode, out ushort flags); + NativeMethods.TerminalSendKeyEvent(this.terminal, vkey, scanCode, flags, true); this.blinkTimer?.Start(); break; } @@ -265,16 +279,16 @@ private IntPtr TerminalContainer_MessageHook(IntPtr hwnd, int msg, IntPtr wParam case NativeMethods.WindowMessage.WM_KEYUP: { // WM_KEYUP lParam layout documentation: https://docs.microsoft.com/en-us/windows/win32/inputdev/wm-keyup - ulong scanCode = (((ulong)lParam) & 0x00FF0000) >> 16; - NativeMethods.TerminalSendKeyEvent(this.terminal, (ushort)wParam, (ushort)scanCode, false); + UnpackKeyMessage(wParam, lParam, out ushort vkey, out ushort scanCode, out ushort flags); + NativeMethods.TerminalSendKeyEvent(this.terminal, (ushort)wParam, scanCode, flags, false); break; } case NativeMethods.WindowMessage.WM_CHAR: { // WM_CHAR lParam layout documentation: https://docs.microsoft.com/en-us/windows/win32/inputdev/wm-char - ulong scanCode = (((ulong)lParam) & 0x00FF0000) >> 16; - NativeMethods.TerminalSendCharEvent(this.terminal, (char)wParam, (ushort)scanCode); + UnpackCharMessage(wParam, lParam, out char character, out ushort scanCode, out ushort flags); + NativeMethods.TerminalSendCharEvent(this.terminal, character, scanCode, flags); break; } From ef4aed944a45c82355a7245b1d575a97968ef219 Mon Sep 17 00:00:00 2001 From: James Holderness Date: Sat, 1 Aug 2020 09:09:37 +0100 Subject: [PATCH 25/33] Add support for the "crossed-out" graphic rendition attribute (#7143) This PR adds support for the ANSI _crossed-out_ graphic rendition attribute, which is enabled by the `SGR 9` escape sequence. * Support for the escape sequences and storage of the attribute was originally added in #2917. * Support for drawing the strikethrough effect in the grid line renderer was added in #7107. Since the majority of the code required for this attribute had already been implemented, it was just a matter of activating the `GridLines::Strikethrough` style in the `Renderer::s_GetGridlines` method when the `CrossedOut` attribute was set. VALIDATION There were already some unit tests in place in `VtRendererTest` and the `ScreenBufferTests`, but I've also now extended the SGR tests in `AdapterTest` to cover this attribute. I've manually confirmed the first test case from #6205 now works as expected in both conhost and Terminal. Closes #6205 --- src/renderer/base/renderer.cpp | 5 +++++ src/terminal/adapter/ut_adapter/adapterTest.cpp | 14 +++++++++++++- 2 files changed, 18 insertions(+), 1 deletion(-) diff --git a/src/renderer/base/renderer.cpp b/src/renderer/base/renderer.cpp index bdda98bc3cf..c4e9d71d9c5 100644 --- a/src/renderer/base/renderer.cpp +++ b/src/renderer/base/renderer.cpp @@ -860,6 +860,11 @@ IRenderEngine::GridLines Renderer::s_GetGridlines(const TextAttribute& textAttri { lines |= IRenderEngine::GridLines::Right; } + + if (textAttribute.IsCrossedOut()) + { + lines |= IRenderEngine::GridLines::Strikethrough; + } return lines; } diff --git a/src/terminal/adapter/ut_adapter/adapterTest.cpp b/src/terminal/adapter/ut_adapter/adapterTest.cpp index 3823a6179c5..6ecdfb7f0a4 100644 --- a/src/terminal/adapter/ut_adapter/adapterTest.cpp +++ b/src/terminal/adapter/ut_adapter/adapterTest.cpp @@ -1260,7 +1260,7 @@ class AdapterTest TEST_METHOD(GraphicsSingleTests) { BEGIN_TEST_METHOD_PROPERTIES() - TEST_METHOD_PROPERTY(L"Data:uiGraphicsOptions", L"{0, 1, 2, 4, 7, 8, 22, 24, 27, 28, 30, 31, 32, 33, 34, 35, 36, 37, 39, 40, 41, 42, 43, 44, 45, 46, 47, 49, 53, 55, 90, 91, 92, 93, 94, 95, 96, 97, 100, 101, 102, 103, 104, 105, 106, 107}") // corresponds to options in DispatchTypes::GraphicsOptions + TEST_METHOD_PROPERTY(L"Data:uiGraphicsOptions", L"{0, 1, 2, 4, 7, 8, 9, 22, 24, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 39, 40, 41, 42, 43, 44, 45, 46, 47, 49, 53, 55, 90, 91, 92, 93, 94, 95, 96, 97, 100, 101, 102, 103, 104, 105, 106, 107}") // corresponds to options in DispatchTypes::GraphicsOptions END_TEST_METHOD_PROPERTIES() Log::Comment(L"Starting test..."); @@ -1316,6 +1316,12 @@ class AdapterTest _testGetSet->_expectedAttribute = TextAttribute{ 0 }; _testGetSet->_expectedAttribute.SetInvisible(true); break; + case DispatchTypes::GraphicsOptions::CrossedOut: + Log::Comment(L"Testing graphics 'Crossed Out'"); + _testGetSet->_attribute = TextAttribute{ 0 }; + _testGetSet->_expectedAttribute = TextAttribute{ 0 }; + _testGetSet->_expectedAttribute.SetCrossedOut(true); + break; case DispatchTypes::GraphicsOptions::NotBoldOrFaint: Log::Comment(L"Testing graphics 'No Bold or Faint'"); _testGetSet->_attribute = TextAttribute{ 0 }; @@ -1344,6 +1350,12 @@ class AdapterTest _testGetSet->_attribute.SetInvisible(true); _testGetSet->_expectedAttribute = TextAttribute{ 0 }; break; + case DispatchTypes::GraphicsOptions::NotCrossedOut: + Log::Comment(L"Testing graphics 'Not Crossed Out'"); + _testGetSet->_attribute = TextAttribute{ 0 }; + _testGetSet->_attribute.SetCrossedOut(true); + _testGetSet->_expectedAttribute = TextAttribute{ 0 }; + break; case DispatchTypes::GraphicsOptions::ForegroundBlack: Log::Comment(L"Testing graphics 'Foreground Color Black'"); _testGetSet->_attribute = TextAttribute{ FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY }; From 158a1708a62504d59d2f5000489f7ceddb90b8f2 Mon Sep 17 00:00:00 2001 From: James Holderness Date: Mon, 3 Aug 2020 13:49:25 +0100 Subject: [PATCH 26/33] Render the SGR "underlined" attribute in the style of the font (#7148) This PR updates the rendering of the _underlined_ graphic rendition attribute, using the style specified in the active font, instead of just reusing the grid line at the bottom of the character cell. * Support for drawing the correct underline effect in the grid line renderer was added in #7107. There was already an `ExtendedAttributes` flag defined for the underlined state, but I needed to update the `SetUnderlined` and `IsUnderlined` methods in the `TextAttribute` class to use that flag now in place of the legacy `LVB_UNDERSCORE` attribute. This enables underlines set via a VT sequence to be tracked separately from `LVB_UNDERSCORE` grid lines set via the console API. I then needed to update the `Renderer::s_GetGridlines` method to activate the `GridLines::Underline` style when the `Underlined` attribute was set. The `GridLines::Bottom` style is still triggered by the `LVB_UNDERSCORE` attribute to produce the bottom grid line effect. Validation ---------- Because this is a change from the existing behaviour, certain unit tests that were expecting the `LVB_UNDERSCORE` to be toggled by `SGR 4` and `SGR 24` have now had to be updated to check the `Underlined` flag instead. There were also some UI Automation tests that were checking for `SGR 4` mapping to `LVB_UNDERSCORE` attribute, which I've now substituted with a test of the `SGR 53` overline attribute mapping to `LVB_GRID_HORIZONTAL`. These tests only work with legacy attributes, so they can't access the extended underline state, and I thought a replacement test that covered similar ground would be better than dropping the tests altogether. As far as the visual rendering is concerned, I've manually confirmed that the VT underline sequences now draw the underline in the correct position and style, while grid lines output via the console API are still displayed in their original form. Closes #2915 --- src/buffer/out/TextAttribute.cpp | 6 ++---- src/host/ft_uia/VirtualTerminalTests.cs | 16 ++++++++-------- src/host/ut_host/TextBufferTests.cpp | 4 ++-- src/inc/conattrs.hpp | 2 +- src/renderer/base/renderer.cpp | 5 +++++ src/terminal/adapter/ut_adapter/adapterTest.cpp | 6 ++++-- src/tools/vtapp/Program.cs | 6 +++--- 7 files changed, 25 insertions(+), 20 deletions(-) diff --git a/src/buffer/out/TextAttribute.cpp b/src/buffer/out/TextAttribute.cpp index 371fedb2b64..ad7ee0546e7 100644 --- a/src/buffer/out/TextAttribute.cpp +++ b/src/buffer/out/TextAttribute.cpp @@ -246,8 +246,7 @@ bool TextAttribute::IsCrossedOut() const noexcept bool TextAttribute::IsUnderlined() const noexcept { - // TODO:GH#2915 Treat underline separately from LVB_UNDERSCORE - return WI_IsFlagSet(_wAttrLegacy, COMMON_LVB_UNDERSCORE); + return WI_IsFlagSet(_extendedAttrs, ExtendedAttributes::Underlined); } bool TextAttribute::IsOverlined() const noexcept @@ -292,8 +291,7 @@ void TextAttribute::SetCrossedOut(bool isCrossedOut) noexcept void TextAttribute::SetUnderlined(bool isUnderlined) noexcept { - // TODO:GH#2915 Treat underline separately from LVB_UNDERSCORE - WI_UpdateFlag(_wAttrLegacy, COMMON_LVB_UNDERSCORE, isUnderlined); + WI_UpdateFlag(_extendedAttrs, ExtendedAttributes::Underlined, isUnderlined); } void TextAttribute::SetOverlined(bool isOverlined) noexcept diff --git a/src/host/ft_uia/VirtualTerminalTests.cs b/src/host/ft_uia/VirtualTerminalTests.cs index 65fdf71b401..6210e297363 100644 --- a/src/host/ft_uia/VirtualTerminalTests.cs +++ b/src/host/ft_uia/VirtualTerminalTests.cs @@ -381,23 +381,23 @@ private static void TestGraphicsCommands(CmdApp app, ViewportArea area, IntPtr h ciActual = area.GetCharInfoAt(hConsole, pt); Verify.AreEqual(ciExpected, ciActual, "Verify that background bright cyan got set."); - Log.Comment("Set underline (SGR.4)"); + Log.Comment("Set overline (SGR.53)"); app.FillCursorPosition(hConsole, ref pt); app.UIRoot.SendKeys("e`"); - ciExpected.Attributes |= WinCon.CONSOLE_ATTRIBUTES.COMMON_LVB_UNDERSCORE; + ciExpected.Attributes |= WinCon.CONSOLE_ATTRIBUTES.COMMON_LVB_GRID_HORIZONTAL; ciActual = area.GetCharInfoAt(hConsole, pt); - Verify.AreEqual(ciExpected, ciActual, "Verify that underline got set."); + Verify.AreEqual(ciExpected, ciActual, "Verify that overline got set."); - Log.Comment("Clear underline (SGR.24)"); + Log.Comment("Clear overline (SGR.55)"); app.FillCursorPosition(hConsole, ref pt); app.UIRoot.SendKeys("d`"); - ciExpected.Attributes &= ~WinCon.CONSOLE_ATTRIBUTES.COMMON_LVB_UNDERSCORE; + ciExpected.Attributes &= ~WinCon.CONSOLE_ATTRIBUTES.COMMON_LVB_GRID_HORIZONTAL; ciActual = area.GetCharInfoAt(hConsole, pt); - Verify.AreEqual(ciExpected, ciActual, "Verify that underline got cleared."); + Verify.AreEqual(ciExpected, ciActual, "Verify that overline got cleared."); Log.Comment("Set negative image video (SGR.7)"); app.FillCursorPosition(hConsole, ref pt); @@ -426,14 +426,14 @@ private static void TestGraphicsCommands(CmdApp app, ViewportArea area, IntPtr h ciActual = area.GetCharInfoAt(hConsole, pt); Verify.AreEqual(ciExpected, ciActual, "Verify that we got set back to the original state."); - Log.Comment("Set multiple properties in the same message (SGR.1,37,43,4)"); + Log.Comment("Set multiple properties in the same message (SGR.1,37,43,53)"); app.FillCursorPosition(hConsole, ref pt); app.UIRoot.SendKeys("9`"); ciExpected.Attributes |= WinCon.CONSOLE_ATTRIBUTES.FOREGROUND_COLORS; ciExpected.Attributes |= WinCon.CONSOLE_ATTRIBUTES.FOREGROUND_INTENSITY; ciExpected.Attributes |= WinCon.CONSOLE_ATTRIBUTES.BACKGROUND_YELLOW; - ciExpected.Attributes |= WinCon.CONSOLE_ATTRIBUTES.COMMON_LVB_UNDERSCORE; + ciExpected.Attributes |= WinCon.CONSOLE_ATTRIBUTES.COMMON_LVB_GRID_HORIZONTAL; ciActual = area.GetCharInfoAt(hConsole, pt); Verify.AreEqual(ciExpected, ciActual, "Verify that we set foreground bright white, background yellow, and underscore in the same SGR command."); diff --git a/src/host/ut_host/TextBufferTests.cpp b/src/host/ut_host/TextBufferTests.cpp index 6755cc7b76e..6f4351b6c26 100644 --- a/src/host/ut_host/TextBufferTests.cpp +++ b/src/host/ut_host/TextBufferTests.cpp @@ -757,8 +757,8 @@ void TextBufferTests::TestMixedRgbAndLegacyUnderline() VERIFY_ARE_EQUAL(gci.LookupAttributeColors(attrA), std::make_pair(fgColor, bgColor)); VERIFY_ARE_EQUAL(gci.LookupAttributeColors(attrB), std::make_pair(fgColor, bgColor)); - VERIFY_ARE_EQUAL(attrA.GetLegacyAttributes() & COMMON_LVB_UNDERSCORE, 0); - VERIFY_ARE_EQUAL(attrB.GetLegacyAttributes() & COMMON_LVB_UNDERSCORE, COMMON_LVB_UNDERSCORE); + VERIFY_ARE_EQUAL(attrA.IsUnderlined(), false); + VERIFY_ARE_EQUAL(attrB.IsUnderlined(), true); wchar_t* reset = L"\x1b[0m"; stateMachine.ProcessString(reset); diff --git a/src/inc/conattrs.hpp b/src/inc/conattrs.hpp index 1ad1fa90302..06d2d9d3ebe 100644 --- a/src/inc/conattrs.hpp +++ b/src/inc/conattrs.hpp @@ -17,7 +17,7 @@ enum class ExtendedAttributes : BYTE Invisible = 0x08, CrossedOut = 0x10, // TODO:GH#2916 add support for these to the parser as well. - Underlined = 0x20, // _technically_ different from LVB_UNDERSCORE, see TODO:GH#2915 + Underlined = 0x20, DoublyUnderlined = 0x40, // Included for completeness, but not currently supported. Faint = 0x80, }; diff --git a/src/renderer/base/renderer.cpp b/src/renderer/base/renderer.cpp index c4e9d71d9c5..2bbbf220b47 100644 --- a/src/renderer/base/renderer.cpp +++ b/src/renderer/base/renderer.cpp @@ -865,6 +865,11 @@ IRenderEngine::GridLines Renderer::s_GetGridlines(const TextAttribute& textAttri { lines |= IRenderEngine::GridLines::Strikethrough; } + + if (textAttribute.IsUnderlined()) + { + lines |= IRenderEngine::GridLines::Underline; + } return lines; } diff --git a/src/terminal/adapter/ut_adapter/adapterTest.cpp b/src/terminal/adapter/ut_adapter/adapterTest.cpp index 6ecdfb7f0a4..e3c8746f650 100644 --- a/src/terminal/adapter/ut_adapter/adapterTest.cpp +++ b/src/terminal/adapter/ut_adapter/adapterTest.cpp @@ -1298,7 +1298,8 @@ class AdapterTest case DispatchTypes::GraphicsOptions::Underline: Log::Comment(L"Testing graphics 'Underline'"); _testGetSet->_attribute = TextAttribute{ 0 }; - _testGetSet->_expectedAttribute = TextAttribute{ COMMON_LVB_UNDERSCORE }; + _testGetSet->_expectedAttribute = TextAttribute{ 0 }; + _testGetSet->_expectedAttribute.SetUnderlined(true); break; case DispatchTypes::GraphicsOptions::Overline: Log::Comment(L"Testing graphics 'Overline'"); @@ -1331,7 +1332,8 @@ class AdapterTest break; case DispatchTypes::GraphicsOptions::NoUnderline: Log::Comment(L"Testing graphics 'No Underline'"); - _testGetSet->_attribute = TextAttribute{ COMMON_LVB_UNDERSCORE }; + _testGetSet->_attribute = TextAttribute{ 0 }; + _testGetSet->_attribute.SetUnderlined(true); _testGetSet->_expectedAttribute = TextAttribute{ 0 }; break; case DispatchTypes::GraphicsOptions::NoOverline: diff --git a/src/tools/vtapp/Program.cs b/src/tools/vtapp/Program.cs index 20cff98abb7..6b2017c004b 100644 --- a/src/tools/vtapp/Program.cs +++ b/src/tools/vtapp/Program.cs @@ -236,11 +236,11 @@ static void Main(string[] args) break; case 'e': Console.Write(CSI); - Console.Write("4m"); + Console.Write("53m"); break; case 'd': Console.Write(CSI); - Console.Write("24m"); + Console.Write("55m"); break; case 'r': Console.Write(CSI); @@ -260,7 +260,7 @@ static void Main(string[] args) break; case '9': Console.Write(CSI); - Console.Write("1;37;43;4m"); + Console.Write("1;37;43;53m"); break; case '(': Console.Write(CSI); From 14c94f5963b07962ab7f0573e6618f388f48820d Mon Sep 17 00:00:00 2001 From: Mike Griese Date: Mon, 3 Aug 2020 15:01:36 -0500 Subject: [PATCH 27/33] Add a spec for per-profile tab colors (#7134) Co-authored-by: Mike Griese ## Summary of the Pull Request This spec is a subset of #5772, but specific to per-profile tab colors. We've had enough requests for that in the last few days that I want to pull that feature out into it's own spec, so we can get that approved and implemented in a future-proof way. > This spec describes a way to specify tab colors in a profile in a way that will > be forward compatible with theming the Terminal. This spec will be largely > dedicated to the design of a single setting, but within the context of theming. > ## PR Checklist * [x] Specs: #1337 * [x] References: #5772 * [x] I work here ## Detailed Description of the Pull Request / Additional comments _\*\*\* read the spec \*\*\*_ --- .../#1337 - Per-Profile Tab Colors.md | 146 ++++++++++++++++++ .../profile-tabColor-000.gif | Bin 0 -> 835167 bytes 2 files changed, 146 insertions(+) create mode 100644 doc/specs/#1337 - Per-Profile Tab Colors/#1337 - Per-Profile Tab Colors.md create mode 100644 doc/specs/#1337 - Per-Profile Tab Colors/profile-tabColor-000.gif diff --git a/doc/specs/#1337 - Per-Profile Tab Colors/#1337 - Per-Profile Tab Colors.md b/doc/specs/#1337 - Per-Profile Tab Colors/#1337 - Per-Profile Tab Colors.md new file mode 100644 index 00000000000..e2830babbe7 --- /dev/null +++ b/doc/specs/#1337 - Per-Profile Tab Colors/#1337 - Per-Profile Tab Colors.md @@ -0,0 +1,146 @@ +--- +author: Mike Griese @zadjii-msft +created on: 2020-07-31 +last updated: 2020-08-03 +issue id: #1337 +--- +# Per-Profile Tab Colors + +## Abstract + +This spec describes a way to specify tab colors in a profile in a way that will +be forward compatible with theming the Terminal. This spec will be largely +dedicated to the design of a single setting, but within the context of theming. + +## Inspiration + +Following the addition of the Tab Color Picker in [#3789], we've had numerous +requests for the ability to set the color of a tab directly within a profile. +While largely we're tracking theming in [#3327], including the specification of +a tab color, the theming spec ([#5772] )is very large and will take a while to +revise and approve. This spec is intended to pull a single point out from that +spec to make it more easily reviewable, and implement it in a way that will +continue working when we add support for themes in the future. + +## Solution Design + +To enable per-profile tab colors, we'll add a single setting: `tabColor`. For +now[[1](#user-content-footnote-1)], this setting will accept any +`#rrggbb` color string. + +Since each profile creates a `Pane` with a `TermControl`, we'll need to store +this color not in the `Tab`, but somewhere below `Pane`, so that when you switch +between Panes in a tab with different `tabColor`s, the color will update +automatically. When a new `TermControl` is created, we'll store this color in the +`TermControl`'s `Terminal` core. This is to support the future possibility of +setting the tab color via VT sequences. + +A Tab's color will be the result of layering a variety of sources, from the bottom up: + +Color | | Set by +-- | -- | -- +Runtime Color | _optional_ |Color Picker / `setTabColor` action +Control Tab Color | _optional_ | Profile's `tabColor`, or a color set by VT +Theme Tab Background | _optional_ | `tab.backgroundColor` in the theme +Tab Default Color | **default** | TabView in XAML + +Some examples: +* **Scenario 1**: The user has set `"tabColor": "#ff0000"` in their profile. + When they create tabs with that profile, instead of appearing in the default + color for the TabView, they'll be `#ff0000`. +* **Scenario 2**: The user has set `"tabColor": "#ff0000"` in their profile. + When they try to set the color for that tab (with the color picker) to + `#0000ff`, the tab's color is updated to reflect this new blue color. When + they clear the runtime color (with the color picker), the tab will return to + `#ff0000`. +* **Scenario 3**: The user has two profiles with colors set, one to `"tabColor": + "#ff0000"`, and the other with `"tabColor": "#00ff00"`. If they open these + profiles in two panes side-by side, the tab's color will update to reflect the + color from the currently-focused control. +* **Scenario 4**: The user has two profiles with colors set, one to `"tabColor": + "#ff0000"`, and the other with `"tabColor": "#00ff00"`. If they open these + profiles in two panes side-by side, and try to set the color for that tab + (with the color picker) to `#0000ff`, the tab's color is updated to reflect + this new blue color. Regardless of which pane is focused, the tab will be + blue. +* **Scenario 5**: The user has set `"tabColor": "#ff0000"` in their profile + ("Profile A"), and `"tab.backgroundColor": "#00ff00"`in their theme. When they + create tabs with "Profile A", the tabs will appear red. Other tabs (for + profiles without `tabColor` set) will appear green, using the color from the + theme. + + +## UI/UX Design + +In general, this is going to look exactly like the colored tabs look now. + +![preview](profile-tabColor-000.gif) + +## Capabilities + + + + + + + + + + + + + + + + + + + + + + +
Accessibility +N/A +
Security +N/A +
Reliability +No expected change +
Compatibility +This entire spec outlines how this feature is designed with a emphasis on future +compatibility. As such, there are no expected regressions in the future when we +do add support for themes. +
Performance, Power, and Efficiency +No expected change +
+ +## Potential Issues + +None expected. + +## Footnotes + +[1]: When full theming support is added, themes will +provide support for setting colors as one of a variety of values: + + * An `#rrggbb` string + * The system accent color + * The current background color of the Terminal + * A value from a given resource key from XAML + +When support for these other types of "smart" colors is added, then the profile +`tabColor` setting will also gracefully accept these values. + +## Future considerations + +* It's not out of the realm of possibility that someone might want to color each + _pane_'s color at runtime. In that case, the runtime color would be stored in + the `Pane`, not the `Tab`. + + + + + +[#1337]: https://github.com/microsoft/terminal/issues/1337 +[#3789]: https://github.com/microsoft/terminal/issues/3789 +[#3327]: https://github.com/microsoft/terminal/issues/3327 +[#5772]: https://github.com/microsoft/terminal/pull/5772 diff --git a/doc/specs/#1337 - Per-Profile Tab Colors/profile-tabColor-000.gif b/doc/specs/#1337 - Per-Profile Tab Colors/profile-tabColor-000.gif new file mode 100644 index 0000000000000000000000000000000000000000..2b3e04a65131d6729ae886aa2f4622105be2992f GIT binary patch literal 835167 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%0A*SZ{2<(k@hxlg{vbprt$#u=C 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 z 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

4e$*P@GlMs91aNH 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%0A5Ofu2a5D~?DEg=D+!D-5P}FKKn4=|1d`wa ziIM&cDv+BhU;;4e1{bOv45k%;1ETcTKydsE6tIH&N*ILb^v7ESK)HfwIfE#3gWNlV zF0#-j5>KM?Vs9VBZ7VYtcro0Wbu$y;iWwap?QU zfLjTT3u7oGE{q5q>bDX^H-T36q4#X2xzis8_jrBM;&gHnjIAN$s(Xv3y{P_b=93w8_ydq#oBU@V>xgiK@ZZtw_w%GAZ;1mjil$d1(dYm{L3*aG9Yys zxL6Cbifs)*;?po!b@v2}>fodOLzi{yQuwAl40Hq;;W?)T+tv`^QN3 zf5uS;6HD!t<9Pp1ShB=8PvUPQ+5bAX{~Aa6oXaLh_CA7czF|kF7Wy7`esc3Vvd&!_ zONW=@Xaf)6+*o2`o-DlQ>?^yl82#Dl>9z#9$7(Fv_Rh;&UuVXmMz=o79-Db=INeFH zvROta=;O6fYQLLwt?fFLL4uUr`iXqt^?C5HfeBsP^(7v;of(w(-WYi2b*xg5o1bXv zlTY`*l0N<*B@J$boq6dZ+E(U&j1@*)HZ<+J>{U(Ibi)QRa&1qZEk1zVj1#H*xb->s zb@P(j?)>s~;$_#%{z;AiyMQD^--N`;6osDIV?&N*y`npI5Z=&nPvQoCAe6*_hyKCA zy4pSQ9S2T3>j3`)<0p2!iRsU{?(xw}d`&ztCpxXb#dts&5%6fzH$m3XI!U3)&`WJc zLn0Y=fr%(BzCs>Lcq4DFe3duPLn~;Y&v=TND%#vhsM050UeBN)_jTxQQ%YPYFA2Tn zVUl2)l@oVgGHF26N+2PvTLLZs$|&1makagaq7Vry`le-{L}RCTWlUQM;GC^{5Z1WM z8=IH&2fAg&$)|?QyToj-6p)Br=5rTK78u#4>&KD0Xu@onvGVq46IS}RP)9J>p2UI3 zV`te)Bpz06vQYPM>goXQxnsS-=;!!-w`n<4_($`4vdfQ_&7$AC*6g=U6IzY0gMYRk zO}YGhi{B{!`R@Gq`%_if3*kwl9+LX7b_h9oPiI+jXRmvif?%tSw9XW*eBe;w@c~+6 z(qm(i5t*RL&}7;(AdoEr$lbb78`i(3^l8#uMJ!Zw$bYuJ`ZhHzN39<@U~ippxl`e8 zDQ&`fr(d`J;gP8f*!6HwCz$4$7S2?}_#+f-^Kppmr)0-4G@MP!h-9A@KKodc?dE5j z6p=dvqCdXpbjE*)UykA6W0C|{jE5q=ws zZ(=*DTQ~Vd@>csmgBAZxco6zp^>SH${118OQu344Sj+^B`)hxfi5DkZhe9+DNu(u# z86SLmKqQDPpYt|I>s_SpFc+0PsexBuLjM-}NgI@9lcXd9=5ycduuTrq*nbf43<1h9gX6XEEXJb zzH^v1HOwc~R66p+^DtE%vmn%`J?fcun6ar>EIU0g`n>hfJ;@Y9GjbXMX4QMN_)>kn z$LVrZa2)$wiPgHP1X*+K)%t^2$mZEGXFV9;&bi9Rs}Q>jsrJ`dyVVF>td{a)A`0@H z>`O{jyQK8FO*xtAN_O(L;5`jv3H;tA$|29oVrJYNDt}JFk=#0}i)U?4>-?>b8NJ^7AA}SXuGh?RB%oC#G0XimU8VYPw z&y4oIqq|wEpyy@C8RXzFf9QNcf)w@YO)4VM7F1W1R*H#=!;nbit!^Gq3H5pxn&2Q@ z%0m5Tw~|9KEY<^`5-mI~ybCV#1#}ct<*=}VI=MFcT@pD%H-%)GdxvaSZ6xWVm-LPH z>j~46%of#ee~s30zY$b@z6}?|MlsUXS(^w7nf69|xOSAUKD;Q2&#IN=>Y*$6;=0y} z(4mM?n!Gz^FkdGW^gWQuEz9xOFVh{RJ@PZG4`2P!M> z0d(o0%oZ9F0-X37N;wd6i@hWIVZ|!TH$11r2Qe&sb&cx~-v{iA#YQgxJl}BxY{p{Y z6Af!|%7I3-9-gWNB5)Cp4saO(7z4k4h%`7N%Rk?X|= ziA)RsScP(55C^_aRh82*WSwa|1WOWma`#&bYwJWT)=QOI|2h@Y>SM7?T`sZbV|tFc z$sD31RrZmsVE@2R8H%^E)uWw4jOKWF92+Vg>$|vJMT$#)Xes}fjk^!bdSxe~y&}8T zL6@^E%GEiY!Ni1fDhSSQhEPIpo7%cPTOtuEt~&(?Cs17w?2n9SzQ;B7U@rCe+m4>s z`oWi`+zyXC;}!f;h!BBH&m2_KXuUf>HSj;wOC_A0m1uEe>7~$&Ipe{(g4Af>3Cu<^X4w06{AGQJ((JZ;B7q?lP_1J>Xk$zeOS<9D{TF<$jQ@+C7iXo zY;`QxdZWYq%-1?;x0Mxtg4XaJaogc6Pf=po#Z87ohWF3OTkDcgIAg~YpUq+HL<>lUxo<9Sn zH+huLBcTk6?Rbwb14N*v?)KAXA19i`6W*O?zxY0FHh-zD__p=M>WbO#8%oQ+eZOt# zPCoki=f2|6zOL~7(VBM(umo;S46E9?uH+CS$8Y z)S`{BdrWEN$N^rY2`?%UaT^pYwk$I z9+eynuVobptCq-!&u_RovzanTc%23Bm3~dW`+VzbifyRi2F@;1eIwPesB|OEwQ*}B z-Ti~$w+yc-r*D})8>Qc}{ExT3Wd{-oZRViqoi}qad}W(?QBvER`LP;8TLp>c&Rd1J zM`c?@8PB)3igQARwo3|G_5 z{EHKR!yFzr*uSdU25E(j>b0#_mGss?nrszBs`5)_3P- zaU1OvW|uEJ45I6A<3u8-gre)VCY=;CpGdXdsv0Y?A2J_d5T2e&wj25~lG2*-k^EjPC5tr5c(gXcBUP(bvgl1J8rEOMK&6&pz< zSj82c3uELLP%_FP53r{=%WP$tB%YZ?4a(P+HZmEapPw{g zJF{MdHukc1wy2|6ipIR#e(OPX^uZUWr#<|-^7Or?6O5G@&L2pDzMj%r;))|x?}2^; zbHtkgvY|uMQ6as=*oua*00?m;GHtSX1P>=^4&re(JL-rS2NhT|_` zRIl)hF^2DcZDhyzpKUjNnF8qw@LrxDO+UT7IC@R{UmZj>VBqS-3jFh8DUhmveb`B; z$gVnwxViz= z2(CLzdBorB3onjSUDa?_V1~KZI$k=_8Kyt^uwF&%N2j zk_H%Y=r~iStA}(qY(VV5tBxX;9EB{9tRdkUHq$A)HYR4lg&)XB5%IE%g4&9I7MXTc9QK-ulJI)2G)+9QGFTqd?^gEe*f8GY3Wh7prTG98IY0pcCS z3Lm-0CG~6V4aM_dm(FInVdjYNyy3ffx`>@>35WaYLedWLTE`DZy)DFOib{uP>PGUv zk)p4K#tB5MfGP$LBO+_>sk>NYZHWiU@5HiTUAH+;mK+ns>-p3^`CN->hP|O41s##C zFY`=n4;j_1*0$!CQ;Ww5OB`B{)8%Ws3f#;@%k@s!zC2Bp@5|mAY;xyXt zza}0Is^Yi$wg(99LmpbDRMhHZODC^!#i>kbthZ5GI&(&udoRS+4(tiXDDQaH?Slln zA5mQ=Z5kdQatay3%3hQTFTZfA6$Eg(o;w~DlwC5FWnZi7ye5TpcXvCDiKPc5cSH|! z<9`}=*O@&Ry>w#}%li{PAhb*YT;p4;zBcY#hV{cs9lOfuE9$e{K-x+ZZtiZsI3Ndg9pL{qdo4!(>$t9-%-rNVXPGkdN14Zyu9Z6 zr6G>pkCesqYfSZjkZRqJ*2Q30BSrgUKYDON!mqKPlxWI`qp|<(B+df=0d;{|{?~Ev z9|n)OUxNC|NgS#jf0wqzBaoMmMU9WP)?-e?%9`L#%M4jTe+vC|N=9{YZn+duLIZpL zc*`yYnp{&-40u7KlNO9B~dR z>&KAK(p&lOR2wM z3=4m0(_Vxbzq;@mw2yH}$bY6N@LN}@v`ZKx1Gj8kEqu!NnNj?>yEKU5%?IIL25wb_GmND-qgf;Jooen08fw643rqko7r4M?x2-9ot@ z#ELj~9jg6keLOg|TFfZ|GZIeeF4sTiGR!PZU5>?R%3A!eGe}hpWgp;O zscDpFI=8=_!7iS>os~j0Y1EV`eqU@swJyM4Drw6|lQo>)Q{Gj2sn1}i1a zRCqtl5+~raCZhV7BSu2x`eQea$Zb|yUI11lQPT5%-Zxj+#YtPR@OAMJ`CX=7 z@5sE1*J)GkHU4q$Bc7{YpHcok2Dp2NCDDK5W$VtV9$~`XHDKRTTE>DK?wF)5IPL{{ z=J6=`8{iV0Tb%n_uDtt*A;~+NZ})}TPXg7UE_yPj00ky`EP6YQ&h_?-YBNy zx$-7B-qY+4w_V?2!?%!rRhrwmr(QxW_3%bn>Wjqk;br?2cOek@Lq$x_*+2EjGOXRGASM8zDw=e+~CX@dVbn#kA;>xKxXv}*0?Wt48l!NN2(7BmYSjNF2& zP{s{4K8^bUabuQiNW<>B4{_lS3zuoyKq{0J2RaYgdwFRVlSvt#j zp>Q-Bbg;i@q9@9(r~pvD{(MXy!2_3%r<#@0(#j-*O(R4QoBmP@(1qUH7!Heos(etA zAH}1O4Wl=GF%(oa_u!1?OSdLqvYoiIPlkh0_oMT+Noe=-cqU9kAI|)wrlmPkEI-kH z3e(s2pLtj3`+iGnQhBPpcP4Vd*!im{pgj!6?NTT%XOF-jG_{!$ie%@#L#ydKs=5x> zn1T(jc6_ELepTnIhW%AFplTX%S<~;cZY{O9N~cR5h)-0l#;7Tj`p{pkIL{jJv!87t;D5-8zft} z5a8#vT*6R{5+@y|EPcbXHZMd7ofo{)j|@g!sPNQgaKf|Uy2}r(@%vm6ZO9PZ3Qky^ zDD5lAU^#dpIm+Lg*>{wsn^cAG)R4M8~@{eaF4f{JHdyUHyvAS1trf$iCkJ-oT7;K2P@0+G@0$}V|G?1gB^ zdwTbf&wc7aJB11DDpi!p-iJZt;Gvq$I**2d6h=!W*S5)(qu-gxP!nE9qP}32w1Vyk zKGt)?FTVKv-2pAP#R34K$HC_WG|*ng8sta+dQ+w>&Q=L5)*E$yVLU@+dFm6EkJ2L{hpECJ0C9IB+d)|G_ zAPJZZ^7l;rOn4$9`8y{v!3Tr*}4-JjUgJ6(ulh% zerGLNY2VXCw{FxWle=d3$M~Lq7~nisXFYyT6;ZXKk%B{Q?r|6F>zq&e^pF@5+$gNq zvBVPcJ5QVI%4S7)lYq;!vJHBzOawTJ;QXE9nRJ9aF681$;n@n%BVC_Ex1aFUCC>~U@$O}J9 zCHG>AKQSwM_Xq;qeZ7@!z1@60l69R3;S3O|4FtHo!bd%u9(@}|0j*3y+AC_ywxQ;N zVeNt;{I-6FSw0QNfw?ikSXSOfkMe(G+$XZU6^;R?iosoaLFlXg{EEU9N^l5xo)S-? z6Y_xwcA+_s!E<`jyrThrioP*zVeCTT^~b^5?Eux|z}`pi$C!X#MVbCZaRg~KnL8yb zW+jVNC-!S4`zIO0W`r*~Dj?bDRK!nY0&tr|2-1H3HT%(qI`VGBh%OaE^vNm?v1&yn z;>Ad@v1rQoNcPFFV)>Tln6k9!&=ZqL205?q(ont_HzhS@YoS;);6X$z%X^Vy1xcEF zHG3tsl6D6nIpE@cbP%Je?VYrtkN&V10>DnacFZL2Rw<4k?x_hO0!`VaLa$#*&$by9 zdm@6;Y%uU-OvGqWfCh3_h@bx;62%V7pTrm5bG- zkMBf-=gCs3t`HA<)6*cww$mqgl_o8Kg+|BXWC-P|+haCYlR8R8o6&%^rG{UA$mO*g zcrwUPS;ZI2Nu^gLX*Yvjzkq_2L|ygcUWKee#}FvWK}>SMFU>CR#$(=9rk*Rv(F(^h zkeCtw;hbg`Kom*N-lJzZ#Qy_xSekMemK+pcAF>7n_l!g0^Z;2aQdclk z-&$n=!mfL)EChWun}jH2X)R|M=yfZYbMb7HR~gX#3_)hjO@7Y3Tgy&mfex$z(${jb z1i|1n&xFcc%=LUFru;t;cWjJcE@toJwfw?U$c1tw`FgIj9u%M`nS`F7Cmhju>YmEt z8;@Q@oL%?_0=))!Aa#Nnv-5$F0^%6=5?LJz)QD{ZkJNDpe;k->BAbJ?@Z)ISFZ+B6 z)B-qSuU~6<8dbT`YhI#{5Q~^>i<=r4 zHg=ROtrQtNm9d{?K8)wyDVI(PXKOtgRTz}YGC@mD{rL?8k58jI&^?G@OknORXu)&g z@N-Cg2b7?*z|{e=3dqkPcp&?ih-QUdYM1zsddX%Ki+3uQ8wO@Q zXS=*T*RUFF5SETn%#KkBg;esbf(PxZ%>2vxmLlcfTDm53P+2S7MRJDQHR!2vmoOsA z(Y?AVbN8}phB2xtk1N{a3fWg7(aMz+aaB%dMU=ip%B&T==-tbYGVq8z=YoTNU{PXWD4h+b9gn|12J zM7jJUWJuWiI}7xIq_mpIcbp}HTn`s~R}au>b9-tI0gIxmHmr5Fl|45}k^y~lMCdfy zBc9+jx@|aDL2lG1GbQ5Tx$xPaVrd$g2VFfn~dF ze8U}I2dKCqy~_cZ(*`kUuZ=G=6K(!5*(4R84Kr*c;-1>=|_hVu0H|hu7Dt$H|dnLkdPtDsCIn$jgO(q)+F#*jXm=&SxKs1mt;@74v z%O+F(=C-p~g6b|RwpeY^7T*n^+mldaeDk;{!U}!=czpBGq*SPCi#lU{6kGqNfNae3 zE{u&9XmNXK^MKD}b170k(aR7G+t7(>y~0a+6lTk+>L7ubi{fT`Im_qj`1;VeIBouh zT)STJi)QNTzPH5r`%{~mXhTy#wS3NyKzC=j(D!8e?(z7yD&1bH{-#Mf6_tzOtn-Wt zoxZP=Lw4(fbXY^^Fa5EL;Bai5JZ%}w}Q2YPP0jw}14 zTti+C5g{6nF&O`h*&Q!B%0AaX29*Kr_nJXllyceza%8xt`b(|)_Zb_KeO#i%aB-mp zpum!pi%PDk(nry1;P`l9O{J9J)ad4TqJMEhM*(JB_XMb0ZN0sEs@XZPA?V`!H^heO zbCF6_iAv1j$=J5XjTW1W-sbB1PV%-AGBD(HDrODrPCl*lSUNvm02Bk~feMm=vmnUS zl%^`n44MK`t5*j!4(w)yy)jzFPT5;|V z1~v4m&3z=AA{Ln{Gnlf?T^e_4Dj|a)-M}v!&VPv;i$3i|%w5h69K)P0O;oGE*ea0x zG@e~kAZ}71f?a;Qx$rM=R&i@Q;<9MCY92st=5lIKipY*{;RF^T8+f5NTkKw!CwrYqRP=jdm3X;)Bf_!O~jO+?$ggjkG8kB zo*x*^9I&e&nD-tE&FrgD_PYq-%Dgs7*2S^~H|R^m>gVl;iX7XiA7Q=hE4?aVPfmQw zi#AaOwOn+Xs5eN$Bo4){(rj@WE{u;Xr;qL14}qLVn}OT$iTj&sC)PMIhU%xz?S~N~ z-}Gk^&0kxLIS*z_`XjgZBwy7k;tvNzJJ$IQ#W~Lc{U)lnqXjO`id+s!L{ACTB!~Tu zSYJ<}Gy5*;$M$F~qrn$huNTXk`=5Ic%`f&961!D!noBrOWM_^!O^;YPoAuQ%Tqv)O z)DJKME^HEKSaHsOY)?=4wa9HBKU`h9DD5lt#(c*)3%@!`b@{a{)+-J@L^QkLO}y;b z9<_fR@!CF!iodj1T8ef&d;qs}1pjhIzwVp4LIz&u&K#g)Uj5kKQ=!~X5AL_?Jt+=6 zYroq2(p%37>o`1kg|~bCEmOC*zIkr=qk-*ny{Jo)u<3r9`f%Y)%ty(Ct>A{WnZx?v z->ojcy@JoDO_PN$_TsNDi=A#iCN%`UUJsuPeXl#XuWR8kO#=3w2!DGJyJ{FsoG?v1 zI>@{Km3J6QcJ#4MzDDd+G2nQv?wiZjP`-M7v(Y)*+o;U>`bF@qL~mz{L|2;niAUaH zhv{J`F6)l8LY@eJ9fzA9E_XjjbX>RgUDbU)opd?!qYsOqr}5~#5`}j0>;{tP#gf}k@$5D8sa)eOp2H#)OC``% zkXh5eY9wn!;8_1@VA3h0ohFoHO|70wq6+qi67hDJCGhb5h%GuO`#E3i8@`yKUWv}2 zR#M_2+kGTzjTEYw4`}gdx>LlrQGV0gQLj&R_jeE3O071B1+ou?2j2mEK%*7@MqT?uw6?{ zJlAEPE4R$wK2%;}*{T!;{-QYdVbgdRi)YHu>8aef(IhLMj_-X=UaV@q$7M^B*d0W4 zt2}k8;$&)ASDoZ|($~gmxbGyG;H^WWSCx9@PfMtK>d#J=TmhwiuIzJany7vk;t0EYwj_p$Ny``0lP?8P(uj*E@$?5*(*dfi{tyPhDr1LU9kIy;LtS3VGq_^=SHzIT{ zFtP8+o{Md?368(NF%+s|l?W3#;wt`{l2NatJ#6~S&l5%4#KE^{%ptcL-sm!&L%rxw z(HTnTtl2Bp;@b6%`a7%Si=j47bqOv5*XMFx@>xEn;>OyBU19;Be%Te*w*x9g&SGB3|R*G0|=Ra6{dLxP7S2RBHg|_2c5be-}_G8UX#b_gwRLXv$%i`Ud)|kQQvdJ3PQB4wbsn}YBV6ugX0jR?n;doQX4QnMXV}J7 zID%^f5{aC?(z?_qSK%x+d4OIy2F9hY*ptQmxbcF0x!X9ul6idNL*QH>e}C2N_(AbpwRvB? z_FtY*8@^2qZ93W~5Z5wI+-|ZUSd=2(z0G1Gy@tPVj{Hyn{Ut6wwMZP}Dgovxa<2L% zvN?B%#ai(1**m8yEw+~TXq=k{iw69|1vnHMytros>Ql5IjgWC!UItY&erILi0i*ih>nzv?G<3=YLL8r=#; zx%eo|n3BdMdSu3-Y4D||qZ(dPfl}8p$S&ki_z;DTaj5#zQ5mZ^IU#$bIRGA2q23_d z7|ths2y4dH3qiG;(War(TS@=(?e=8%2Z^sKt}#b1G=H`kbK2bM9(ZIrMENngVAlQf^p&Pg zw`Fve~B*ZZ8LlsFldNpji-2-zhj4hnY$-*1vD<+&~k1tSrhj}U-g4ZYsA9K zUe_G~!cJ7C90_lk|H(wK`anu6c0DpNp7bDxboWjJdoVtHu7&YM{7~k_ADftkS(}zq zsfexdht-p%GF|Rxp2q{N)Q8GR7FK14lddIGG*&WjrwxA@ga%d+dO8=&%fc>__Cq;< zuIH17f;AIgb(KV%GMU7YE}|1{)fJlXdIeArgpRW)M&GYcsV}+ z71~0j5p{0Qbn2FmD&;x@)w$C=&7{Lry4T((sUeQ55tY`f+P@T*PN;shJbcs&TcfFa zU7!+Unk%p8b=K-CuRs6jWIgEs(JXf=0;e!{N6Bc?D+m6K9DYG6H*&bLK8`L7$y+uZ)Cv|-~fi5VA=9S@)|@F5(tfwTt=QG6h^MJ zTXQYN8QA97FYw=sH7xwuaI#visxK?}tuX@nv8Ektq{Q3RI9Cq#pij_8`DoSp?5lM7 zwL#2@i&2)Pk#%W3acflUiR6o#&c7pdZOg&G(xToulmsA(f3?d7-nz-o%Oesi9MTy6 zJ4Qtq3_}RtL0Uc>mfuqSADAqtcy zUP;^GwOwFI2tT>zONC#vOFC!&@J3FC#h` z%17n@dr(qwEG9ypd%@q5UC(M>99u=`e9pwMMn!0t9c)>+c7yjPGzqyW7f0p8G;Tp0 zkjY)M!jhyB(}Akxg#-tqML(t9mrf8AKt7z(^FBNN18Iu_jVQ52&sb^|rszi&+Hdlc zIemT=xZ~)2BDHLWjfjP*e@?)Mo+*rmyt*uu9r(CKs**mp4d3ASYQ}Qu)v*35k<5)z zsAtoe;T2;5Bpe_tZtl2}@ci*4OcopLupYkVLp(x3_X>HVTm`!KuHgm!BrL1(qW7UG z4;|T`&MRnvcx8j>6rOY@XH3_)Q0=tDM?^t1HiPNxvtLUBuRW!uP(2 z#(R=lG*#FqU~s3X>IFA>nI~yii*$Q&fV8vY`YG!d9K9A2IN*=i(|PLY7{3;h)Y>9W zw0Tl%YUvlR^qWG)nL>!cj}Lc%q`*`TorQEIdycotgKUe$QUY+BBL~4=S5FvbiE_tT z0R|E&914b5GF`cnOtbsl2W0eeSa3kfc(EM13`^)dpTtY%O_`4NyHI7- zu7rtIr7Br9!(cvvQstNU^kU`LY~~w+kxy#9jW6svz^>kFo`s3Q`YB0|!Pf9|6_la0 zD;kQt^AvCTY87@i;d2QYa**V>lsmjK{XS1Pi*m->9wrs3Z4i@EuFOc~)gz%_w<|BZ z;IKeX?P;%+G49~97pBA_DezDk*J`R?6I8_*>>(L^w~>OY-OIa~gHP8|$wwJSlFW{k z_tApw2|k1EhbT4%FDH~1Mt&Ywg*Jp_G}Ht?A`hwiA)Fd6Eb_-5$IXIP*pYH{H{Wv) z=%tn9{fCO4wD7CBFq&mP4MvOoOFp}1VW?VB8dgH2Hpvvf8fb0e+{hHFno`a6{_gEad_&`eB?>0H2270VV; z3sHr0vtDD1r}?-OYPrC#wKyO;`0czneQY;r1d)pXzJ!AmSH?oH?54FrYgS$>FMOAt zJ&pc-MBo0R!pe>UY-+Pn|Li*{K`%?jyx9IH{QGH+=7l-)MY4b?{i0!_gc0I0u=`!ghO>6;t4Y58`f0Z=zzL<%)i8HK)Irex%Ooc!tgGdbI+GOl18jr~WzWH7v zp26V349j@cCfmP|1=Z+$S{4xqh5_oxPU8U_5SYCTrD#NS{B0Uk(wp^ zyKsM}tHQ&J_n~Put|22W1?kr%{PDVK|1oI`b5P=|H-E&eP?)IWjy zLut2gS40M73UY4WZ`#Iona%ej{<7HYYglCnfE*Gg3>!~EX4&v51(Q#(v;e`W*Jn$>BvtNW*_HRY1-8MZr<>~{t6Be5pWF;IFWJtI%o46z4oaVR_pDPTk}k3ow4 z>_=#oaS=p~#m+Og;b}MGyPfXH1$0-%kt-{i3naB=JP|4#@HSd6y;~ZQB3yO@u+9``+TGkI(R6ss zK`IkB*}X|0-we=J%aLb7CsWL5*@z1Dg@)p!L?O`{tsl_x}*HL!X%xCx=paabZA*ZtXWU zxp1z)Ghc@+bwh{oBCbjmyOBfPrChhO1aAvh5#e4$qLW3U=yR2AgZln=6-^@(WdV|r zuk3{m`W72G#WgV{vKA)Y{(E+73E5+O z+3jm%4PD*U+|=1PERuM@SvJ>s+3$98#Y^Q zXgL3OkBQ2s9%=O6*SPZDV8fek2%-^K#-sIp6Kv6u@2j_KVTJ;;baw*0X0TiS; z=>c^Ofr-D%@;t5&R2Cdym&vL%zD5y$>cJBj+fx=l3Ypq};V!%vMIvn3AKBo{eF zm5qNU4K%-hN*c0}c(OTe%%Gm8xgRg{S;VP-?sIFQCS+VWcs~Fm$LX8(6U<|Y^Vv%E z)lF-(D6Hnq@|Qmke=!&9_(ZmAtWNc~&`l|8n{{qf0!MEXy2nG$LQB0dXcG1{@E>W= z_W=zAd^U_a0+YRnU0M{U#&fq;BQ*euL~1(*&cDMmvKt4Q#k~4Nqj%Pm@h?TCBila+ z*it?(x8c;wr#X%(Fjfz6C*xm}R zk4C5wn`Va|T@VW<21bF=)BDjfiDS{EKQ5cXHC0ME zO>TymT^|$+K!=8UbERn(ZBHO=r4G#{jioV7AIb*J&$Z$^Z48CW<3zjq#x4D=JDNdB*{{XLE`V5 z&^HpDO_!6L^`^Zy%l{2u`-xi=K>0gf6T4h;r}x=F_UbrOzI4eftd*@*^I68@vg=KnJgv{bMBm+-4hVWG<8|Co?-{}Yw)yFIJj(24!|hDu;k{y!+- zKT;Fv{}u)OAe@RN&Ql@ZG}Vs8_NGVsb#W2uFCpmBHfCu^Lih8s5qFf8EO343-)pDvo_F&7u#5wV?h4 z!E#T?+;~YlXn>l$=m+6@;!5+0l=sBuY2so)gpAqCHu^A`A~&-D7aIV5rmGCV1~LQh zTMqG=0Tx9OU#;!M`!(uS#J1mL**eiccdXUL8?WgK{sB%*E00()TT)Pqf!=@6nJD&>uETdRqtwGr+S-zLTOhERo}=$>^)H&PQ&a>z=*} zufaxPou<}wg4MlW@0Z5|CyzXW9b6f7u(?&?RD-n zuOH)F_TTkv-IwS5dcE$QTLkdMbNYWkCzWSg3IozIAR1rvGqE4c$2;{jnLxCb#ilj6 zEXPPTgS6xtPNLNHPQuYp(Dm9t;xm5q2R|G0_}VHC(G-O(&@kB%hR6pvWdMlg6~wlp zM?9R?lXNtfuqQ!r)J~wm%`HuP=i5vc_f4Rf*zyYHlknC(ciaG}=0nL+aauwo5@Nv; z9BHZa7Re1zA~Jul*Jt=0Zwk=gf4_J8WavNmy*$6bX($8%u8;5#a$J(C(CCq_U9)SHwq)6DQkqJOqw znPAG4`t;5{RL1V>$TQ7iki&v8OZ=&_QR@vfh2S&V@+os=m^=N)K$HINGBuo{_yqBb zGT}G4ao{9{Aag!`|8})q^tKQ$p%pV*mUj-pg;G1Ik^PW`!f*O6YB5BK7bMyppTdsL;GUUq#}r&k$k3yZq9zZTUSaKde(ghGh$ zBjceTRq%yHBMC!0=eJHJ>%TH71&512od#9gBrb45HzJ}G=5D%H0cdqcvE!Bk_I+`L+>h)*tLOlf{NO}uaM?PjY z*k~x>O%+VT3sED->#|$%ZLIR*o~l`o4N<%u`RB7+n~Nzp96mc5F12Ph*NWFrO9T0Q zU^vv#HNai@Iu+$@j2ZWDUQ`$pJ3y27kL@F$I6bneH;;JR+O?D6ZzuYr&RPpQS9>^p z+9r`NZG5}7r?2q+c6xcecK=iO)gl~rt6tEEqwy_p_9aRVhludMs%(h*eEmx2lNS+) z2;BmRQVd-wTEg+0xl-`O-jQbpY+{hD4CeLMM{_xC@~&oet}lgpH?ZxUXM%^f-h=i>(+1Q@E-lW z+Bm4aDHO*L{%O5U4&6a`%2dHSi|sFpQ1))uj=a0yr*0cgHR@>x7eu^BOiS|PwGlz} zZwZ*6?C#I>=WL$pOA@d!Rb>6wrlX@`05M7m&i;$t_Z9N*#Sl;%q#Wq#GhL|FrYNC? zL$jrBS#33&U%K95woBZ^wHfUhtr%`Q*SR$AD;<+!8m>madM5^mUCZo~^cZNgrsPiB z(G7)dK71-^q4>b2^omcr`fylQ`(ca{@5&zVVj*pv&5*RyxY`21I^@K5Jp zJ|g^??%<8*IT6kW(1vIjYX$X=_+!(6wQ(dR=XxL3FV}?^%$1LMsD~iT0aS|>)dX3< zVq3yMnK-qJA?5Gbi-Y*)kQUxZ!jj;UHlS3IV!BO$@&`mV3X zd9y-22(Xv_jT~f8O7ZonkzWf;xn@Fe3;W-k21FWWbi+0BXunR0wMy3C?8s0eAJe#W zPD^;`gsg4(`?vVGQg~jqhTYo-_r$qRNB!B${Wb8=G2qI%pYv#p+>hc1x^#MRp~zc{ zxBVNOqwc~$rFy1qi;XVyEydAN*FjtHWTgce%A4MOVJr9#wkn(Va5YP|>=qI*X`=oJ zFl)PRJ#QQE4ZhymC+_io{a5fWVVkS_<_SB?Z+6)%kqFTIo`dR|`j;1A!v}$GPE}V> zYVp0ho0rQ>l=(iY4Kdh!bjbnO?Bm(y;d~tYP!_z4?8`JN_m9yp=8Kz{qMe9>8=|i% z%eBP>QK%3&5SdxS%Su#}P5{Fl0bM_+!#aq(P0{_gpBlaYPeqU2QJ0z#F$O6UZb1uL zlz@7l;JawY>v9gSOj|*e=usOto)b@TMmyM%FaL5>fj}q%IPkBx{(EM{&=UK1siBap zuaL*k%wuL|#jpqK!1GLuV$@)(tT2iv^CqT%mIwb8SVpj2nTdOh4RD#`_pxa|qa}|} zp#P(5zmLcUD^{_)#QaRTX;t^~;0WH>)sGC4ZY^WAe;! z2ciIjF^{IUs16&~Un{a~6_!3<>;#FTF9n=zV{N4$ElrYwu& z@0f#nJ?Hi_+J?X7U_)4hk)uS&e%`8lI`#bk~m&{1a$en_E4H|zvw zFph`ajG4)c;!GYlaPsP>L}N z04jOwAV440d6E-JPDL_TRDXU9GWKQEXaj$4%PxqCCtC#*ty;5mWM@EJQ}umaY#hPk zsXpaQ$L_#s<^&t&=-}f_w6`B&-3WUaFhQon?GJK_S+R;DiRkKb3>F&Rj~MUMRe-E^ z{-6N#Z7?Tx6->Wo%%o_;k&JwK3}t7@d>w=Ev?0YCeEr90SH70(DQt#&=DD@z%N2@j zKb}2T<~25I=Bt-MwZ<{0mlGru$$w|B$r4X)&%cbGuFC9DI+|Y^lPXK#Z*bz{WD8=> zglr!|9LB@NeLTe~L&Do^2T-B~Gu@ID^L*C|k%)`ZS&SQGiw^8kh|t3ti8FFCgB~D- zRl+88&tUU2aCw#z19buDDdW<&*vZHB52LZ;v*Vg_iIZ?h_zK8IKOtnSq;}jXMmGbf zOr<3VN0pq2SMhZNC9GE`ha7fV)S8ybJQ_)FADhDB@s{XvF**+EM{x)j+T2d0Iz zdO~8Or7}&ofF&l^Y1Yf--;}M8V?9)e_2Pv~Tb|*&DxGmObG{A(qR!y^PAgOtT((Cu z#_cPUg)15L5QaKZhnPV^tO1slWqijHws8UI5KsTCa__SM5u4~JJyXGxDmkAxIEM^c zksvBuHU08xY#OkBc^$r8eh6`?wos}eB#f!j9Q-HjN47<6d6eN;<)~8H(@MZ!qQU~D zs^{ZO^sXwcv2wEP1a%STbo(+le!!38Y6D$wLy@4{wTgJ*nr?+kee`0>W9!-nKLl3a zrPAWoktFx>D3D!%6->c)pe=;`qyXg&fMO~k*a@K=FW+De?L8?CV+GLcz%SYYz8K=& ztf|r^C-yy8giSz)zURNJ<Gk)(!e>H3AMnh&%9I&&^ncfOggvIyc?(*f_m_j4p6ZlCnSPQP>D-{YFMG zJH!S;Qs44uUYuRd`;c3L;Rm)$>;Hn}9S|rV(6$K<*FY_`Eo$hg!fj`5$D{#=vbEfy zD+-9zr20e2Pa>n3JC0DBs`XsA1>kjwJsI@t{k78YvU9&GMSH6x2anoDfALFM&jygh zG`}zPZ;Uf~8+#5nNc>e9EkP1WCAr{4}%4AOu5SZK)kh>@cG!*E4{oXmyi`hLARq1q5!}^d4 zpHpTB^Rb{kf>7I=+MU!RvY2_1w&ALbbdMCSpJy{07jKL5)5Q(1er!SiQsKrvs^!z` zGzGnfT*2XH5zR3VcIva@VJgF0uSw&Ld zN;3PZFcsuu*Zt_(|1nM0b0l7`*}rReuv6VIdo)J53sbY=(reU>9Kqx)<&M;UPb|qe z-kef@D2KJaKi2g@)HP&%l&u1|14*+zsdXREE5>V|XK{k+`f0plgb^sYTdw1zH0_sjqK8k%Ql_SYh+d{;w+62LjQ=?Rv)Dj% z%%0G=jwN|dWRy1oH^G9q{OLN6(laq@i%lgTN9+Rd|8zEc6ee6qtOhZ>0xgkED zy)hxjx?W>{&64KKMz_i>kBZDNp*7@*Q6l*zYQrSHU?#W>tIOpX@-@sj6jfL#$_@we zP6D!CD9WDm_Rc4yUF_|Xo^36u?Mo9B>w*FxKeDO@io6DrH8=8;IPz-`lByJvd_B^u z36h)!iWc|JztcaFB#`B#cCdqgI$`~QuS1kCK$Htbe#iOq9p?^0@J~vYou{B3Dwm%k za64qdb#lqO>~*{PJBa$!KUuD~<&xi!t)HCRd)(@Xd=mTmJNs#Ci>Vxdvk3%A(8RAb zT+QcxT>a(#sx4fmY8K~jx@!nn-b#Av&;q9FFmWi(!{MjRQOC_;Y6Aq4YcErr0y8$K zsrnJlm#>@bM^YrKL4Ow=K}RzQ8#ddAMy5xY7)Mj2Cz8&`Zk)&3PPJ(;?3zf@jL@7S z|ED1&o>ASG8T0Kax2wZy;IVJsf{|$(1jpa@wWV>Q2BT&uKk;-s;4HQ-J2d^MWadl< zc%*H7IHi2nSa;S?cNR2UqqlvQtA48g5+hzyicj99(RG4BV=XzA5>t2DDsiTTRtd>F zg3M^tzMcVIPirVIs2$Fp){fRW4|@~O%3aO}OxunqPfmKTw0gUo>#pkRE^F9}hI9Ay7$h zOY@j9uFT)&OGxv%-3m(Ha);bWzPnX0yX8;5<|5-aV`P!PQ3P~;+$oxPQRcbmMv8AG`&@wd9sZthp-2}pg}xUFj$@)o+I*nI!u ze2)@h_9cSr$wK$3CdWg+Ko8XSl=$;08TOP)^$f~?GI&4+=RarnJwty!=OsOB!&Me$ zpq7~ZDGT{ik^iSEAGPLX?kfl2?@V)o>2JdS1!h2*zahaXkJ$qR*6og;WsnNK|ND^e z`>7E8z%Ts9Z~VmX`@tXjkzEEF@chsp{n9`E)L;G2Z~0~L0@}a*D*v$k-v9mJ{{r35 z{os$n#Tg6epZ@B<{_NlW?vMT*J@F7mW=qTH8=LaAAAybjz>|*d08s*kz!oh~7@Ptr zl|nqc=n$jEDFp|jD5F8-NRlN@oBt8 znbT&>G6D&fi4|1nP@+YR9u3;_qsJ0H4YnW{;)4egBS;MJ;9Su-iH-=-^I(XiTcW@BY_S=PB{flI*c~OYJv=>$ReALvZipmj5`fC z^NBY6+zP>h_DoBUE7#Ur%`~oH`@n+P>MMvg`wnWUuDfpZ%Rh+t67H@kJWTMU3lkThGI6WaP;}2kv|5ypAo_6o>?8dI^v|J& zdh89r9R>W6r65Ndl1L5mJgJPf5Uh?dC8v{&LYcfvZ2w9{W9i95`;3dq0@+4*t*aBk zJnz!jrpih_rf~bTLy+do>&*dqOT|L*kHT+EKOrU4N98O_cGHc z8X1RRD9g%m$t){c6I->6C8|%YiT@%1`j+PIqAEHO4kV&m5Odm+u6JRtT@p%C zyc9^a16^q;SaK1}v~oKNlEq&G;8I!&*Otk}MQ3aC8Jtd~IpZ;pSQL|9#Q=yd)!mJN zd2^w!x;Mk4a0Y&#q0e|Eb)qh*2UBSA*OsQ@skhurcxT(qwz##qg^?<5r2`#dqL>nM zo$Eo`tD^Q`xVJ1sPHJ3C%JA-$rYyOJUoGp}RklVIPQ55p`1w;A@V7*@;mBJI^9%n_ z7)3q_4rxxyVhcHzlPb9mkyHW?Bd;bE5ut@&xnqy{{#6w%l?ha9fs{bjltkeqjFWN+ zPQnayBovlJdWXqmAg#AL)KSNauK#?cP%3k-t9`~rRB4T+c<3^&jUX$KBO6m}h_h}T z4{h~hqK^odm}V+xC4>_oud?{U0lt8NrOPHPNoJ6NqF_8QQ%{L51tv#|Wh#*C%m{v`_RVa3cMC8a!IJlA-RBMzvA9^sAniFlx0}$2V z)rbX0Z?#Q03-L|n-08&T)H69oqGFReHYg`q&!2+>NkE5EnIaM~G+l{J`WA}5(?rk% z?Q`ERgXbX!>SvQbZRc?sP2bsk?=KlvD%RHyh^Lc}zRp|WGAr?+Em4=c|A+@7dMp3V&$9jrX zVgpmIjEJz3M33*-xJWcX6k-(-*1FjJ)}6&w8=W`(Pq2CdM5O=B8ell0Vyk+!ss z0*!4$a8os^25}5kPi#x%saO^)lf{ImPf>*z68ea8xyhp*^<=BLBKLq9LnU;m8dcI( zZ9a??pOz@4C9UA{Yd>5WSIR`hZd%E#O(fMt9gC_qc}{L{P47KlrAp6Ilb@`MQhf;= zT`M(mONE7`%U(7b0Ryiyx4{y^G}jj$(UEOE`|Yt#2;u0BZlX+;rYe_ep)Kl_Ggd?K zL8i;H_fRsDhNUF?I{zis8d~c}7M%-#+?l_IJtSTNkTyZ!%E@u{7K_@-kNCO30#>lX~1so{QN1|VrG9qVk#V+PW?$^R$=mBFZ5!V}X=1(EA8k4hKbQrA?avQpI=HkcddgR=BYT9T(hpDx29Tj7BQ zAv^9(Gq@sEdmS?kU?5i4-L#V<-Ygxks39^MFq!L0W^4tfCnXv<<6C z!)_{>;SnA-%)vCt!ApcLG1Nr2>#kw}pG?FgOr)N&sk9fIw|VP8#p(=33qjThy7hP& z)L@@A5}s%yD|_k0Ce*}Coyu$AuPB9EWiRi@B%oH$(xi( znzTuroXMKh$)4Ovp!CUY0tuSLNu0z2rBuqLq)DfQN~mngsl)=KEQ2plfhp)4t;~YH z!Ah?DO0TSduO!Q?^vb@;O5pklIG_Wzyn{G!%eIuuw|vXEv`aW}OSq(iJCIAGq{15# zGTB(kF2P2|amCoMfZ(YXVl1>k5Cq4B%*T{W$&Ad(q)b7$%*aH8UtxpJ^vur$&Cd*k z&?HUJ^piiy0tQgc)nv`qbj{a;PTqa(eCI8W&6du}| zGg=WbF-bOx5kNeW%)CrUz)Z`OPChb1JCTv(5%qV+)mKE&`fE3&EEv3 zwnKp&YOU7`F~bZKtlG9SG_f*R(CM7c2fa+}bczY(Q0**D^VHBH_0El&m=I;s*gUEG zgi_lyQT(J*`h?PT157idrLmx?9&#j=jEzNOE*>J(IBbG>g z1M19#>TFOoeb6ms@jD^OO$L!UqcO?6O6$OH#G(Fu`Cbh~zmDNCHSlav%KRm7cYBXORC;t>#R}%TEC5xzO1STC# z)-y%cklj>4h|v28)j1tiI#pSLHO+Z4*n<_(Ul~_Hwbd$((pfcyb@N8*nXc)=Se7{- zh9aZ&sl6RUjQh$BPBqh!P1DTuf+p)%BCXaV^;fFxPy&2em}SpaDuWcI*+7j|-%LhO ztU|CkNv}vr^hl3h)mUI+siUn_%Y;^Y?NJ4V)@TKifrZnmwc5Q^Sv-vztqsvp1Bshe zQCbaK6g5!;!Bw|qix9EG(vYbvq>4%j8%nE|+EPX|aL{|D*9B!zLAZh^Vp+efQ&APw zY*kOeZO?=SSA`AN*uB+B#5Jf$nbumF;zXauLDw*ak^dGA6_D^zy3NDz%8BW-CD%x+J&uI0R~iuB^*U#B*@hgpu0B06xKy- z#$KG)e5GK!bymqF0~tHn(jC%&o!ZWP1B{bi|Ls#z31GxkT$)W>-K;zZN+;FQ5-&l! zjzf(S@m)@|w6gKo;+;%o4TR3MS2cawz_4G`U0J;?Papf#ACf%W_@4k)YQ5C)c?{sUHwH_{4GtvVd5sHUhuHq?FCx` zCe&prMzZnG##xcri(D>a~`q*F#Ez%(^RlP+|n>h|Srd|ME zSeqr_>&4C3@xyaL88q_a*vqA}4LPRhMcPUXGX7lmeNHol&YNqFl?~YEWnR<0Qw_#s z*Id=y@Z=P}+3UU8VOgxD@K1h;wV6^Vus91zp&8qg)Wk?+GH%~Y4Fr6pMx>m6pC1=p~p)$V0w%{?40iI(fKSZvd()>2MUkwcbXU*aWRGxp~(woWg| zfJ_oq55{HGz2%l|j&UwwJ2~eSZrFuwrT-|bmNbJY7MWp-Wfs7?;f!lW%aF`x6bA{1cX zYqntdP19yQ-cLmrHZEOo&fi>S1C`R&mwr`ECT56^=$qB!Nldh9yJ#&IvD2Vf%$>%u z;yE2XUZz%RY>wYG9b(HcU4!oC{IzTJbStcWRRS|-?1f!)7T4Ouj;1)^8H@^al^~*{ zpz>KC6@lQ5gUj9`2N#?kTvXnfQK92F7D?Zv%QXrbh-ekJYJk!jc! zS9N}915QFKZVRc9iuNI&jD8kG1J3vCT72kkqwjBRzyThsn{(^oM>*u?%Ls3R&n@k*3Il}BpppRcJP7a+8eizzpm-% zrs)ATN~oAr#T1V)Ra^4un*SKpC9H~OUpy125MxJ6RhmaPxv zZep%I=hqcx6xB0PRz@)Q@a$%@8MRSD9y`-=tGGsL&`od*?u`0{@FS*bO5WcmnsA4X zVki#unVrvx?!(j)Fw^kql;oGzc-O?5!P*LMxPDN8o=)tS1vzTNb_HKo;+Zx5;C z0uF4hF4Q+X)YP&m6R9>4dyUnyiZ8aREKS;bo%3cbW8%$Vll|sBAMPYZZhZQ5N0!yY z9d#)-TsI|f+uLa)KThqglzpj2YBAInCAA8!b&-|Mxo!y~Ug?7N_UFyk#Q1cd@KzqT zV;z^(R?6oW-jrZ%;Qtb&JrzmJlL^B++~+vI=FG;|%A{pGpK(pU>*qz)sxCCrUh7a7 z^#UGjL`ilRgdiht4|pFeE1bpg7&`(yFU4B&jc4)%SI|0F0b=q&rN4}0n)d$eEsweO=9 z@=h*jZ@Fh)FVIf9_e{G7%`uqMczFQ^h=9Kje83m{!YBO0AN<5O{K3DuiD86Lu!P6A zgif#oMSy%psQk+h1!-fyqrdbAKkQe3_iumQQ-A1#D(6E3DKNkN z>pdcPgYN?fG-c2%kwOrSlqCquNExV*$Qy!XN}y;#vBbrS8e6nL5yFB85*|Vh81SJa z%9JWgdie06nw8_khO8*io7pp}4@&nDbWG835TDdOVt~-BPy=eKeQM94=dd6ILuUD*~Q}Y!|Ic-|H zSM!bqytg)1s&V52=1rS+?7$m4emrc_Bx1&m35PrxGh}4Ren-z;owqVhxU8d=cFX;A z@av$vR&HIIH(AS2U0>HN*=_svcW0|z4|R4{-x~*8NPgVEaxNj~(g!276d7IKX(!cc znR#^?d=PfV*KQC>s9kO6-Ip6(R=t;7Y+aot+;1D=MVVOarRZ0QY?aX8e*_Mom~tf@ zHj-i^#Y946`C$iJ4>a^J!;nG>NhFa*9@zs5MFu(KlQS6kWDk`|>BEpoG6^LONz$<7 zm;X2QK6A2_(FdS>;p-_e%Ug)6*B%5m5X{MZdD(W4djtZ)#qU!O+PdJq^#uyX8 z8tbgGj`4-9w9eXvuCbZ{YpxSav{e~#jA1OY$0ob%vCSGg2eQdRt85uil>tW_abT-$ zw%cO+Ew|iy8!oupmXYG1e|bdUVU7XF*rNmJh+K4(QCL+Ov*^1ozy13AFTnavkFvJf>-0;E&XQ5pgjR2xC#~XXxF~}c_9J0m};Z=qukyw)Q%Ks`~ zvU1BYvploPF4MenwH93$7+@i^JEL&|GMZAmE*S`!a0{lEZ@^7E{qL|Bl|eDpRX=R7 z)mLksaMW6rv2hz;FU2y|lmr%yqB%eJp>S%vl zvWS<$T=(lU!#;Q2d)sXL-$12XTML7^w897@7#8WfixH;SO9n<-ug*$ybUEeG2b^Bvif+-tTNy1uZ#tLzzsK;2mdoFY9ph@ z0o{_(kOmgp>_#$@lO6&EcAYY4Z+i}WAosG8F|ny_d}-^L_`a6~Ysn5~@ynaa8nH4F zzU*#%o7=fmBOi?%YB0z<&hQv@l9nKk1(6y-bWTK{jT|t6(i_%ItOvm%V$ER>NMR5& z$TkX&Ph(~?TgNV@6S$R75hiTJDB@Pa^~nupBD932-Xk%J6&UKXuf=r3w``!{8kp~Sg_3vzB$N)PGP*n_aFch`UIUBhx&H^ol55tgATF7R zHq${-m*rca`?grgmc5LU!;Bp<<(5MH*oQcfDV+YIDZ>E;k8lE{6nc1vM^;u2H$sG9 zEo<31AV#i<=5%5qM;12oQv2)|-xk(gE-Chq)F#=F#}g>OtF;fCfC!x?4- z?dnk{Q)!WHa&vmO`Q{%ZO3u+CGMC^xXXzGsK6l2`i(Qmo%kTy}_F{#vfvP_;c!{;$0 zvB`a+B|kGMOyMGhION=ra57~ci`vpooa%8l5RIicBYMOI^8XTph|FNx%m#=lUW%-fqu%AzI?Ewa zkB{agD*4KmI*n??onicUjpIO95E2~Hkt$`(4MQ!< zuVIxodp+G+<~mz~DWFrR6}{j&MK%Qvc5!ceBOxY*S>2d9b#D`m4^({Sk{AF@t1V?r zL9u$g;NeiARLw|mg)1;?9oLT#>{<)55Z&iSce;6joBZ->NlezPm~y)(YDuceyFi6W z8ex(}A_Y?x2#=tK>0dPsIy{3Sw2T?KPkiOu*-P~_t^e3VnA`L+LD0griKTn789WSN zdP?$knN;c)t-C%H4wkA-+D{0CCp^WTV6mels6h*4Py=;%XFFS^e5VH+h}QRkn7x!b zvz%p%Zutv!opCZzdt)5`HGZ|5DueGb1LBB;1T2U_k>fl7BQwTukX15aXd1Y!+%(Dn z8!?ruyuGOs@|+m_!+t$RT0UyAgU1xGg0l1zx8C0iR{=SW0-JD{_5kX>Y5M> z_sW5Gpoy`UV$WLi#fkJKmpS%@eNs`H6qI<(nFogp*0L516{Zjtn>G5acRF{8V#4F0k2 zEDSW^^{*s|(dy7)EAoAlb=4$Z`h9o)wQW1Sx#5F)!d1LlGFOu3+x4I@OPE4of1NlX zxNu=&P?!rN?u8Q0vtCM6zse$gxC?}P-2eaE@{oxv>K;q6z8P*~hnM@K;l6G?OPX%L z=$yeND9oHoastJ3y6nb@R19|1BMtT_to`NW4>Y4D&w`qH$LT;kGkO= zrZI2scLF=S>#Kio8KKdI6&VS@8F}^3VR7H_@JO1S&sA6j+u@Ybwcnu8ng!h*28~Sy z7F8p784qdK{ejW_g`mWl-r(h2n!O(3h~MIQA9|^g{=~rXAWfBs+MY#VLrowBUJsyg zApLC~AfVf~Nt%w0pv~dmN0HF`8UNi~K-lYzfa0-0_$l5L+SX#h(Hq57ht;6hL16kR z5D)F3s#y!vVHEwnA61}C5ki%iO`7Q);S#D@M{LQ1yl0xoW4-jILl)y>Mp5oD7Gkzc9)f)*+UMKw)K<1GUzGC||UB`4D>d>E} z72_RAnnQM!flcBXZc!Zm-)}kCq2OLh%w9*TL;@z(jA+;#?UUCLVoCatwGm`NDx5cp zj7x$etvTfWky+r$WR9K7n)M?wwtx$$n^qhir^NtynI-Kpijf`8rv;+gQPonm(r}<8 z=5?JJAmk5DUAjr4E@IcX&D?f1o+fE(<{0S)13f?$Jb(tkrfkyYY{q77 z;^uAUCU5R08pxg6^a0tBjc|73aP~oPl8xFlLUAhRaV{s>n2(Avf+9qMBJ_bJD1stn z=XPFacXlUsYNsXifp>DJb&}_JmO(KZCNZ{W4^&Cdh2mKrASs4lG!2hiHlUBSz!Vfg z3Y0+^OhJIYK@ki@feJ(x3`7=8K^FXH87x5-pn-rE=z~(|5(Fr15CK9Y#1v@g5_G5( zOhG}E!4(j}6rh2Jx&cE>!HHgIhZ4k#Ug#ipsDOSb5hUmmZps_ z=!XvDgAN3MqW?jH5)BpuqJM#|Ye#@S&5cpuX1Uyeyh0dMD1Pb3CKX~0o{fzYox@5!meV$-h~gmY!AGwoW$(Q z#)-`0iOk-~&E{;N$cfGdiOj~V&BjR?`7F@Ztk3eS(k89V=4{g@?b1fA)K2Zxo=>ns zD#d~;!&b=&6swrd8J(?!guxWqHS50$s&DzK#aSuawyoQ~E!@Vf+isNH#;qCDE#6w` z-A?J=x^3V3t=lH7J3{KjdMvvV34Dg^0N6muswGwhR5V&#z*-t1-cjCOF6PGV>SZo~ z{{L+m+%4#SuIPp?>5i`GvaRRxE#RiEl|pQ}8ZI4n>_y(8S&C`citS5fm4?woMOrQ8 z{w`JZ0Oth1HIZq}+R$FgU|Zi%HH7CqJgJ<1;Al44vrk4t}DZC?3Z>e zz3w4ok|LSfPyzB*U6rcDX6*kt82jdJ^WJTO%B@}q@B79t{OT|2cChK%uLtWb|DLW1 z=P&=_V#5A!x_WEHPHOfV2Byj*O5CncZk(He;_?J=xk7NBYAgF*u-y``x=pYNKmTtQ zlrRSas1if(-=?tJmhjz5aka=U#RjW;ZtX=X#_VD0Vi9G%-qs1&5Ml7?v?l7d79a5{ zZxfHO-TGGDiZJ~qum1LJ^HTBse((|REfni<6*q|$zwpP#F38TAJl22>BrZUI8GVu{#a`gT!^S12@3o-y-uX~;e$TlWr z&etrVnaWiM`-WujPPxL8!@-Uw+ z9%J;BDzPy0@#%Uc7Vq=*av}}HF!z?k_sX7aEnb{`s$uLS#QrZr|LgfVv`wS)l&*6- zFL6UhZ~pEyC|k4%1NGa&fkJ;QD+98bVDBBCbU-7HD7N(C@$SN27w-hsoOuK{{*yxMgQ7hpYpzzWnO(e)``TclNMtL4(~CD1}EoWd%c!YjP?C)0K?KkpnU zf)IbQ!g=uBDgq{S_jkX7CA2eI@2w)x!6pCnQ1dMu0JjI1uzmxm;4Ufv6EefnK*hFz z50t=J9&$;@0COis__ZMSN_S~%@wt+ALhGB`Znq*#=_|ZKfXB8wPw938b1EA)9?-%m z@Gl%(0wY|DV2d({p8_&7_IT^DfB*8`3hs}k@-%00KAVZ9hW{TxKR6!(WtYf5E9CH~!>7E|-2F6xkEZw$=vN{}pLv9wuYRo7-P0HZ3N7T()hIe=ohBG@-;+kus;Hfz83 z-PXZvi?dSs_(&T z(*dljx-!eSJ@fBTEA*ryIG(@fdzN(fV(LBGNK_wNNcOV;pKb7Z&3-F79Dp|y@4+ja zLMyz2mgB*9pMrM-C?0^jcb~#*gExz}f+nHzUWzartpE8izrrfGxV&GBB4j&wgOQiN zLU*Hjws$wTe=e3^0>Fp&dxQ6x@2@D2c;BY7)|N>>_j5iA34<^0k*l<_4xr*y*r5L~ z0H$ruo$s&e@pfB+YBRzqth*(cd6m<`Ylpb#0#+Qrd>NGaDgY>`kGDFPmfP+DEm#6a zi!Q(O?a&hfEhM~k-YvYF!HV1X=X&{TV|jSP0U^A?n!^Dm(1IS6w~U|g5*m0lA9#Y7 zKq6;Q;JMc9PKfqX%8ADYRDK6WB-5+t^>f@umP5A*{w0So?sD!#R<0|ph9gy zm0}BuN$n=BSof~Sh?i(7g4pU+oQlce7neL+@!=(wd&i6TA5 zln4iKP?v~FzB;85BuAS#A@U@N2WZdH4Z%w{sDTIMn*RgqE9by+3oPkQAYm)(mg){Fye`Y@DI>E>>>=_z zVhlvp6ftoXfnG7uj+HcWtV%^LF^!Rx6nW4iGv-2SD48Ph(!@PpQN)b=E>UEUh7h~t z6ca6>Z?ib{LysNM5l73!Mn-$-|UjBS6D-dImMt~H$zC+j4(;)Alw)d zHm9L3OR6aGbQ1O;geDZW6-9o9gAip;d6vCvDH9eU(|lS*5%l?lyi$LKz)hg*I!O2e(}@dL@n649C;LVI*8qh zLE;`})hlDZw6hh3HL2AXB&$CbIoHZE<9B57T83HdH8W$)GiF=1E#%wOUb`reG~zcn zP5(Vo#;A%Di&TRZHVZ8u(PCk(AYYwW$+>L3j63cW$7}1MUUo8aj=83G+D!oj`)$cx zeq1KF(UzI0w$Hwe@-mq6?l+!a#55_OyYlMbzI9AG>A(qx6}U9%zVy3)vj+L(uRSkb zGw-Nwxnr#PTlu4y-Ty{eCgnTVJh#kNoLf7+0{&E~5@Z-F1{-#;K~(c;XIMJv*aDJ- zrGM`o@w#mVPwUDzp8WIEM>Zosx~8@{{8?^#x*;9P!UnpKQR`%CgPu%UQ{P9jU8;nr>@y0VSU zWV*?k>0$;w|4qvbaJvi7w1-4c$p~m}5zCIoLNv3uWqmawRSA*OJMcKocS=$n)o#c+ zt;w*3MpVlF$hg2BDv&Z~W0wGJlbZ#ykzFW3(b>unFx6GiZr%gf>ttXYdg>@i)>_Spln-va3z2Z3?`N>4vz#9PY0& z+0$O#SSKUm7;OL?)XD%720}zKOmKvg*!;Y6I7!xRaW)K|{$f};Hl~pzZ7V~x{(~~p zMQ?|A1RWW#`M_0{awrb$&%`3QGgo5pDsBm1>}+tV9TjaliDX!-P9QP6ZLeo>u}AZ=}T$)Q;+!+ zrbP{^P5&X{)1%UK3Oj@4kv!$PqZB8QV@XaFxgy1~Ficd?=@BEj7#yidut?x(!C7UH zm$UXDtxR)kUSv?xdvb?vy{Sl3&MH^MmGr52?Lk#G^;f(8b%MZoDqks?Si#oQHx+a$ zR2&->3L>QhEx2e6%C{Wabwxuu`d!dunRbBTs6F3=2Rc%yXgx2w3LVrW+zUhQ1!Rtf$cFzaI6_!>CFya8Y=0XyOJZrHs1`mt4pyyM~i z2DeCl%8D}Oy@8>xgXh#LS-R?~L`EkDA$Z>-MXSUeGj^n54reUE8(St*m^U0A?-46} z-Xs&2&cJQ+hx>XLh?W$CmkDt>V~5Ts(oR*ks{xHdKwW!YcgBpq6=_LITr#WKx^P}| zo`a0u4@>yN&|KYZlN?+MyNE8I@*asXMc-Kt5|_+5C#rm;zC^NM1R-F7JWb15N&iz? zwuPnfgRdLjB~O~o?yaqkgRNd;H>JQ4K5Vj64O{y5>nhTb-A8%gm26+RM`sDa!g?7b z-NpE>&pzx4`E2e79~RFVc6Xh79Z}rYR%gbYcaZxv*mOrQwiBg6dq4G8i^?DdJRsFY z38}Dmay8s1xQ<+gDdsdsP1Kd{@M!Z~ab!by$mzASA2SSUb3Yc^jOO_FXnCAKZa zZei|pRS3!)?_^8d#uJ@!k$&9nB+l95dcHHATi4^T>-N(&_g$Jb<;Q8~&HpPkg1Ub9 z8=X~A5mpIiw9k=fbV>gm?shhLY482%OrO2C_*Q(h+AR0l>e0dd_BE%PQk)Q8HHzHE zGL5{d79o8Zg@#Qbk#(FVt-D>mnZ`7+naw&UqutJ^j{SIX>qnk{w^Nrgb&R6&$0-}^ z;Gzm&bEjB!=n9Smx9)i{hh32#!n*`fwUAdy_fEoyDLYE6;c zr;4U)IyUiDyo_+zhj7$qx)QAn9nL!9DGbBV;T$dui$fLN;scChy8a7j5^a3Aii$eQ zb{NJ60BjbMrtZcE7m2a%%*Tm%F%c7u6S?Y%P9Tt&u@ze&(f=yyE!I#KUy%%_ks58W z6{q7EXK^e9NjZYX24)A=TBQq{uT>^7k-W^yUS%!Xks9A(6~nNjez6{zaTlj!8CfwJ zc@Y_z(H8{?7zfgcPRtnpF&7i@#Fh~k!4Vmc@x;RM7?;t5JO~&Q@gScOAl)JxOEDs& zaU=J!AfJc_jN=f)Vi?mWRn%uK28Ur1P0JpJinOdB&50iWu>`v8BA3x0agq~Pkrjb5 zo=WH=Inf51&YVifAM?g2LqI8!k{LP3D9wi_pE8iJQYo*pAT8<{6Ok){W-NV?E1@!c zPM`&#vN&L{veMEm*-|YzQ7+|jI%HrO_eN;$?h4P5NB_`=6K4%N+F}6QhpQg323Um? zhp`t!h#%EwBe@J>KyMQfjbR9G0G6=}|FR1)(?_DxE6_p_!P0zC(ks9bBL~fV#z!o+ zZQE268tw0Vun?UJ(#kxjs;V-4&{8+2?4 zR4k&h28h#WI`5-!B%MS>#k4SeT8u_MYu17Uy8mSI(57=O4(-t12|L*bK#ztzNr*hv z=Wp!uX!tWn#BpKlv!hUS7;*8P`jZE8R6ZF7mvYoA(DFT-aY;Q$KEJ{>qYk<{uk*A* zESeNKwe%U!sW*$yiIPJ$Z9pv-=A+Qm?h3}>Qj(CyN3*t&I}H;$cCqSo(Z3KgF@q#K zeKZ*<5=bPHBE^#nk7GwXG9iH^EJ3p%od`0c6uM$(95FI26tO)Mk~LFIkZ{REBehL$ zNm9F%Hy5-=g)>7ft4vAKe8!X<_2%HP@Ix0dPLIZ;5HkiwAUfLOM4Pes*3s!cYmscH zzksAMZ4^f*)18JfN+*&NJ9Q)l)HKloCI5r5QB#v8d$A&oBZRQ9zb3V-9I-2a)JPRH ztH3fG12jjGtEv>#oIdIpTi~PK)o9KqXcmUb!qNCTXj3=qEO;?8+owDUX9aMTRaS6M zT}AnJQAifkH03l{Rr40R3M1)HB)RGkE44pkhv2HJP{CC|zmZ|uzB- z_FOksH6wLkWZ-4%^L)YrLW4$98#F>O62AtZ1;XNkplDx>rsZ%|%N8kD_b~=mAURm& zZ_YwBr)z|a)fs11H9JabpNk(wGA;bHQpYhsGtxMW^bixtG`F>0la*ZC^E5&BHT$zF zF$y`gk|{B2GJRxB>$M|kwnv=kUH=o*vO4mdRBT_jN`%~JNJdCt0d;*)^d{3H6uAme zZzmc<^KT6E8v(UgS$01g7o%j>Fh}S<(b8)Zay5xDTYc10X|ul~)jtohs<`4mHTFlf zVqh3FNquB)lk09fRYFC@OgS_;=XN@ji(mv-9YIfFJ!(2t@DSzICV`c5chOjDbm1cN zT921>CzroKv%mPO(6&rRRQH{r3;$fVNzeAglJ$wCbStPd+p1P{VUtM})iTlZ)q;^W z&qppBbYb*Yc++!lnwLX~=BkPpe5;6Q70JKE_OnD~^a#^)BNt#-*J7b#BVE*BoX+Vm zm}$d8M>uOavZ|22!dvOIkpDdRcFUrJk`-JvD%&_$9JS(0>y;dzv0hOYqd0Seuq=nc zqJJ|~J$InnjD}~s;?)L;Z;Cg3xiDcBSa3dzFiBtqSU`$dU;v!BB>9Va!?$APbp>R{ z={!n<$J9l+uy&GEN18)*uP}DBm1>_cEjTmKROJfalq?8IG*K3YZx~c#ZG@MDmNE() zyYPx+fN%E3hKny=j}yNRt}l!Cxu|!2*y6L+!iuf9l9ASl4^d#J6ErPZRjSw=SvY}f zl}__CgP$llGFU^QH>>8jP~X&)W5-o}^f-wXPMfxaJ1>RN$!|J%HM`B}GM6*^i*o;1 zJ#i$6Kgeiir(G{9EdMx9>I(QQJUB*e%`Fa1k*pXztr(02X8;6NU{$b15fg*WnS92g zin-#D&2f@#U^-8^lUr5g)K?ta6nwuTpY2$bm1A}&)q_*GIjXpqu?mg#nUKzypH)(; zx|a(zb(u5kgA_TV^jB|(H=w5(psh1H_cV(g<`9c{pfP!QQ&W^3(MLL~mMOPIBlFM% zwqR;id0Aiw#Q4y_w=BFWM-0_$x3?=;0G*wV1kpLrlq0A|c6?cFgy;A;)fbA!8BGo5 zL?bnh`KDCUl2o=dkk=VG)+vdZSGpjTP8}wZ#P*#@bdtq-l0|kg@%gLam_~@tsL^z* z+qqV=8Cu(wnmF}ZX7x6o#YeeFMVN_?g_W~Zr07kT`8mK-v2{QwsM00{p82M8QUu%N+%OcE+w$grWq zhY%x5oJg^v#fum-YOHv$qsNaR85$W$vZTqAC{wCj$+D%(moQ_>oJq4KLy$Og7GzSh zr_Y~2g9;t$Goj9-9%Br!!6F6=5+qJYl?rugRjX8?YK_V@MhLE3!D^*?BC1uWUdxsR zJ9TYUu4L6>ZENe)@)w4Zr`%St5`2yw=8OyRf@E-!4jBD zWXQZZGv>~nHGAg#nY3uoo>7}FExL7U)uCgTK*4&nYTKh<<6iArHt*bI<#)$ zoGmLCcw)ea3^Yu*kZwY{iy0!EFvck3j5OAm!G|9rwE|Kxd>CSlKn5w~kVF<~WRN!w zFxYZ9kwt=tM@A{-lvGw(jJLv9dkZb$JF7jo)ejSKV_6|=C|7gJ z9Xrs6Px0Gtxkb0#`RAZ}{K6Z zmPZ{P6l$C`)Nld|XTyB++j_HZddzsgYC7n2w{83M*dN>x;J2@Sz2Y2GU%I&ilc@Cw z0*MV`z6I4#jyyXGk1s(^oq)Emv*(}v=Zeogz5byCpVOk3J&!o*dT>*nxx}}>@EI*# zBhnQ5vLp~u*=q*_h+juSHL9)!##G&Fpz}nSJp?w;ge1%Wq(EE0lSky?s1&;Jg$N{A z1WE7}f>^~eouZd>Hnk~d<&J+Z1mgGqf=I*?h7Ko1D54TwcsR!eriK-qm%TueqpB37 zOLq$461T|3E+Xt84j@3%29QKAnvsDsB*6!+s2mc+DT<^jRp3O2!ZX_Oj;$j|K9ZIK zGU9QG-xJu4LO?kia_K0Y8VLGGrN$6|@Q;v;B=$T)1ae98kB$=vvv{Z^H*RW*9m!E4 zeHX`Rsg7|fcf=N+XHCGUp`_1wPbqJ?8$4Sm|n)96FEE+o3$d^cWfd!0)p}O4t`)5+6&WG;K-aq3^{#l$t6u5ahoTYU41f)+U8%Jr7Djwu3n-!4=!J1ZV zykoWZo$Y<=yI=dh7QX;??S03qsJY@51CID@ae<3qz4rBEe`T(Ond{tx^})K+%`k?+ zYu)c^n6VuGuy|1@NDI(#jXR7YWw3e0vY_m8QVGEaEFj;7+BUZN)h}!FTh<)on6=~G z?Sk{#;Jp_4uEym+W7o=9=CDsi=%zSkX^~{(B`FOO0uOxP zwBO7VBXsOv+Pe1t#-yl`Lix{wturCuaSrSjdb))^G@%!r zXhSpl(TNUn2{T{;Gs~DDixeh{OUs;s1ZJ~ku5km`Ea3mj8NmMSahrdfYDGAVw@4=P zaP>UgS}SmHvU#W)f+ou+Hn|;h?RsVM!xkVVP_x$dzP%%T5lBMgzFCA)K-BwFZK-$6W{R`g=&uF5kXi3>!mqpa zv9~k-?NhFJ#*aPhEax|6?;ZSSZ#LT$MBmo7G)nm+)U8H-5{da%HD%)Wvv>rf-V2XxjH|GR7>;QG8GlcL%pA2q%9Y;4;u= zcl!fzvh`-EW?QzEccF(3b+&PM6>`L-fC`9L;Wv8@I9OYUFkP2^j~984HiU-uZ~sGS zptf-BdaCDrL-u+fw}U;XT>rLm=SPG_ zNP&>YXh`@xl{b6`H4yewEI6@7i?m4Z*KldJW^ERF{N-lUw`zsxg|Ehat+$AS7kj_| zc7}(ga&Gu?=%;%uCxMbjUX@mY2o-lY5*X}dhrXjmAow93U;zU_V^#<{pjUB$C~o}) zXa2WZ8P{ZjH){&UU=HRmJP3)s#&wnGhQH@{ZwP$)=P+(kf@_3uJ2XL^COmeCJkAk! zW_D)K2XNA7h_e`5g*b8Dh=_qFhPU{AuV;7-=!<~{j7Io->)3mcR*L|acFK5vZnqYp z=yp6*g3d@o)tCX!RziRngRlr-vlxRECxePNhORe`Ajgmk$yW^6i;$RxlSqsexNpi< zT?9C3XU2&ha5m1-Pilk{Il_s`SAu4iir4r*pm%Bq`HB=5aXJQ$+h=44c7S33xPTCb zj)Y}<^2TqJ_;M9Vgy~Ro90_e9FakL@0{+x<*M@Dr(~)R4U)cy}N>^Xu7J#xviwSv) zIH-$6<_P8}k!MJe=f{q_XN3FKe*Y72w{&K{b2iOqZSBQLASe*k_%iXZ z2yXY)Uy7hH8+T-bCtQfxknqNfJn4h#Xl%$qAY@E1zGGZ1Ts zP@7eS^VN#n7>IsXZdVCl=%$DY8Jkg;SB^-QJ!qCj_;P4TcDWa6dpSLG$aW%_VpCXr zAHjTUw{2+lO?FmpstJ?cIFNxjg9eCaQ`ddv7?F=DSUxFx7DP;%KbhaNz8 zq$q_saeO=k6@8ciT9j)N7oD&8g5Z{P*ie`dhKsqFlQ#)mX1JY*)iXi(hPbzem3Wbj zW|RP@gqK#0n@2^V^nNmC0jhYK*Y{@IC~?zwYVb$|G{}&PDVvKJpaS}XKdGB)$%Zf| zbH0{@YG-xe2Ar_L~7zc_@i~T=!Rdnd%x#~)KzGEaEu>AY0yTBgF1~$d6%BX7tAP{?`LK``c>H& zlg~+g|L2#ir3gy^C?VRWdZmCxcAZM5ottW>YS^3m=BXG-Y%eN@6hN!IW21o)s~fa6 z_D2Gosg$V*reDQ>tLc&}7>K1eTSjWEgol{MwWN>Pq>WdB!dP}iX{v>ijCpCJU22@3 z#uZq~J6(E$_F5=?sg*BDpMQyJYAPnds))v=uCc}l$aX?1o6Q=fz{jW5lL1xA znbw9r3FU+b5p8^tX*K#G7K(y=nVK*tlR|2ct>tP@XOr#!mSorIt~}YKLin8rI)qc2 zgwU3f`U)aybdT-nOQI>L+?s#!X>!gfdgl75ub5U}c$g&mroa_)I*X1d>Ycoar!9(+ zVn+xZJ5`&=S#((z-g={)g{?Ufu%`61Vycb0+KpuDocZ;Im5PA;sfY?#o16NJof?5; zo2M^lw&Ycf)fjh7*%nWjrBfJfO)% zmS-C`ej0590HKQ17f36sp7yOX2Ck{)f|*OC^;v2HW(P8KXT)`##p-T0tErpHvu`+= z7+Zmlr??H|u>&xz&}Nsfs}qg8dGEKftN1yDFbcc>FbWVAzTpc|l#mPHo4(|$zT%s{ z+)293}N^ZN((YrlVRzw_G$`0Ky(Tfg+%zxGSN`D=K;CJ9>52wETsRlvZK z0KpHuz!c2D7F@v?e8H0NwZBFR&R`18KnflV!Xo^^Aw0q-Y{Df>!YI7L@k?IRo1AOJ ziGAo1pBA?>y1f^ALU3RPW)KH?5C=az#6WBYdEmoHEW|=g#6yh4WzL2_mt1(R8RWc&-~oa`TWlS zZBHabX==xCPYDuBNzZ3?$=^f>y)X*C;0vQr4H8Y!7Cq4webF1O(HV`=9G%gT;8(s? z(#K`eD1Fi@ozf|dz=V(pK>*V-9n&=bJ<~Q_(>Q(8Fnw7-*bLIp3_kq~Kkd^%J=D@5 z)J2WdL2cAZebmx`nR1x6&g{)5xM@*&y}EpV4SkBZn>~zB4PYJCVm;PmUDjp|)(pxB z8?e@F-PUgX)^HuyYkhXI2L*P0*La=RdcD_tZPy&k2O)&D~X-re704c_7%;B5`Pb&cKzj@PLzdxp*4gN+Y?&ESF!;SWC867Jj$ z`nqZd$sife?bUp6=^Qi6aMOCv*y!ITUJV=hYXZLF8&Il1c;GM&1?o-VgzeylZR3KC z+srr zN&%=?Y0XE1T5ZFRd^sNfUS>!hKuVtGz760kF5Y!s-gl1PoqgDR9^tJm;atv~sG66U z)}H)|k8|m*QkmQSNJ5Ri+2b(Q*g)2=&e=KR2fP^NpFQVO?pM3c>wcx@>yYW0PT0cUu`x{K z)acl>ooxcahkf`mnEY%0?F%Np2meUx8zASlF5FGN?Z%zpzqZ^E9`5c9!>I^uqv@H; zY{Ozc5S51NX=Z1>E${s;@n}5*K*-|Q4%cl?-c`=;rS0#^z24rg>4DwlQ9WbJET{xg z-|ifhd3o8XrP&n!@95Ni@xq<)*PiWikAI>gbnN^&*S%siU!ZGI7-{aE~_0$ z&8jZ#zFp_Cr}4Ee+V#%!rS0>9E%4s1<0k*-W|p>!MC9ST?lX!|TutKp4fWL!>tgNp zC|>VzUiF_%<+_gbd#&||&GlQ}_k;cQ9gB(`8R~OM=JROwTAlVpFK=fJ_nGbZW^D&+ zZtZW4?{8i6c8>RXPoR3P<9z@3p011*8qecA>Y_=S%txBqo$B1p_L^bu=JtM2+`P46}z*RwC+Qs42mf7g01^dm3s zX|~P>oy(8^&GL?|^3C_9y8ZMg4*8kQw{#EMQeNECkJox%*Z~jpG~Va$-KQ~%lJ|Eu z5Ni4-Dct}uV!!|o13nzIkb%e#h7BD){6U0JHHsB2UaaT~<3@~o8ZIQXL8M3wBTb$} zX|m+Vl_Ci}Bm_m~Oqw-q-oz=B(87j<*8Kz;ROry5^@QRJ%4i`^h!2Tmuu$-Whl2w~ z2psrf;8v~!sgfX3kZahfA1Eknnl|D@j&0q#-Q&Yy$do5rl0J zM2{8~YSb`Lr3{&>{Q))VL9JT_R_@x>g9j1@v1+A?FyUj!j@fS1_*S(=MKJ4b(EB>} z-XC)R8U7WVJ22s%iGdp|vQJ8Pvp`Z&zh6tS&N z-O=@H^5tpI)tx>k@7uwH4|mU)bZMwrr&=Z$Hmvl4oyA%m0Xu>`ut2-{(vqk<1uY7% znz-gt$-D?96lssga8oZsoi2B9 zT7!^6*mTs(Li98Qk`b6dBoeW88WYi}cb;#n{i1eqjQlzuEgr>ssKUTEX#;ye~ZR805 z&D-jltxS|Wa_k2T)zr{pWYRxfM zMqlHLr%BBPj9j0B+H_rEe?k}Ah%&gcs>)pKjK9jNvac*G&syr$e`6K6EpKma)Zo2r zWmq?dCysAjOW|FXvZ|glsAK7*HAvpAq8cD73rI#5)&;li4$|7bHE*_-@fykh>0VM^|FH~;8#YsyJK3l@Kz=hT=IOxJMZ=OE>hz7{8lSe#;J?$)XX{qy2`9b z*!SoRJ_YsdjAX6x?nU#`)h^smvbtQ&HxD*W!#wYLorv9iHG|DID_wQYd`25pYN-oU zJ7i^tTV)WKy47VJZTJ26!8nJL>xn@hakAxGv@%*~p`VU9*I_SBqEYU@Kb8A)$-nJNaUI95;Aus{Yb5D*Q7U<4l+!3d)3HdRPO75t!u4R((4_hd+FwCFmDA<&`K!(>vRg zq_r{o5TrmJXxog;00%1G!3k7za7R(T;VrV;-;gkSUg7ig5Vj6sP!wI{NX7egq^K``AZBu5phJnW7%%Xa+d~ zvXWS!BPHv&Ni)O&kXIxm76?g2GZ4XIj;T*{DAPV?@dqqfv63nqcgoVxi7B?>i3!x= zgOVjJB0Bhi4s?JmVEWRRrVJgShUpZZ5Mh}g0VY#Sxy%DKb30G}v49hsXcYlTX)O1t zl8ai`FJqR|oaaR6t7w_dbFOnsOOh9XR3|;5dCWvtF%gW&sZMqx%biKn(mxU8&wdW{ zoKV4%sJe15Z%zl6-0Ydr5;8<{3iO)kbf-lNx>1gza(y4O(h^U##MHg0M1n$A9aOqf zmbTQTFNG;f9}-iV)|93*wP{Xuic_8TG^YNvQ)qk^pn7^NKlm{SbzIlW?GOSKivYz_ zqY722R+Xw(ooZICI#o*y3M7kI1R%f~*0G8etY#(aS;tB@2#&xcB zm8)EXU{}2&0183yD_{SLfUdra5Wxt>GH9_3#447tj&1D!ViPOb$uhRGkzEG4#MU~g z%oAk)>B=jah0hm_>~%?Fge_FNTGqDKwXcP(YJtTQMr^{ix5aI4b-P>M+SY=SIzVuR zJ6z%x*SN6}EV9eB}#Y`m$oa_J!|#?|ZY__SV1u-EGByi(CR1*tq2C19cU=U4GJK2*U%{uQ?1hq~=)YrrD{V<3{d|waqN>TtuF^U~#U>393#LHbUcBLz0 z>e3jx4?ZO}tAnRKC2^sp^OM>18O7L%_`^pwa+2%+8{eA|ViT1}ag=pii50il%EwLE zZLYiJ=vtS?UY;>^x4TYwV#mi?f#04`B{ZKA$g~tyOKOv>WI7|c#F0AjZK1s9CqJ3b zf9`W7_B?1mKY1tIyKE;GWcUG9RaKGlIAcG7G%^8yGntvd^x)6(G) zBe~9}hHsN`3uq|YR?vYCbgNk%Xu>E=(YHPTn-&6NE^9;5&iys8qZ{n(J~!B7CKN*V zRW=lr*E$-jl9@$Axkn#=a1nv zgWG-apliI+Vk=tE@H1X#XJu5G2^5wb=dXbiT-#5(P1YAqXmM*j+z+3N*T3$Nb%&YQ zKQFesA5KfaIgxo#f;aF>ni+Os zV?6N+KK9xFmK?`F=})iJ6Z5DNj_U45T-)$>==765L%*Xv?!1o08sV|wj zD~|E8|JwS}9eVweb9q>D%-KsUYS5Oc9zOLKD;fla5oIeVDv@y%E zA_|QVXdcozy0HKn$XlDH`@PVK#1uR=C?o{+!$gJ?w>#XrN;|zy6fW?AG3@%X91KP0 zy1!V2h#zbY@p`uRNkx!0dQL1gS<^L^4}!I0UT27X&vM>_lOtu5&EA7)yreB1HTn5P8{| zv}wC->M?$)$5FFJ;lsxN7L>J&WI#U~G;f57a16#CB*%1oGiuxWDgtcISUlTUR%86Q6J{9jDrvy1*`jiPYN*pA~1|!ApYMq8M6_|_`d2FIqfg-1a z#H(bvoZP#9q(WZoMMMirf!x7kv@UZ5LorOBXIUjqF&J@F6Fs*13n3Z&sM%8Wxwy83&xgiN;oWrLA$`V2*MNkrtPYQa2egw0c1LE7v}TpTpc1WE8A%P-79pX<&0 zqa_jnuWTYte1l0O1SiCV#n;3~yOYDM%*>t)J+A!5pae$1^up;nMvaq#Xi~{QVaj*( zvC!%mCMrXOs7WSFPZhMLTU5Z9+s6gmNQ-l;4Qsn5kg#@z8*tdAZj4~{cl)I)PrObRG-|- zJJd5)U{mIUIB*n7TM9cWjjn^VQ0WRo{OdR@S)KojmXbQ1{FsVZlAnq4C#W-0fh)eP zWWQA1#`kp6S^bFXtWR4lHtgcg?qZzqQakW;%C_4N(4ZF>@xALgghLpGMM&3mZC7?x zS9o>TczxG;rPoog#Y1QWeLaLr;MaZK*HQRae)ZQz5QKmoSb){n_ymH6b=Zf6*oc+b ziEUW_rC7aIXoXY2*p21bj`i4&9fge@g;&5>(Nsw+`M^Lm9br9A4I|Ta`lC1~BTrHz znuP;Tq9U7>Su4WXo1Ixel36}713x0#p#`HdFr-5|+BE_rQaYqH0whQBBR8U=seS@?mTRqT&wWT6OS|`9+N#T?w4^67UF{$N5 zCnCTl`r)OGl8b68)4v(qjw+}5s6kUw+{Jwt#XY77GtTCLmi~N}wJcD>#oWx*+|A|O zP|4B@J1^XGrO%2>>d1h?<=oU&-PL8?Wi-VgEEUOhC71M5gMdsDZQb0}-Q6|ZP;p29 z&8EeI$f97n`mweYFreJP$&-sWZA=1tz`h2EZ0Cv0+(tB4X!^Hk~xQ|b^6>oFN< z5a017-|{uz^F?3rl>}Yt2?cQ9_l4j1mEZU+g!z5nLfC^?B?M03-~RRA{{`Rx7GVBu zGFo^A14iHjR^S9?;01Qz1~%Z|(!OOOsS|m~3~R}vk&1o!fa6UIMnH!U7U2;l;Sx6C z6Gn%2V1!s@1Or$A7lz>%mf;w7;RPsw1(4wzHh>+@;Tbl7-(rMYxCK`b;vzO;A~xbA zR^lZd;@={KV}Rl)mf|U<;wrY{V@L+gn!RiSFaIL}tUw)SbDxgcQkPtw$b<<0MremM zX5%(?<2Q!mI9_8yVBsCMV>`a#0=VNH*5N#U;XT%21JL6gc4Ai`Vnaq`L>}TqX5>b8 z3UlwLfcBdi=FUeCKQC?Z-ARN{l)l**OXpZLI zAp}{r=4;+#huLLa-ez9z=0hgpK7ff~PKID6=S<#Ywb;JL^9;3--4&UV&>+;Nl4dtf zVQIc+YR2Y$wr1rrU*|lk7nb1zL1lK>RE<~f(~exUTLcaXqoPbg{JAQ z#%YKsqNFM*%d=ZoL>1@IFf?`uiD2rsZU?3A=#g&fw$|sUhH7mNXq6`Dz2;`EzKyO1 z>@1F3geuMd*ix`KfdM#y7#Q7@jXVPJV97jcrIu^Bp6t2y=(@IRllEu5w(8G*X}#_P z{S9od9_)e$0dHkl68Py;k;=+gf&M^i(<0R^$!N>Q?YWj~rl#!wcEFt5*zA+WYtX*x z&@S%d_G?KgZJPe-wcfsCzK$@pj>$v96ZnAGX3fLqz{rM(jE-yF#_Y@H?Kalz;Kt_R z{^oDyYk?l^nO^R5Zf=J##Sn-k6lo<_IswD64&s%txispxKI#Am@B#mB0uSlmmK5{m z=NF^ul{RkT#^o+p0`7V5gpTis2$e3j?v7c3*#7AgNNoHLGP8N@vbbEe@NNTF@uUuL z%l7T3R`Bx%JC-)?2e0wsZttzGaB{xzi`k6u0t>8Qffcw4#Lm4UpN=7<4imf{q!#er z2Jg#G;pDF77{BJu#%c#wZ;Q@`ed3zw#NsapI`({vB^dNmzvPWM|*cTy*9Wyj=HKlHb3^?^V|#U81$Ngbgw zWo*Z6C~xbLcJYp;@^FXc;oj?YuVr4&Yn3i_LV)-GcxQHRE%J_$O4P~sRg{*GyLOYg zbb#;nUEl5UHuzcQa|q{hMILn=fA@&5)c-I zDaSK#FL{%n3oZY1fcEUX-sV2o9))rFWrwiR-04_n?HHImPIHmU__&?#ZcGPzUe|Ot zCi$XQuBAu$KL_+Fpzx@tm7j?Z;ow{(FgaBlzhqR-|F0qu4_ z_rtI8hj;t8Kka@~X08D7#Y`LXvJzM~vzPUFT?cxO{&#I>p?#xJYX?K<~&;4Z1@3`;x%op%ock;g{@ZmT3Pd|M>XL?;${?>PWxMvaT zj{L2_`ns2XdU6+Ts7pzVFiPSB(-0m$WKfvVCs;xS#~w5|mSEX|2g{l@+vi6{m=@>K zt+-Po$-H?*^5wW-T1t+6Z}rjfGG@;I#ENg;1?!VYh7VVVA|+9ogypA5m!7za*(uhm z9z1k~>o{y%v}W0|C79ZE!GwqF(x%<`$Hu;T0}lr2JFu(5hT$S!Y+Ui})21VbU`kaf zi4`lLLd~psYUd9uj2`{)Ve9t{${mX(dzSTi*sj&CZufR}?f7=T;@%k8Q+a8n*PeN6eK?kE3&|xP ziV@wG+kN<@gi?#Vee@nf#RYhyOpMSs9%LSzFcfD_K?k8zCwOOBh20HsVF(&-$WwW3 zvG>}Psd-2cjSD%HB9|-f_N8C{(|oDlZ-xDbBboy`MnsR^b%vRB10={)3=k4!8D`v# z@R@-jaP?$QQJ!TUh=fXMXo> z>|+J`ITU6mlv+a#b5gt6RG4AAEoR+j2yTspPATid4yShOmh0BmZg2bLC+uEb5L=_Y z0ruhQnmr12XJ!Bc9IdJU3tG1Vl2>`Bm6PBKIgAdn)m`rE3<$y3MkcRLblmxFCuo>W0$=)C||eT z3)r(n!V^q$iXY z`|P_vKm7EQ%a#j~$}{`|vV$N$t9zb}koef#@@rHIhK1v0RK4t$^)7^bfu)#*pn zky8wa(lVAw2T6PCR+CJ_H4%cv2RvCExJYIi9k7svKX73SUkJk%(olwmap4kBxR4my z&{D&>;Sa&$!y1mTh(^R4a}2~X8z7}lOx&P?rn4l=7-%##J0cddsKqUEv5Q_zma+`= zpyoJBgG91S(|#A4Zv9DxUwk7R<0!{Df>Bw`u^`Ky5;Z+K$ZFd{ik}Qr8afiPkcK?u z5jk}-GahAHrDCLJ`em6KND(xGWYZgsr^!unvXh?tBq&2^Jf4WMl%_l-DpSeHH!2cH zq^gr6{Uw$EGg74}12~w=vO=}4c*To^_$4q2(FaBZvzW&GZrP)kkV$+#~;3hE{F-&oS^O@u%r!vnu&UJzlo#b?*5tRiMs$CFw50U|d zKGUyTCS_a9A`LaWNCa{Ylbr=6C_)eV&2A#Jod-RqIUBQ3buuEM6n!W=D|*n3a#W)p zZ74-ATG5b>?2Gceqb!~HEDV}zpSRT02;RghOv00E110H4JK9il8Z@UqMQB_m8d9NV z6sJ1f=ubO3PMnT(sTmFE7L~=B48C%u0dwRAkHUiKc;+(};0jc^_)VTB)u-QNs!*9~ zP->q4RjFm|X+w+J)UvA8r#)q7O-HE6Pz?+zHh5wrH?!4)!O1{Z;iXBV8P{;KbF3J( zD_uK!7nnFzq(=2;1D=ija>rJ)`PiSr0PRD*! zv78kuS?jt`n$Gs4n#Jr~ISX0g5*N5YH7R6-LY>YK1z;z@-Ct?BT5M&;NGAx&Aip@# z$3ir-jUB2x>sryTSah+LeXMZLDc<6$x4k9xq9U=flxa~1cXDc3f{3zJuAWPo#a1e4DJpx=9ygPq3{o;FaPka5O%&jE(lx>V zm(}f8(n??mr+2f!ZLnuWD&cstX@aJ`9l+?D+9EOc1cMcle@TGYFG9GjCYJ1j4@@uf z78kDSbt_Y!%w*#(6|{PN3|wlQ0ixVdPR)%9eRrqd&GeUQLY^@e2Wn1_3V6G76|j^E z92dB*n8ChnvTr{N<%gnKuUb~hP-I}n=h`4hM7on1rT8W)f;F}bGqO%2icmPOIHcsI z^Mj?V>GIl{)1K|9qc`N0d0&X5gB= z6xBDSW5?NPbR*>{7Y8v^4DN9<u&p_3Z(`S&Q$I>$1&gF{r%=^)D`3Hg``Kud zI<%rDUj;I!QI1bA_TdSh20M;=>7Oz~9J+AqE4V)8i?U-H4SzeP;jU4M+jOr`vB9*G zjn$TcN|vpj(~_EVW)XK0&Q~Ai0Eod3S_GWUOa?ns$DUKgzXGIjmn%E}w&7-OTU+k2 ziznVj+xLsdAlaK)c2cJ0W8X2?IlHVee06T}S3J|?n9wM{_pQuh96TB0Bu4IuF-)zu z9px9L=8G#Tj&4|%8OiXd^BLjogHPiXz-LD|_)X4!bAOz#NI1g(ZSa26{@Zx9H zDcn<;$YxB2S;!z$R5FwU znh)}%VAwGs( znH>|Z#P!z&z=?QI`B+}<{fVN&Uud!3;hj?@}5-vt(69)6-nwcSWv zp)6jZ;<4N}HQ*!+(-|^Dm0g>XiCmT$8&ROvN+AUg;Fr63Si&$x$cdFt9o{K?;q6hN zI8a|Xhyx?gLJdxX&#fZ$t>W2%op+6wVT@cuUBbzwp$&@v(-mF<3G$n_Rg^9cQ`>D+ zH;AL+<=ilRp+*&>r*Rq*Zpt#E5k6hq%Gehq`b)D>MV)-c$6e#F=~Zr(96Qk76s}ws zW}eNZ94-9PE5sl(Fv2#JLrJC_*R5j1xnfV1LpXTd6@sD-5&{i&!wF{IIO*a!iNj3} zEfF+({JLF_u zR54lt@RedROoM8!>8XVK)?L1}4Kd?%OsfoFEn-A>iYD zrr;eKr8ptx8=jmP=3E1=LLUI)S*eqDKFOa2iH`l?4rEmtu@=X5hE{?V9JSmCswFv% zAnkoZNtPci*qnV5Q;*u*Sxw;sTA*#_*)RqFsm*CrN~YW?&_dLDz-YDr7*`tE zQYNQ26(Y$gQ-J}Ot_`YNzS(y%l+I}yA;y{Ig%f~6<}!jx2{>XS$%!K}Q8d0AXT-^n z2n9e%>OxqSr#+OT%H_jV7V@hu6Wzn=I(_QIV*I}Al%~`6h-OtJYT|2UCwU!mO@(5%c9j~4MK3P?%&?!?q2y2J7qJy+)Wu1f9b@D!cwxW`)~hJ=1|ns#HM*ugU=4v73FR8Y4c}Q$UAM zz*fS_4xh^E+hLo_ZY;rFY^BwznqI6d+AGBEthQ+p#hpwE#K6D$;O*eu22IT^jVp7} zQ@y=JRJp2)X{?D+YfjN5w0fR{WvxYVo+Zp{qKc}~HAm3mlMhN?7IV?x zniLT-V%x91YG%Q!d!1N}37pQZQ`eHJ!+u^=K?b)BKnVaA6GcVFp&pk(1#1l}XE2MO z9HDl_t-4-qt)Xfe-fejOtyk{<+?&Z_A9O9Bx|mX}Y#nXcQnUaQWt^NY1-L>888s1g zzzM=2mZZ8W)#{d9(QJh20GkXKn+wnyORZ4sVs2E*MqZRiY@-zV4yb ziJdmxR9q6+LQwy}0r_~Z_d-zkhA;OzP+U9^_~sA!j&J$0Z~A_(`gX4wuy6dXZ~2lB z*pk|yvERyktFJavp@kV##1xE9#UP0)k0h|U;Z2SCZqZ4q4mGf|`tCcz1qH+2Y4|P) zv55vda9qIN2RpDyjaE}g3xt3tAT^?kcIturSJ5F73~yu%C(;bd&JN-c;yz2e;a8#E z$z^icz5rMa$8ayb?GPXTv8WXYQMACoJlFriE(=7($W9H&IWH2^@D+hPi&;eqgytEe#>&k-LF@dxkg z5+~idovk68O1hCi4YXEuBupNIa39mrADd_-OAu)-*CDUe6VWLVKGLZuSE!zAC4-(H z3)CnhVu8$3h7~f&)-j$$ac0J-9#8Tqn{q8r7y~n-p;_j)%D|>puOdhBf}qTQF)%H| z@Q&0}xy_Cn!BaDDF$v$%;Sz~2pHb{WoyB1!{l&#CGvo-LG2vYzu_5t^TAVC7qNVZx z+P)vDV8$YQSz$H*2~CM|H`_86+i(gkFd&z6k@Qt`Z6|_EY6ex_6lRMDaCwpLKm5i7~6+I(3Cwv0+vWB>}dKw4*j3%CGVqrh6LH42yj zTD$dH-?d!BHC^L%UB5M4|21I8HC(&3TGO>$o4{b#bz&EGU#In4vo&G6HDVLCV9#}0 zQ+8x$z+}JwHDVjKWUn=1|8-|uc3W$lkLv2kZWb2xW$bBlH7 zF>^OZ26Q)eH#fIjcawm3bDwt}w=lOf_jjW=cDFZivp00lH+skSb=$Xn7dL*B_uy`~ zeCPLfkN0@{cY41!eb0AsA2)F?v9w6>d=>KUuvCLw2DdnJpICqegg}Nb%Y_?AhG+PJ ze0Ye5_=k(QiTeqLYq*EcOp5o3hMV|ukGP0?_=vmsh=+IyxVVUGcysRyh$Au)`o64st;;$=A4nzs$gaa^C8{~E%X+XQci){r2^1mZ`g)(! zx~|VUf=juq=lY@RI)k@>X{pQ(m+SzTv>v_aMP5da-N~@;OXLE&i^qDcpSiF9NSW{d z%hCA>vp+k%S38izdRBglvB&$QS9!Z((^mgAILn_yUPzWv^ULCBs(Ub zZA2n&#__OH#K6HYatYtb;FfzJ?a7|N3A4xgRm}Uc!~Du4Hy$6I7&-LM_i)YAeS=%v zr*K&bIEcl)G0n$35SMGYHe=oo{Ld?W!V|o5C;Z~eyF*)hs33a?U^|dtJ9S|HJLa!j zzh)d~{OiVBPzG&>-=onVaSIDbhOx$dE!}bLF#X)me9^OfkL|te&wQ2RyyR1)2JJcD z7yPUX8r2s(@%syq7(DRDfWh~;^1FO;g+Rx-Crnqt3BQnf%S#eKoFFmq#D{?- z1fDn%LLoziCk8MKF`%Ktg#slmwBfMC#Sj@Slq(X#> zFkuK5UqfhJNCM~wgCyRr6-dzJLxf}zeo%-|D?x)NLOx7LR_un&U#q6$>x4sIx`Oq@5>1Y#r8WQrbzyV%1%HCyN+N zZQ~6|7I6r$a2e`VesC||xd-X0O%0etjJwVWAG8=)p<3=CEuKt`a3t!&Jh@hf=rF2i zu0RzI=*SZ3sal||g%8>bOST=PY7inDsM>9}hXy#SsjMgh zYq)`UVhcKoJ}{1i5eR|~y1DGytFRIW8_~KJ>w57bhUnu@Fp6sbe2A;z02|=H`1;%^=GNNFa?fZpPT68nC<@DJ&4ksGO=HzOJU4$_5Fqnn)_J zSg7GEArta3!{ewEks%Z9B1kJ1U?i-$6Y0v6!oaw@E3iN#!?C;R3Ih)&u;9}%wZNu= z={%S&OHICp=<>-t!eZkOD4tsD&p^GJRMNo&okH^}AfbYag{HXr%SYx^q$~!l(qite zT%9usp{#Zlk;nb!l99z-3Dr?2@H8ZrQ5|;$j9JkjOiQATLZS~@vXHG*v_%Eu>LQkk z%!;f`!!tEA1f_gUs!(4oFu@b-we8FcU41o#8YUuvDW>+NyA`au__C5OU?;8iTFY>| z&7nvIOc5{@@yhX`peCKJ%p#rDkWjOTr78xK_pIvTBcI|@qlOf8nZk`JZZOdVM`I~L z2U|Py!G2$jh}f>$9AJb7hl_b%hpM`6NWnN9P|37rMmAQ%DrOHi>Q)Y`DoSU@u;8cW zg%j-Vgf2HXC3Ax+ttPp{u)mk4q8H26fGm~3F)MCzfELcAZ#EKU12d|C001HR1O)^D z0{|>R0Sf{D03ZPX2>$??47fMI-GGA#6DnNDu%W|;5F<*QNU@^Dix@L%#7JepmV<_< zh}=lBq{)*gQ>t7Uk%_>M9a+kpNwcQSn>cgo+{v@2&!0ep3LQ$csL`WHlPX=xw5ijl zP@_tnO0}xht5|uu+{(49*RNp1iXBU~tl6_@)2dxtcIegtOoYId8y9ZYyE^OYrTf-r zi~%PABmAo{MBu+MLi{z%c!1)^HV`sC5#nHF%ZmvgOiVd);=}_oZ#FC$@#oK@V<2{{ zxin|Tltq_T%(}GYgCrD3-t0Ow?c0wjOFr@1cWlGOS(7Fm`h@cnyJOVYd4hy<64IWrXPL`0@z=6{Pkxbg6M^Y(_gtc7eWakga~4YA2K!~i6fpc;)*1;C}N8z zqL`bDF^V{2i70-6nP{e|=9+A_>E@eo3dUtlOVnxSop|P{=bn7_>F1w-1}f;F zguPW;TwU01i9;1uXmCkz3xq&$hv0!15}e?{LvWW+P`EpVdm+Ky-QC^Y-D~q*dmrrX zKImVt=3FOhu6vGW++bqM{VY*R*nV~x@8Nz<6bFpJ0a?oOATMdxZJbcruWmWAQueh5ne_QfQy(ZIV8OR86cqX4j3cbG9xw6BUS`T@&vS>3LHb$;_BY(sJI zhx>6=A`6(cI%zXdt)%0>Vw)UHrKXddEP>CKa;*t_$94OE7fUM+vLCIg{0%=BBvjT~ zon>IVd3-E9|0H!Lvs>A8)~>*p`?2F5ct2i`#}%ex&ld(G4RqW7~SXRrSfljpTR^zLQQI-6@V!{Bp7+O$g6Y8Fzn&_1g(~dF5gRmwWo(te@JF%bJt29|+O+NZ2<5z+VU2 zbe&ST7ysbe&X;AFX#03jSWxzO;97S2cvM!0<8i2^7>$HTngqH&ZWuj%I?l9Ab2DJG z8*VTF?eIQk#_AdcUnM3XyX&F#)n=$r1FTQ?rq8s1AWTQ_%Zj5PzjhBJCwN_nU;<4eNUk* zaST^DGdP!ySx$jmCL6Cr0hbJIzBKu)P#=J z5YYQWMlGzeB#+l(KIq-$WvbY+36;N`GCfY!x5O&n2^2XzGmdTKQIm95a=CBr>0GHx z!+Y!w0Qji)pg42~%UpDHpull3*HSxdfjiIQo90^?ZfW-~ks3Dz-OY)Nb(BJ}0l9Hu zxm_B7(=X}A_}Tyl`}7GYBMH5>B;ELU-Y2jHmZ>&I%3wKOyuf>zwxWq}q^cZuq#|^f z$>*4;NhED`Q!*W`-h7d`6eg1csU@bVkVD6UrsJY-q5u}BN`enR^<;?w4brg!F##Z9 z)(?3CGheiCvNcC?f7CU8&9ofk0w}FY@u7VbXQ|0jaLVIR>Yq)hy~*bfu+lx^(`W>$ z>GgcpZj;HZJffjX&Tbx=mARKMXuV9yNHa6EVUYxkk5}i}Z0USx&{TTFkBr!Xp@bI= z2f%}-X*-8D&2Y8G3Sf@u0m9Z;s;pfzhm|!B*4Eak<{Dx2xrMbO>xG)a{nMLWyY*(ZCucxMf*=oe=aNJn$0VRfAKjz0milc+sDH~6#>0I^03l(mNOBA zV$A6<(wKRUA0jV_WEtO@cJ@pBXnbAydmH!kd7!`MDsE1qHMT8AZEX%;0G(P?ytt*- zj^KucJYO%k=Zx-;;zVn(OP}cRA73Bc0`UGmvcaf@(B}#GUK>Qe6~r7Pg0T zJY_nu0Y=|6(Oo_CgWBL%h&@>?Y%*wqzy0vP{{m|w<(j8htD0~v|B z9uEMYOr|fk*|dKNZ5>xGHj&m|mN1u^UfuHdA9*rzi>7JNqo>wk1=#as!B$)-no7IV zK3Caz9bHNAf}x|wOnns5gJAc8&Ir!B@7TJ`V^P%~)3S;`4v%zKCd|ganl^9?8&JlR zI(~9158G?8Bl|bK+TWU0f3|$QBjPcIb-?36ZC`2C<~kpm|K~$w_?e9|#SjrZ@}wtP zUdIW3NDH1Na|(Z$vl(+qS@4Fv-wH$dI&DA7RdQ9ytbFQ+t3LG;`>NN=OHtfgY&z&P zHoG+VkPGK_W4+37z=~|j<7v4(V7>qrp>Px@=)5D|x~%clm$HZd7&$56(P_uaiFE5Z z`aRUNn|^h}2YLC}vBi}ut<~ALNM{2FwbYCJ)F#N-6~?&6wO-eFnE;8e%vDd4n18r7 zl1ck!rR=$)c4%fTpnvr9AMLmei(^}2%Rcfy&tN_M!MwJ_MsFV0xTcmTvJCH|qHxE< z&|>Sk$fZe{$n1Qs2s^MYp6P(D-v(3!!O_S2+jyMIhd-lFOuvLTh4-4^d5BbY^9(<4 zQ$_oUem4z|8aMB9)i$ggd90nCy#$srK3$;NI(BHlE9G6JQ>yqg0<~zx92zy8(&8N| z9NqQqd>2vFqU#J}_teII$WEB)9N&p!XGxm}y5=#uhw>ss1WNLvdJgbI;(V)fsTj<^OSfku3RCYpg}7=iGsukZqsGc^ALV!W>jpz7~T z(JGKw6-cxl#5oA!o&@o{hj@?#InBGck^sC6f`VLwyvlwa!k}RDppgC`2w#wq zT2N9_a7ukJlmy_q33(+5$tDR&=aZ)G4y}0sC_T zwt9jIbAp9Mg5f{{(stB7I6RRyvW6bdz%07y#%Q}d(Q_fu`ytVnG|7Wmfl?(Y&@Cw_ zIVq$e>1}$)@H{DsG&zPpIZiA2?acZbm7LO$3|&Z0e@ISF4)o2AGIx%qxv{_?HF3CC z{JW4+Mw$d3NUG#d4LL|ka7%qtJ0t;8nio>j-Tr*$S5K8mB=wJ)Mssp2GW*v69U@Jw zet=e4q&D!U)i4cVgZsp2fTnGN<7 z!FY6bc18Ok!&AA+j}j^=>Hi7j#cSpLcubXg{B_oCOZqF)h9n9BC4cxK*BF*AVwpc3 zoNqChOgWhEJdoEGX!Zpt;DR76UqPLs2F$GfV)MpaqKx$pd6b_p2xJ zhS@iRu|k+*$!>DVpmyr;Vo6L< zv6s7FHGSb4X$i0)O+h<*8JJWJgk>+5Y^UVEE0mTpHECZ=0~(qy4yK$vCSJe_uR@A% zEb|uK$Ym`{KWW6~R)h;)a*T!naqjcq`>Wqg1+zFT;O2GzcrPWXk;Zdy` zuzF`RvjoNn@ESjnO?LQ|&hy{8y+y zr9afk91!i>9|DK=hc)*{EcZt}_Xk<`gLMb|6$dht23+a~QkDmx&jT*^!n3l``N1uP znAJR*Ocmx~CCh_l&x3YuENlLK_`yswcU9M#rC!5brSp3ROtnh_jS7jR)T`@smlubce}0)UcynKzOud;ags`V&(`GGgrYq@Y-pm!MN;BQnfo=ga z_n3v9hu-d3qn5<8-Y0X$HnV^AX3bk>150OZu;)Us=j<`{Y9Zuvf_1R#xj3aMKjHbL zmZ<=*d8poWaLarq_Kdwk1}8?fi*OA<9MSjLD1K#;(`zA_a;dOQY)RwOQ_CpC2e)4jfq? zfw#;{6wW-eRA*ne>)Wi%y+|yuFD;F%1ieVCl`d6>wtj3bW5pKPPg`BDTCG@FJq@2; zrCj^X?wZvb5~PzM+LSUJyA~h5@_aJ&`m$z?y@rIdxG_?3@oaBnJ~Gz59(S^i>plCC zZevJkgQ#qN*HRHc^ka(M|7CC(vc2Jhy-8a(g{QnJNx9C*vDmEFW;xeInpMBc?(_*~ z{!nkr%xjA;eVUiX7pSW7-Bb8OvEmpzlv zjMt8l*S0p!hVJSP!s@oc=vMxG=QL~x)2|E=FZ~_I-STxtt87QUbz4AWugNAP3%)zg z6utp-3rT(2OBmU;;n-Y9-m}nqYlW+oO!_>zGUVyC8bvkb7qRUhv6UpU7hj+=by9H{ zqRu(Gn8k4zBXYp|x|?viU~jvx#9lXu;^Jzvi%Z)@Npd?47{B#cnWOa9e9k$zs81+1Qu$=Y_P9@Esn+|5KmDlDdq2msY*Gl1 zT^Veld@@V5Isdx0*t#W%h1Y(vY45s*Aa%Oay0)i(6km2)|GIPXIvq2}I`?#Tn%Ar@ zbc*70hMRtN+H%G?T5O#%Q$I06eKdrreBR}I@mzYbJaR#_nq{(^AIbhB53bWQ|Lc1IAlJYuCyGhI&FWCbmdAi3Cd3jWNRXcKZ5$>F(v0jUL?q<6t{qyQ;0=dd=Uy(PlWw-RB=h$sW zvrTP=@RM!!6MCNu=e1o|pLy$#Ydgg{6CyUV^8Rp*v+ju7KCk%n{pqJbpQWUKM=GtEY^iv;xveqOM{#4T`Tx#?GnULDdtt5RHc5FE)Q44T zYc>B)>&}+-YC=-9YafATy}7NKzpt}##d0&I653{aes2hi+~@~3W5LNzB3_@OB6@N} zUp8^Y3cgJzifycxPaplmIf1_(Q^QX`!p}wFhvhv!+xxE~HnNQy2pfj&?ewVFR8r=g zlM?@9t^ku%Y{W221LeDu@IG_~ByhN)JgAz;#(Ypps3si9?hJ^1uVfFnGF43Bwi)c! zaxj!gM@QEzU+?G?%a#sK=aj$hLhzFd2NKS!9je2=m+JSV#2ew2>9u&HlK)_vW7Zx? z-+3Tln#fmP!O_%qMA69>_rVcM)i_&id2?K{UAi0_lq(=zNqc^O3-bSL)doEA9xV4e zqN}v0YF?R*qP?J@y=Xa_Pv!__@M^kHSxjXn!MSsK({%1^R~683N`>Cr zPHdC~xA6!{KiKb%q=`aCDGVJCXNtbnrRxbgpRD9qeP4;I{FB$S!W#~AnxwxyS!sh% z|Md0%$C4Q~W>CYuUtS*IcW13~Vyx!)ikuDG?I?Ka<>F}6x||Z|@4|A~{AasRB(VvW zIVEvKuQ|JM7!l7H`%$zln-OJw!<+p=bV6xv?z1Xn$bWZpeWkRZyU3J7LHHy~3!$r& z{or?e(fKpMq*9JC1N>=_K9)J7W<>aT7`CF!B|e(L~SZ zV51X`Du#s$WkIK0`(WzG?W(c&S5PT=arAKfarUm~|KN(!1WIv=NX3sQ>_npGTtz$^ zmY7USyUkTo%7{1I(<+Gc)zklBV-qNRZ_wqLk<=2d?u;*i4RH_}s!i0?_Ff@;%I3TI ztSNLvP&5BQj)!MK;z(y&UM5YNaFHX;sajF?1nE?|fJ5)k$bx4)7pp)3{hW+SxU`0> zNxW&IoEV-B&xGqwz4%qc(w2mx-Z*y~9ozW7So8Kn!e3S#=WG)7)D3SgX9ACACJot& z)0|jp-1WklbXTrWo5l92|7yL|>g`q6g?3 zOjN(gJgA!;nYvB5>ZOycSxvCPCbOd|-I|FS<453yQ7*4>ni)!EAI$@j^IS}W3Mk1H zwc-;jX$n8#MDP`?7$NTUbCMrgmYf{B9f|neYLC0*IcZK*=1IpHX-96=G2t#M9-b71 zl9$=0osBMjZ3*3JI+OT4#clmVkE3zN0t*s1(u0m))>DKouwgSmHdMpY#7sSVIrQ~J z+ab$~u4$t@n5t=F4Cm*cImAqFvWNT@FW~lo#Xs(|CHS!3o%r{Jd-?Ib7vZ5Kq9#`5 zaCFTyrMXybO6Q?Tf_IOCc^TgQ!==A3e`_E{-o6I4(51ne>>`GMo4t)!4L!z5kG?8= zF7baFet$g={Ta3UwT;-58%H+*v|3u?>lO+@b+C0wrNqzUFZ}HB4$sfDiZs zB%<7hr@vRaGAA;bg1@q}`{{(`{2AR7Xkr^@!6wXU(43cef1~Pv=|O^Bb@%BN`=8?z z{@R075}(wfs!sbr4)BgoSm72s9BXQu>~|pxi}&SECGtGAdRgw8ED-CPEI5)uPR{9j z8 z%L!>i%6)&QDsXTm$fMg|*{@~`-DzyBaLN5lzhjEVjBRbV&}NK^dtN>!DWMb=D!n|(1vTuCdDumwL(Co)Ux zdzQ;gOv`sI{GDI?$;m7dEZ-p|w8d~WWf1bfDxs5R*z|uCf<)0WG3997)`RW56Iy7M zswN9;67HmbRU~eBOv9nXs0vMERL5B$r@3*YKAFba=+9BWjy!ugt=1n51-T~jYX2?8 zj)qj!?gLAUYGE={haVN>P^kqaeF=$oc$m9+Laf3ikc40}Rn|7g zBV_hTM-HF4e0)QsoorjqmB!Y2XnIh4wS-Ly-z!Rrj^xjt(3RVm>nwN1hmBw2@P;w3 zelZU=a6PuC>NMarJq)(OST-OQAmC8uXTW_uIzpP zB7yJae4{{IvM3ucrz9<+99W7(+~FzB*>XGh&wqrV>^hKfkQt+r*@)KkOX|XyvU5u0 z2*qS3F&i@zQfGR6LH;DUmo`@5ytNZKsKKI$0R;MySN}lajdewE$=DPDJj=}@? z#TnZh%+i&U-#$-sF0elpK8cwX$#x)953>3@uS1PHk9Absn}1ceOpxDhD|%Ips%6}| zP}1jhL~6IeyOwjewIc*)6+&`5-A~9AJ9gvxZbNlx*996L8=^EOwErbk@|-`f(FcRfFE&d1;ni5gr-?}dEHXd?5u z3d(JRMO&*xA46M_wp%(w3AVUJUp*So>8Sau2p4F@P~sXNtJ{q2}S?Sv&ls3sK~tYv6}OHZMhcJTUo+ ziQdBK1$(*gPZT^$aRLfaC^Ze3y~=w>QSo=oTxgaWkyaZ;)DH>Ch|Wy5HcfUI>R z;ypwbOGu--8!1{qu^inQqr2`2@{LXG`ADpAp$&&lJO|+;6G}F1i8x`Hzz=Y+#XY(* zIQZi;SWF1SIvi#GEWr*1e=~si)JxcOi))89+TTNp1VIIYedgT~$PZv21BjzZ-*4+i z7DbSiE-o8NUzu8am@3t#b{nIvUy6O23{;}PxL2-FD(N1DzZ&9`B!g^-9%uqFXM>2C zpu^eYy1rDSC($-jG^2cjHtL{!jb4@s^z5}am*tN`4~T<^#6bk0S)NH~9zl|B?IeOlA8g;N1O`+>TSjr@v3!E6fp%V_4yJ^5W=pD0MOxvXLkirGEHCo@29 zT){(gK(25wZ96QiLPSccZS=!n&N>I5Rso`VkEy3*Ab3D73epY^u5a!sNDcJ#?Uln& z7-#Ei8|tW}@Qo@N%10h$BfBbGx7mU*6&OrEFoECm9)V~=gSgbuVn0UGF7B5UE;D~qK>MA%nwB%c=6IHEohI*rO# zEnx>9kwcIxh(-4>7+ED8_B3y-6jE5*?x3d=G;|aju;Yr1Eg+Z<`|c^7MAIkBrV!{j zkQmhO8HLV%+$$0$IYy{d0d2en3)IAQ2ZI5kC8NXLN|;2$XeYyCVf_!E6{?2?F8xz@ zKLF9TnF>iG@_dJLJsbT|hKG;QU{gc!C9*|JqlH6V3Bz9tbd+Wkl}dyrqJ17wEa(KUCc*m!$UJ3rdP7fC*JyDh=f^46G9lwhikpM){BRr9LGX z@k&gfubWd*I8<{4(rPWBl_qN@Hg4|Yk)_yoB@)eR@*%TPY6qUAa z3*AWzLQt)`t~LTDzw0T{N>-7GrG=dHzAlH9lr7DhAgye6?apN^3vFz2CPZ@1h3t8u zY}dsMC8~m8X4K0`tnS5<(n-il*}r(iYx2CxJoVeEI8r5LI%}OeqOKI_#rfD4k~e89 zn4nfm2lH5`O-VIorK~(YjJSL$)C<=8kPRbBEN+qNebK3R>ePMg%gt{}M=Ncfkutcl_wY&Lh zc1%}ycxrY7R`=uecfX50TT65j=^dNKRtq$o-mIQ|$C}M%+c0i_ve%vqB0sAnJvUvu zby_R%)6MbKW4{?lG4k6)Z6Lmon{s+HSNwz!^c=;nWtZ#hh>KRg6vDr+qpo6iONL|# zNh-Vu5sPW@n5<*=8jKi_Z(xdSc!qAUm&ub#AdIZz^BS&OF3eeJ6%-;8@3)1m6rBog zkmhgv`lOhXwAB4!iSe^;5A6mS+9v+4HjyMS5mT?gT$qIZ%P!_7L;40eRoMsI6k@zj zz*VOHM?=Qh%~#6JE!Cgdb`9%-Uuamr>@93^zy5@mg->UTwUO~{{`XlYTw;rVcaz*1 z^IUrYTDrUeq87L{KBxbJ|5JqY zyZU$`c4)w?_Hunv;P2brjLg&?u{~$!Jx7sW>zW}onZ7RiST#X$wzUXeBC*~gzdT>} zvNV6K2kot4?91}+lkl7SpYCyQ{IVY+_Cbq)+qN<|`D1o%^--qp#8DbU<<|g$h_f*h zJmev^y@XyJ<-PO2GTS*5Zp~u!EfSOude?vT%37py9Qc&&g)v+BzGBa6hQ`nCfzb|q zdVj?-nCIT^d3*0`8*f}`VuDyGK>3eap47ufqkB^%-v3~I* zf?>kx#wK{gh-~J6^LtfdQ3Pmv=d=Fe9LD({xG@~8Yag5+{D8e$X5j1><{x?yTi6C- zVucS= z`c;F@AYx?2(MaRbxr(O}KC!@9_2@L16*12zc%d#9i-L*|W>}A+5!J&>tv*cqw zm}00qzLh(k`43~a_`h5OKWo_H*2miD34ADQQ@KJ?fYw?280Bxt4%I0tHPBB?zt`>@ z?PnD}r-g2r-7N5+07toN$*$$^VMXQfRPTA{?#J2A^AnhLSG6wz`o+7xeGc1;Y~B+R z+_RCu3y|g?oNuC3?^+AO%SlueKTn^@pJ*|$3Cc6;<^K&${(uukWhW?eL5f0;9%|c% zd_?m}$TmyxB6fuGi|P{5gwg$Qz7^+sd54T3q9N)YDu4u`zqO_N0f3b!FCS*VYb4>MGQE z0qqxg;SW24lHc-uMj0j-iOSi%YA6rG&%)vJi|+%%-x?vUUA`e$1iyYp-Xs~z3vVCagH zaqE&^3|#w2{Pl*unNjz|NSGxBF}Ua>^yg%XcbJ{n zyFNaL?eNp%(W`=Y=ePz}k0L_)KDT4NH!8T|d@c@Qwig+wPjR9`l|Bz)8E%#ScQACP z)W|cHwX4*&_l;Zo?`_)$VEIyKtS>J{mSn7W!1J!W`={Bm!6>(A+ef@R#|`Tn{WYhd zvb!i{M+eL&gx#;<{?Fz=Co&<21n|dW9IN^|JIjpUf+Ej|oF`o^&ztTm86QQN1KSaU zQYCsl0Qy{IdLcwkH+d<)Vzizb)^@SgD6~=m}QsB)^VUU-%(;=MBY8l=9e&rLx z!^!(woz+!%gf|=|hyWQS5Q8go-4_@AT@0t}W@ZNn_`%zi$*$cOLW@t8AZ*d zPeH1>9t@(Bg$Cih?+p%R)a(?Z{jl4f#HL2pJYUt_9*OqFT}bus-nbtImrS>LmdR8u zx|)%-xc#;-nHKu|`g~>1*K$qan0=D>c|VAeHLHbG@wR&+xHTG~uDAXQ;qKIB(}nn1 zS_#teF+#UjoBP7?r!{ zJ&eS#+ISx~DaY$LH@f~}Gji0=pXql;J>g(yN50((F>T(&6)Fw6P|+UhN2# zJEt`82d_^Qyae`JYn)s5AaS=vu#NLtwt4NXh6^X|9InRDL!zEtoP!1!)BEg1_+2pY zM-!`N!|Wa$4tUMp!G|M+uT7387$LW1-hz%ds|9`UL_Hea?&(b0ym8iAZ+AD9eyuo8 zEc7iJ&jf4e`RwA!W;(Cl@TBV3QfeYAxZ@=xS}_*xlIiLDUh2 z?}E7sZ#BZGyXzA}SQh!jBA9ojHN#kYlZ=AdVuEr)ncV9)L*4Q)==3SdnCKzWR14V< z=?FgKIJ!!VJbf{a;H?P0+S;W6hVOxML37fOw2+~+^A3Bv>@Rz%Fm?@Ns9obhii@-U zTtTK|4AXufxY9Q*NCw8oXv$i9U%Ei6+ebV!heo!NQeq~qlIrP;RR&W< z1mZj#z=E~mmW6S)_}T{0tnUo}VaH%cb^L2bV?8eKCbl}R=w~QCt{mn)I<6X*5o`yd zOE_vsVgPfyYL}glPU_YJSx@V?6Rb`f_VbHR8;@(3Qe}N^1ZJA$PG%>(u6L~nTkmDm z{mUNFbk)7lv-l?hE`cTGs%Vna=bfNCLL^g+8$s1hykE_+J%H~FXAUSEnJekkqp-p?*fkTdS$<0;{m8S zM^plpHD1&ve*Cfl&1k#mskv$@oZQT#_lVi_5$$N8Ec_^TjT&YCSKYn*7FOS_xbD3L zw(fWE6PGnlc$y2Im0*+v-rq4jmCdjxB~|YaNzY{xn&gxYTS;3sD!b677S}yB!f4bD zHO^PJJ*aW6;{s}ju4N&Q-x$7#)x0qCp=9ryXX_DLUf(f@T4az1<{ zc84(VbmOANa5OZiMtNzK-o(z8FH8NCf@ur~>7FXx-h5^UkrdLBIcUHgvCk(ga_q zMlr;a(7c#Ph$Xq6`*R0Np>vVM;x}&Nvr26!l5KP*T91R-;tacO>#Ha@Pyqp)7$7+2 zCn-O|KL}r?B*fMCB@@r1m~4xK=2M8fp+a27#Z}rLpkHHI52F~rc4H7UX?DHwiRSo) z*$qiRa_GtgR**&lz@Fq{3nHc&b*@GjQhz%0DnG* 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 z diff --git a/src/common.build.tests.props b/src/common.build.tests.props index 79410878836..02dc8706ef7 100644 --- a/src/common.build.tests.props +++ b/src/common.build.tests.props @@ -5,11 +5,11 @@ INLINE_TEST_METHOD_MARKUP;UNIT_TESTING;%(PreprocessorDefinitions) - + This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. - + diff --git a/src/host/ft_uia/Host.Tests.UIA.csproj b/src/host/ft_uia/Host.Tests.UIA.csproj index c963f3d9624..d85b269e2e9 100644 --- a/src/host/ft_uia/Host.Tests.UIA.csproj +++ b/src/host/ft_uia/Host.Tests.UIA.csproj @@ -53,7 +53,10 @@ - ..\..\..\packages\Taef.Redist.Wlk.10.51.200127004\lib\net45\TE.Managed.dll + ..\..\..\packages\Taef.Redist.Wlk.10.57.200731005-develop\lib\net45\TE.Managed.dll + + + ..\..\..\packages\Taef.Redist.Wlk.10.57.200731005-develop\lib\net45\TE.Model.Managed.dll @@ -64,10 +67,10 @@ ..\..\..\packages\Selenium.Support.3.5.0\lib\net40\WebDriver.Support.dll - ..\..\..\packages\Taef.Redist.Wlk.10.51.200127004\lib\net45\Wex.Common.Managed.dll + ..\..\..\packages\Taef.Redist.Wlk.10.57.200731005-develop\lib\net45\Wex.Common.Managed.dll - ..\..\..\packages\Taef.Redist.Wlk.10.51.200127004\lib\net45\Wex.Logger.Interop.dll + ..\..\..\packages\Taef.Redist.Wlk.10.57.200731005-develop\lib\net45\Wex.Logger.Interop.dll @@ -142,11 +145,11 @@ copy $(SolutionDir)\dep\WinAppDriver\* $(OutDir)\ - + This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. - + - + \ No newline at end of file diff --git a/src/host/ft_uia/app.config b/src/host/ft_uia/app.config index bf061caaf76..5d6775b6725 100644 --- a/src/host/ft_uia/app.config +++ b/src/host/ft_uia/app.config @@ -8,7 +8,7 @@ - + diff --git a/src/host/ft_uia/packages.config b/src/host/ft_uia/packages.config index 6629afad84b..101824b09d4 100644 --- a/src/host/ft_uia/packages.config +++ b/src/host/ft_uia/packages.config @@ -5,5 +5,5 @@ - - + + \ No newline at end of file diff --git a/src/terminal/parser/ut_parser/Parser.UnitTests.vcxproj b/src/terminal/parser/ut_parser/Parser.UnitTests.vcxproj index 02e923f575e..df36be81a1b 100644 --- a/src/terminal/parser/ut_parser/Parser.UnitTests.vcxproj +++ b/src/terminal/parser/ut_parser/Parser.UnitTests.vcxproj @@ -6,15 +6,12 @@ ParserUnitTests TerminalParser.UnitTests ConParser.Unit.Tests - DynamicLibrary + DynamicLibrary - - - @@ -26,13 +23,11 @@ Create - ..;%(AdditionalIncludeDirectories) - {18d09a24-8240-42d6-8cb6-236eee820263} @@ -44,9 +39,17 @@ {3ae13314-1939-4dfa-9c14-38ca0834050c} - - + + + - + + + + This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. + + + + \ No newline at end of file diff --git a/src/terminal/parser/ut_parser/Parser.UnitTests.vcxproj.filters b/src/terminal/parser/ut_parser/Parser.UnitTests.vcxproj.filters index adc0b0fec1f..40253dffc1c 100644 --- a/src/terminal/parser/ut_parser/Parser.UnitTests.vcxproj.filters +++ b/src/terminal/parser/ut_parser/Parser.UnitTests.vcxproj.filters @@ -36,4 +36,10 @@ Header Files - + + + + + + + \ No newline at end of file diff --git a/src/terminal/parser/ut_parser/packages.config b/src/terminal/parser/ut_parser/packages.config index 42477ca456a..3a630c09c2c 100644 --- a/src/terminal/parser/ut_parser/packages.config +++ b/src/terminal/parser/ut_parser/packages.config @@ -1,4 +1,4 @@  - - + + \ No newline at end of file diff --git a/tools/OpenConsole.psm1 b/tools/OpenConsole.psm1 index bef3078a0d2..78c5416eddb 100644 --- a/tools/OpenConsole.psm1 +++ b/tools/OpenConsole.psm1 @@ -189,7 +189,7 @@ function Invoke-OpenConsoleTests() } $OpenConsolePath = "$env:OpenConsoleroot\bin\$OpenConsolePlatform\$Configuration\OpenConsole.exe" $RunTePath = "$env:OpenConsoleRoot\tools\runte.cmd" - $TaefExePath = "$env:OpenConsoleRoot\packages\Taef.Redist.Wlk.10.51.200127004\build\Binaries\$Platform\te.exe" + $TaefExePath = "$env:OpenConsoleRoot\packages\Taef.Redist.Wlk.10.57.200731005-develop\build\Binaries\$Platform\te.exe" $BinDir = "$env:OpenConsoleRoot\bin\$OpenConsolePlatform\$Configuration" [xml]$TestConfig = Get-Content "$env:OpenConsoleRoot\tools\tests.xml" diff --git a/tools/razzle.cmd b/tools/razzle.cmd index 0851160f9ef..9dedd23caca 100644 --- a/tools/razzle.cmd +++ b/tools/razzle.cmd @@ -104,7 +104,7 @@ shift goto :ARGS_LOOP :POST_ARGS_LOOP -set TAEF=%OPENCON%\packages\Taef.Redist.Wlk.10.51.200127004\build\Binaries\%ARCH%\TE.exe +set TAEF=%OPENCON%\packages\Taef.Redist.Wlk.10.57.200731005-develop\build\Binaries\%ARCH%\TE.exe rem Set this envvar so setup won't repeat itself set OpenConBuild=true From 7bf9225c155ea7062c9dd0825078417e0045ac81 Mon Sep 17 00:00:00 2001 From: Mike Griese Date: Mon, 3 Aug 2020 16:13:30 -0500 Subject: [PATCH 30/33] Research how many characters users are typing before dismissing the cmdpal (#7165) Add some user research to determine what the average number of characters a user types before executing a cmdpal action. This might need to be modified when it merges with #6732 --- src/cascadia/TerminalApp/CommandPalette.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/cascadia/TerminalApp/CommandPalette.cpp b/src/cascadia/TerminalApp/CommandPalette.cpp index 0e67a0c2c2e..fd0a139281b 100644 --- a/src/cascadia/TerminalApp/CommandPalette.cpp +++ b/src/cascadia/TerminalApp/CommandPalette.cpp @@ -187,15 +187,16 @@ namespace winrt::TerminalApp::implementation { const auto actionAndArgs = command.Action(); _dispatch.DoAction(actionAndArgs); - _close(); TraceLoggingWrite( g_hTerminalAppProvider, // handle to TerminalApp tracelogging provider "CommandPaletteDispatchedAction", TraceLoggingDescription("Event emitted when the user selects an action in the Command Palette"), - TraceLoggingUInt32(_searchBox().Text().size(), "Number of characters in the search string"), + TraceLoggingUInt32(_searchBox().Text().size(), "SearchTextLength", "Number of characters in the search string"), TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES), TelemetryPrivacyDataTag(PDT_ProductAndServicePerformance)); + + _close(); } } From eb8bb09e5be661ca7e717f0cb94b5712a27a97fb Mon Sep 17 00:00:00 2001 From: Carlos Zamora Date: Mon, 3 Aug 2020 15:54:22 -0700 Subject: [PATCH 31/33] Move TerminalSettings object to TermApp Project (#7163) Move TerminalSettings object from TerminalSettings project (Microsoft.Terminal.Settings) to TerminalApp project. `TerminalSettings` specifically operates as a bridge that exposes any necessary information to a TerminalControl. Closes #7139 Related Epic: #885 Related Spec: #6904 ## PR Checklist * [X] Closes #7139 * [X] CLA signed * [X] Tests ~added~/passed (no additional tests necessary) * [X] ~Documentation updated~ * [X] ~Schema updated~ ## Validation Steps Performed Deployed Windows Terminal and opened a few new tabs. --- .../LocalTests_TerminalApp/SettingsTests.cpp | 2 +- src/cascadia/LocalTests_TerminalApp/TabTests.cpp | 4 ++-- src/cascadia/TerminalApp/CascadiaSettings.h | 4 ++-- src/cascadia/TerminalApp/ColorScheme.cpp | 4 ++-- src/cascadia/TerminalApp/ColorScheme.h | 4 ++-- src/cascadia/TerminalApp/GlobalAppSettings.h | 2 +- src/cascadia/TerminalApp/Pane.h | 2 +- src/cascadia/TerminalApp/Profile.cpp | 1 + src/cascadia/TerminalApp/Profile.h | 2 +- src/cascadia/TerminalApp/Tab.h | 2 +- src/cascadia/TerminalApp/TerminalPage.cpp | 7 +++---- src/cascadia/TerminalApp/TerminalPage.h | 4 ++-- .../TerminalSettings.cpp | 2 +- .../TerminalSettings.h} | 12 ++++++------ .../TerminalSettings.idl | 9 +++------ src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj | 7 +++++++ .../TerminalApp/lib/TerminalAppLib.vcxproj.filters | 12 ++++++++---- src/cascadia/TerminalControl/TermControl.cpp | 5 ----- src/cascadia/TerminalControl/TermControl.h | 1 - src/cascadia/TerminalControl/TermControl.idl | 1 - .../TerminalSettings/TerminalSettings.vcxproj | 12 +----------- 21 files changed, 45 insertions(+), 54 deletions(-) rename src/cascadia/{TerminalSettings => TerminalApp}/TerminalSettings.cpp (87%) rename src/cascadia/{TerminalSettings/terminalsettings.h => TerminalApp/TerminalSettings.h} (84%) rename src/cascadia/{TerminalSettings => TerminalApp}/TerminalSettings.idl (75%) diff --git a/src/cascadia/LocalTests_TerminalApp/SettingsTests.cpp b/src/cascadia/LocalTests_TerminalApp/SettingsTests.cpp index cdfb08415f5..f1eeddc2641 100644 --- a/src/cascadia/LocalTests_TerminalApp/SettingsTests.cpp +++ b/src/cascadia/LocalTests_TerminalApp/SettingsTests.cpp @@ -93,7 +93,7 @@ namespace TerminalAppLocalTests void SettingsTests::TryCreateWinRTType() { - winrt::Microsoft::Terminal::Settings::TerminalSettings settings; + TerminalSettings settings; VERIFY_IS_NOT_NULL(settings); auto oldFontSize = settings.FontSize(); settings.FontSize(oldFontSize + 5); diff --git a/src/cascadia/LocalTests_TerminalApp/TabTests.cpp b/src/cascadia/LocalTests_TerminalApp/TabTests.cpp index b515eacd93e..3c417174c59 100644 --- a/src/cascadia/LocalTests_TerminalApp/TabTests.cpp +++ b/src/cascadia/LocalTests_TerminalApp/TabTests.cpp @@ -84,7 +84,7 @@ namespace TerminalAppLocalTests { // Verify we can create a WinRT type we authored // Just creating it is enough to know that everything is working. - winrt::Microsoft::Terminal::Settings::TerminalSettings settings; + TerminalSettings settings; VERIFY_IS_NOT_NULL(settings); auto oldFontSize = settings.FontSize(); settings.FontSize(oldFontSize + 5); @@ -140,7 +140,7 @@ namespace TerminalAppLocalTests // 4. one of our types that uses MUX/Xaml in this dll (Tab). // Just creating all of them is enough to know that everything is working. const auto profileGuid{ Utils::CreateGuid() }; - winrt::Microsoft::Terminal::Settings::TerminalSettings settings{}; + TerminalSettings settings{}; VERIFY_IS_NOT_NULL(settings); winrt::Microsoft::Terminal::TerminalConnection::EchoConnection conn{}; VERIFY_IS_NOT_NULL(conn); diff --git a/src/cascadia/TerminalApp/CascadiaSettings.h b/src/cascadia/TerminalApp/CascadiaSettings.h index 004f3809423..08a65fba5d7 100644 --- a/src/cascadia/TerminalApp/CascadiaSettings.h +++ b/src/cascadia/TerminalApp/CascadiaSettings.h @@ -54,8 +54,8 @@ class TerminalApp::CascadiaSettings final static const CascadiaSettings& GetCurrentAppSettings(); - std::tuple BuildSettings(const winrt::TerminalApp::NewTerminalArgs& newTerminalArgs) const; - winrt::Microsoft::Terminal::Settings::TerminalSettings BuildSettings(GUID profileGuid) const; + std::tuple BuildSettings(const winrt::TerminalApp::NewTerminalArgs& newTerminalArgs) const; + winrt::TerminalApp::TerminalSettings BuildSettings(GUID profileGuid) const; GlobalAppSettings& GlobalSettings(); diff --git a/src/cascadia/TerminalApp/ColorScheme.cpp b/src/cascadia/TerminalApp/ColorScheme.cpp index 525d8ec95cd..1659013809c 100644 --- a/src/cascadia/TerminalApp/ColorScheme.cpp +++ b/src/cascadia/TerminalApp/ColorScheme.cpp @@ -2,6 +2,7 @@ // Licensed under the MIT license. #include "pch.h" +#include #include "ColorScheme.h" #include "DefaultSettings.h" #include "../../types/inc/Utils.hpp" @@ -10,8 +11,7 @@ using namespace ::Microsoft::Console; using namespace TerminalApp; -using namespace winrt::Microsoft::Terminal::Settings; -using namespace winrt::Microsoft::Terminal::TerminalControl; +using namespace winrt::TerminalApp; static constexpr std::string_view NameKey{ "name" }; static constexpr std::string_view ForegroundKey{ "foreground" }; diff --git a/src/cascadia/TerminalApp/ColorScheme.h b/src/cascadia/TerminalApp/ColorScheme.h index 92f8f4f6d70..dca0f53759a 100644 --- a/src/cascadia/TerminalApp/ColorScheme.h +++ b/src/cascadia/TerminalApp/ColorScheme.h @@ -15,8 +15,8 @@ Author(s): --*/ #pragma once -#include #include +#include "TerminalSettings.h" #include "../../inc/conattrs.hpp" // fwdecl unittest classes @@ -38,7 +38,7 @@ class TerminalApp::ColorScheme ColorScheme(std::wstring name, til::color defaultFg, til::color defaultBg, til::color cursorColor); ~ColorScheme(); - void ApplyScheme(winrt::Microsoft::Terminal::Settings::TerminalSettings terminalSettings) const; + void ApplyScheme(winrt::TerminalApp::TerminalSettings terminalSettings) const; static ColorScheme FromJson(const Json::Value& json); bool ShouldBeLayered(const Json::Value& json) const; diff --git a/src/cascadia/TerminalApp/GlobalAppSettings.h b/src/cascadia/TerminalApp/GlobalAppSettings.h index 7491b433f41..78222106716 100644 --- a/src/cascadia/TerminalApp/GlobalAppSettings.h +++ b/src/cascadia/TerminalApp/GlobalAppSettings.h @@ -46,7 +46,7 @@ class TerminalApp::GlobalAppSettings final static GlobalAppSettings FromJson(const Json::Value& json); void LayerJson(const Json::Value& json); - void ApplyToSettings(winrt::Microsoft::Terminal::Settings::TerminalSettings& settings) const noexcept; + void ApplyToSettings(winrt::TerminalApp::TerminalSettings& settings) const noexcept; std::vector GetKeybindingsWarnings() const; diff --git a/src/cascadia/TerminalApp/Pane.h b/src/cascadia/TerminalApp/Pane.h index a9c7bd9cebb..dfbcf1e7bc2 100644 --- a/src/cascadia/TerminalApp/Pane.h +++ b/src/cascadia/TerminalApp/Pane.h @@ -51,7 +51,7 @@ class Pane : public std::enable_shared_from_this void ClearActive(); void SetActive(); - void UpdateSettings(const winrt::Microsoft::Terminal::Settings::TerminalSettings& settings, + void UpdateSettings(const winrt::TerminalApp::TerminalSettings& settings, const GUID& profile); void ResizeContent(const winrt::Windows::Foundation::Size& newSize); void Relayout(); diff --git a/src/cascadia/TerminalApp/Profile.cpp b/src/cascadia/TerminalApp/Profile.cpp index 7cd80a65b11..b98efb9f691 100644 --- a/src/cascadia/TerminalApp/Profile.cpp +++ b/src/cascadia/TerminalApp/Profile.cpp @@ -12,6 +12,7 @@ #include "TerminalSettingsSerializationHelpers.h" using namespace TerminalApp; +using namespace winrt::TerminalApp; using namespace winrt::Microsoft::Terminal::Settings; using namespace winrt::Windows::UI::Xaml; using namespace ::Microsoft::Console; diff --git a/src/cascadia/TerminalApp/Profile.h b/src/cascadia/TerminalApp/Profile.h index 17edad98bb6..1e145e669c7 100644 --- a/src/cascadia/TerminalApp/Profile.h +++ b/src/cascadia/TerminalApp/Profile.h @@ -46,7 +46,7 @@ class TerminalApp::Profile final ~Profile(); - winrt::Microsoft::Terminal::Settings::TerminalSettings CreateTerminalSettings(const std::unordered_map& schemes) const; + winrt::TerminalApp::TerminalSettings CreateTerminalSettings(const std::unordered_map& schemes) const; Json::Value GenerateStub() const; static Profile FromJson(const Json::Value& json); diff --git a/src/cascadia/TerminalApp/Tab.h b/src/cascadia/TerminalApp/Tab.h index a6752fe6bbe..055d631c421 100644 --- a/src/cascadia/TerminalApp/Tab.h +++ b/src/cascadia/TerminalApp/Tab.h @@ -46,7 +46,7 @@ namespace winrt::TerminalApp::implementation void ResizePane(const winrt::TerminalApp::Direction& direction); void NavigateFocus(const winrt::TerminalApp::Direction& direction); - void UpdateSettings(const winrt::Microsoft::Terminal::Settings::TerminalSettings& settings, const GUID& profile); + void UpdateSettings(const winrt::TerminalApp::TerminalSettings& settings, const GUID& profile); winrt::hstring GetActiveTitle() const; void Shutdown(); diff --git a/src/cascadia/TerminalApp/TerminalPage.cpp b/src/cascadia/TerminalApp/TerminalPage.cpp index fd613d8a82e..30689891f04 100644 --- a/src/cascadia/TerminalApp/TerminalPage.cpp +++ b/src/cascadia/TerminalApp/TerminalPage.cpp @@ -32,7 +32,6 @@ using namespace winrt::Windows::UI::Text; using namespace winrt::Microsoft::Terminal; using namespace winrt::Microsoft::Terminal::TerminalControl; using namespace winrt::Microsoft::Terminal::TerminalConnection; -using namespace winrt::Microsoft::Terminal::Settings; using namespace ::TerminalApp; using namespace ::Microsoft::Console; @@ -626,7 +625,7 @@ namespace winrt::TerminalApp::implementation // currently displayed, it will be shown. // Arguments: // - settings: the TerminalSettings object to use to create the TerminalControl with. - void TerminalPage::_CreateNewTabFromSettings(GUID profileGuid, TerminalSettings settings) + void TerminalPage::_CreateNewTabFromSettings(GUID profileGuid, TerminalApp::TerminalSettings settings) { // Initialize the new tab @@ -727,7 +726,7 @@ namespace winrt::TerminalApp::implementation // Return value: // - the desired connection TerminalConnection::ITerminalConnection TerminalPage::_CreateConnectionFromSettings(GUID profileGuid, - winrt::Microsoft::Terminal::Settings::TerminalSettings settings) + TerminalApp::TerminalSettings settings) { const auto* const profile = _settings->FindProfile(profileGuid); @@ -1368,7 +1367,7 @@ namespace winrt::TerminalApp::implementation try { auto focusedTab = _GetStrongTabImpl(*indexOpt); - winrt::Microsoft::Terminal::Settings::TerminalSettings controlSettings; + TerminalApp::TerminalSettings controlSettings; GUID realGuid; bool profileFound = false; diff --git a/src/cascadia/TerminalApp/TerminalPage.h b/src/cascadia/TerminalApp/TerminalPage.h index f78cfe86f23..021be7a3e16 100644 --- a/src/cascadia/TerminalApp/TerminalPage.h +++ b/src/cascadia/TerminalApp/TerminalPage.h @@ -118,8 +118,8 @@ namespace winrt::TerminalApp::implementation void _CreateNewTabFlyout(); void _OpenNewTabDropdown(); void _OpenNewTab(const winrt::TerminalApp::NewTerminalArgs& newTerminalArgs); - void _CreateNewTabFromSettings(GUID profileGuid, winrt::Microsoft::Terminal::Settings::TerminalSettings settings); - winrt::Microsoft::Terminal::TerminalConnection::ITerminalConnection _CreateConnectionFromSettings(GUID profileGuid, winrt::Microsoft::Terminal::Settings::TerminalSettings settings); + void _CreateNewTabFromSettings(GUID profileGuid, TerminalApp::TerminalSettings settings); + winrt::Microsoft::Terminal::TerminalConnection::ITerminalConnection _CreateConnectionFromSettings(GUID profileGuid, TerminalApp::TerminalSettings settings); void _SettingsButtonOnClick(const IInspectable& sender, const Windows::UI::Xaml::RoutedEventArgs& eventArgs); void _FeedbackButtonOnClick(const IInspectable& sender, const Windows::UI::Xaml::RoutedEventArgs& eventArgs); diff --git a/src/cascadia/TerminalSettings/TerminalSettings.cpp b/src/cascadia/TerminalApp/TerminalSettings.cpp similarity index 87% rename from src/cascadia/TerminalSettings/TerminalSettings.cpp rename to src/cascadia/TerminalApp/TerminalSettings.cpp index 02d8f452e8f..3313736e653 100644 --- a/src/cascadia/TerminalSettings/TerminalSettings.cpp +++ b/src/cascadia/TerminalApp/TerminalSettings.cpp @@ -6,7 +6,7 @@ #include "TerminalSettings.g.cpp" -namespace winrt::Microsoft::Terminal::Settings::implementation +namespace winrt::TerminalApp::implementation { uint32_t TerminalSettings::GetColorTableEntry(int32_t index) const noexcept { diff --git a/src/cascadia/TerminalSettings/terminalsettings.h b/src/cascadia/TerminalApp/TerminalSettings.h similarity index 84% rename from src/cascadia/TerminalSettings/terminalsettings.h rename to src/cascadia/TerminalApp/TerminalSettings.h index 1bd1aad98ae..02998373e7d 100644 --- a/src/cascadia/TerminalSettings/terminalsettings.h +++ b/src/cascadia/TerminalApp/TerminalSettings.h @@ -19,7 +19,7 @@ Author(s): #include #include -namespace winrt::Microsoft::Terminal::Settings::implementation +namespace winrt::TerminalApp::implementation { struct TerminalSettings : TerminalSettingsT { @@ -49,7 +49,7 @@ namespace winrt::Microsoft::Terminal::Settings::implementation GETSET_PROPERTY(bool, SnapOnInput, true); GETSET_PROPERTY(bool, AltGrAliasing, true); GETSET_PROPERTY(uint32_t, CursorColor, DEFAULT_CURSOR_COLOR); - GETSET_PROPERTY(CursorStyle, CursorShape, CursorStyle::Vintage); + GETSET_PROPERTY(Microsoft::Terminal::Settings::CursorStyle, CursorShape, Microsoft::Terminal::Settings::CursorStyle::Vintage); GETSET_PROPERTY(uint32_t, CursorHeight, DEFAULT_CURSOR_HEIGHT); GETSET_PROPERTY(hstring, WordDelimiters, DEFAULT_WORD_DELIMITERS); GETSET_PROPERTY(bool, CopyOnSelect, false); @@ -78,7 +78,7 @@ namespace winrt::Microsoft::Terminal::Settings::implementation BackgroundImageVerticalAlignment, winrt::Windows::UI::Xaml::VerticalAlignment::Center); - GETSET_PROPERTY(IKeyBindings, KeyBindings, nullptr); + GETSET_PROPERTY(Microsoft::Terminal::Settings::IKeyBindings, KeyBindings, nullptr); GETSET_PROPERTY(hstring, Commandline); GETSET_PROPERTY(hstring, StartingDirectory); @@ -86,9 +86,9 @@ namespace winrt::Microsoft::Terminal::Settings::implementation GETSET_PROPERTY(bool, SuppressApplicationTitle); GETSET_PROPERTY(hstring, EnvironmentVariables); - GETSET_PROPERTY(ScrollbarState, ScrollState, ScrollbarState::Visible); + GETSET_PROPERTY(Microsoft::Terminal::Settings::ScrollbarState, ScrollState, Microsoft::Terminal::Settings::ScrollbarState::Visible); - GETSET_PROPERTY(TextAntialiasingMode, AntialiasingMode, TextAntialiasingMode::Grayscale); + GETSET_PROPERTY(Microsoft::Terminal::Settings::TextAntialiasingMode, AntialiasingMode, Microsoft::Terminal::Settings::TextAntialiasingMode::Grayscale); GETSET_PROPERTY(bool, RetroTerminalEffect, false); GETSET_PROPERTY(bool, ForceFullRepaintRendering, false); @@ -102,7 +102,7 @@ namespace winrt::Microsoft::Terminal::Settings::implementation }; } -namespace winrt::Microsoft::Terminal::Settings::factory_implementation +namespace winrt::TerminalApp::factory_implementation { BASIC_FACTORY(TerminalSettings); } diff --git a/src/cascadia/TerminalSettings/TerminalSettings.idl b/src/cascadia/TerminalApp/TerminalSettings.idl similarity index 75% rename from src/cascadia/TerminalSettings/TerminalSettings.idl rename to src/cascadia/TerminalApp/TerminalSettings.idl index 15d265b1a9e..3d7d4880107 100644 --- a/src/cascadia/TerminalSettings/TerminalSettings.idl +++ b/src/cascadia/TerminalApp/TerminalSettings.idl @@ -1,10 +1,7 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT license. -import "ICoreSettings.idl"; -import "IControlSettings.idl"; - -namespace Microsoft.Terminal.Settings +namespace TerminalApp { // Class Description: // TerminalSettings encapsulates all settings that control the @@ -15,8 +12,8 @@ namespace Microsoft.Terminal.Settings // The TerminalControl will pull settings it requires from this object, // and pass along the Core properties to the terminal core. [default_interface] - runtimeclass TerminalSettings : ICoreSettings, - IControlSettings + runtimeclass TerminalSettings : Microsoft.Terminal.Settings.ICoreSettings, + Microsoft.Terminal.Settings.IControlSettings { TerminalSettings(); }; diff --git a/src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj b/src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj index 0fb6b823c4c..2ceada4ea37 100644 --- a/src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj +++ b/src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj @@ -117,6 +117,9 @@ + + ../TerminalSettings.idl + ../ShortcutActionDispatch.idl @@ -186,6 +189,9 @@ + + ../TerminalSettings.idl + Create @@ -256,6 +262,7 @@ + diff --git a/src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj.filters b/src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj.filters index d716860a4af..fea379bc66c 100644 --- a/src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj.filters +++ b/src/cascadia/TerminalApp/lib/TerminalAppLib.vcxproj.filters @@ -59,7 +59,7 @@ - + settings @@ -119,7 +119,7 @@ profileGeneration - + settings @@ -139,10 +139,14 @@ tab - commandPalette + + + + settings + @@ -198,4 +202,4 @@ app - + \ No newline at end of file diff --git a/src/cascadia/TerminalControl/TermControl.cpp b/src/cascadia/TerminalControl/TermControl.cpp index 784275fa324..62bc7a948e2 100644 --- a/src/cascadia/TerminalControl/TermControl.cpp +++ b/src/cascadia/TerminalControl/TermControl.cpp @@ -56,11 +56,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation return initialized; } - TermControl::TermControl() : - TermControl(Settings::TerminalSettings{}, TerminalConnection::ITerminalConnection{ nullptr }) - { - } - TermControl::TermControl(Settings::IControlSettings settings, TerminalConnection::ITerminalConnection connection) : _connection{ connection }, _initializedTerminal{ false }, diff --git a/src/cascadia/TerminalControl/TermControl.h b/src/cascadia/TerminalControl/TermControl.h index 783ca85d967..4499c589efc 100644 --- a/src/cascadia/TerminalControl/TermControl.h +++ b/src/cascadia/TerminalControl/TermControl.h @@ -56,7 +56,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation struct TermControl : TermControlT { - TermControl(); TermControl(Settings::IControlSettings settings, TerminalConnection::ITerminalConnection connection); winrt::fire_and_forget UpdateSettings(Settings::IControlSettings newSettings); diff --git a/src/cascadia/TerminalControl/TermControl.idl b/src/cascadia/TerminalControl/TermControl.idl index d5454e50578..d9a2ac5cdff 100644 --- a/src/cascadia/TerminalControl/TermControl.idl +++ b/src/cascadia/TerminalControl/TermControl.idl @@ -32,7 +32,6 @@ namespace Microsoft.Terminal.TerminalControl [default_interface] runtimeclass TermControl : Windows.UI.Xaml.Controls.UserControl, IDirectKeyListener, IMouseWheelListener { - TermControl(); TermControl(Microsoft.Terminal.Settings.IControlSettings settings, Microsoft.Terminal.TerminalConnection.ITerminalConnection connection); static Windows.Foundation.Size GetProposedDimensions(Microsoft.Terminal.Settings.IControlSettings settings, UInt32 dpi); diff --git a/src/cascadia/TerminalSettings/TerminalSettings.vcxproj b/src/cascadia/TerminalSettings/TerminalSettings.vcxproj index 982de90ec25..eef3fe672f4 100644 --- a/src/cascadia/TerminalSettings/TerminalSettings.vcxproj +++ b/src/cascadia/TerminalSettings/TerminalSettings.vcxproj @@ -17,18 +17,13 @@ --> true - - KeyChord.idl - - TerminalSettings.idl - @@ -37,13 +32,9 @@ KeyChord.idl - - TerminalSettings.idl - - @@ -53,6 +44,5 @@ - - + \ No newline at end of file From d29be591a8ffd74777b3d3d0e417434981ceee58 Mon Sep 17 00:00:00 2001 From: "Dustin L. Howett" Date: Mon, 3 Aug 2020 18:43:17 -0700 Subject: [PATCH 32/33] Fix VT mouse capture issues in Terminal and conhost (#7166) This pull request fixes capture and event generation in VT mouse mode for both conhost and terminal. Fixes #6401. [1/3] Terminal: clamp mouse events to the viewport, don't throw them away gnome-terminal (at least) sends mouse events whose x/y are at the extreme ends of the buffer when a drag starts inside the terminal and then exits it. We would previously discard any mouse events that exited the borders of the viewport. Now we will keep emitting events where X/Y=0/w/h. [2/3] conhost: clamp VT mouse to viewport, capture pointer This is the same as (1), but for conhost. conhost wasn't already capturing the pointer when VT mouse mode was in use. By capturing, we ensure that events that happen outside the screen still result in events sent to an application (like a release after a drag) [3/3] wpf: capture the pointer when VT mouse is enabled This is the same as (2), but for the WPF control. Clamping is handled in TerminalCore in (1), so we didn't need to do it in WPF. --- .../PublicTerminalCore/HwndTerminal.cpp | 27 ++++++++++++++++-- src/cascadia/TerminalCore/Terminal.cpp | 16 +++++------ src/interactivity/win32/windowio.cpp | 28 ++++++++++++++++++- 3 files changed, 60 insertions(+), 11 deletions(-) diff --git a/src/cascadia/PublicTerminalCore/HwndTerminal.cpp b/src/cascadia/PublicTerminalCore/HwndTerminal.cpp index 27775bb314d..3c3e1600192 100644 --- a/src/cascadia/PublicTerminalCore/HwndTerminal.cpp +++ b/src/cascadia/PublicTerminalCore/HwndTerminal.cpp @@ -55,10 +55,29 @@ try if (terminal) { - if (_IsMouseMessage(uMsg) && terminal->_CanSendVTMouseInput()) + if (_IsMouseMessage(uMsg)) { - if (terminal->_SendMouseEvent(uMsg, wParam, lParam)) + if (terminal->_CanSendVTMouseInput() && terminal->_SendMouseEvent(uMsg, wParam, lParam)) { + // GH#6401: Capturing the mouse ensures that we get drag/release events + // even if the user moves outside the window. + // _SendMouseEvent returns false if the terminal's not in VT mode, so we'll + // fall through to release the capture. + switch (uMsg) + { + case WM_LBUTTONDOWN: + case WM_MBUTTONDOWN: + case WM_RBUTTONDOWN: + SetCapture(hwnd); + break; + case WM_LBUTTONUP: + case WM_MBUTTONUP: + case WM_RBUTTONUP: + ReleaseCapture(); + break; + } + + // Suppress all mouse events that made it into the terminal. return 0; } } @@ -76,6 +95,10 @@ try return 0; case WM_LBUTTONUP: terminal->_singleClickTouchdownPos = std::nullopt; + [[fallthrough]]; + case WM_MBUTTONUP: + case WM_RBUTTONUP: + ReleaseCapture(); break; case WM_MOUSEMOVE: if (WI_IsFlagSet(wParam, MK_LBUTTON)) diff --git a/src/cascadia/TerminalCore/Terminal.cpp b/src/cascadia/TerminalCore/Terminal.cpp index e7719507099..b71471fc7ef 100644 --- a/src/cascadia/TerminalCore/Terminal.cpp +++ b/src/cascadia/TerminalCore/Terminal.cpp @@ -486,14 +486,14 @@ bool Terminal::SendKeyEvent(const WORD vkey, // - false if we did not translate the key, and it should be processed into a character. bool Terminal::SendMouseEvent(const COORD viewportPos, const unsigned int uiButton, const ControlKeyStates states, const short wheelDelta) { - // viewportPos must be within the dimensions of the viewport - const auto viewportDimensions = _mutableViewport.Dimensions(); - if (viewportPos.X < 0 || viewportPos.X >= viewportDimensions.X || viewportPos.Y < 0 || viewportPos.Y >= viewportDimensions.Y) - { - return false; - } - - return _terminalInput->HandleMouse(viewportPos, uiButton, GET_KEYSTATE_WPARAM(states.Value()), wheelDelta); + // GH#6401: VT applications should be able to receive mouse events from outside the + // terminal buffer. This is likely to happen when the user drags the cursor offscreen. + // We shouldn't throw away perfectly good events when they're offscreen, so we just + // clamp them to be within the range [(0, 0), (W, H)]. +#pragma warning(suppress : 26496) // analysis can't tell we're assigning through a reference below + auto clampedPos{ viewportPos }; + _mutableViewport.ToOrigin().Clamp(clampedPos); + return _terminalInput->HandleMouse(clampedPos, uiButton, GET_KEYSTATE_WPARAM(states.Value()), wheelDelta); } // Method Description: diff --git a/src/interactivity/win32/windowio.cpp b/src/interactivity/win32/windowio.cpp index 023b14a8598..2b65f515047 100644 --- a/src/interactivity/win32/windowio.cpp +++ b/src/interactivity/win32/windowio.cpp @@ -123,7 +123,14 @@ bool HandleTerminalMouseEvent(const COORD cMousePosition, // Virtual terminal input mode if (IsInVirtualTerminalInputMode()) { - fWasHandled = gci.GetActiveInputBuffer()->GetTerminalInput().HandleMouse(cMousePosition, uiButton, sModifierKeystate, sWheelDelta); + // GH#6401: VT applications should be able to receive mouse events from outside the + // terminal buffer. This is likely to happen when the user drags the cursor offscreen. + // We shouldn't throw away perfectly good events when they're offscreen, so we just + // clamp them to be within the range [(0, 0), (W, H)]. + auto clampedPosition{ cMousePosition }; + const auto clampViewport{ gci.GetActiveOutputBuffer().GetViewport().ToOrigin() }; + clampViewport.Clamp(clampedPosition); + fWasHandled = gci.GetActiveInputBuffer()->GetTerminalInput().HandleMouse(clampedPosition, uiButton, sModifierKeystate, sWheelDelta); } return fWasHandled; @@ -635,6 +642,25 @@ BOOL HandleMouseEvent(const SCREEN_INFORMATION& ScreenInfo, if (HandleTerminalMouseEvent(MousePosition, Message, GET_KEYSTATE_WPARAM(wParam), sDelta)) { + // GH#6401: Capturing the mouse ensures that we get drag/release events + // even if the user moves outside the window. + // HandleTerminalMouseEvent returns false if the terminal's not in VT mode, + // so capturing/releasing here should not impact other console mouse event + // consumers. + switch (Message) + { + case WM_LBUTTONDOWN: + case WM_MBUTTONDOWN: + case WM_RBUTTONDOWN: + SetCapture(ServiceLocator::LocateConsoleWindow()->GetWindowHandle()); + break; + case WM_LBUTTONUP: + case WM_MBUTTONUP: + case WM_RBUTTONUP: + ReleaseCapture(); + break; + } + return FALSE; } } From cd7235661edb65e4327e7683df1b31fa967eb9d1 Mon Sep 17 00:00:00 2001 From: "Dustin L. Howett" Date: Tue, 4 Aug 2020 10:38:34 -0700 Subject: [PATCH 33/33] wpf: fixup mouse wheel events from screen coords (#7168) I found this while crawling through conhost's WindowIo. Mouse wheel events come in in screen coordinates, unlike literally every other mouse event. The WPF control was doing it wrong. --- src/cascadia/PublicTerminalCore/HwndTerminal.cpp | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/cascadia/PublicTerminalCore/HwndTerminal.cpp b/src/cascadia/PublicTerminalCore/HwndTerminal.cpp index 3c3e1600192..bb7112efb1b 100644 --- a/src/cascadia/PublicTerminalCore/HwndTerminal.cpp +++ b/src/cascadia/PublicTerminalCore/HwndTerminal.cpp @@ -21,7 +21,7 @@ static constexpr bool _IsMouseMessage(UINT uMsg) return uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONUP || uMsg == WM_LBUTTONDBLCLK || uMsg == WM_MBUTTONDOWN || uMsg == WM_MBUTTONUP || uMsg == WM_MBUTTONDBLCLK || uMsg == WM_RBUTTONDOWN || uMsg == WM_RBUTTONUP || uMsg == WM_RBUTTONDBLCLK || - uMsg == WM_MOUSEMOVE || uMsg == WM_MOUSEWHEEL; + uMsg == WM_MOUSEMOVE || uMsg == WM_MOUSEWHEEL || uMsg == WM_MOUSEHWHEEL; } // Helper static function to ensure that all ambiguous-width glyphs are reported as narrow. @@ -628,16 +628,21 @@ bool HwndTerminal::_CanSendVTMouseInput() const noexcept bool HwndTerminal::_SendMouseEvent(UINT uMsg, WPARAM wParam, LPARAM lParam) noexcept try { - const til::point cursorPosition{ + til::point cursorPosition{ GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), }; const til::size fontSize{ this->_actualFont.GetSize() }; short wheelDelta{ 0 }; - if (uMsg == WM_MOUSEWHEEL) + if (uMsg == WM_MOUSEWHEEL || uMsg == WM_MOUSEHWHEEL) { wheelDelta = HIWORD(wParam); + + // If it's a *WHEEL event, it's in screen coordinates, not window (?!) + POINT coordsToTransform = cursorPosition; + ScreenToClient(_hwnd.get(), &coordsToTransform); + cursorPosition = coordsToTransform; } return _terminal->SendMouseEvent(cursorPosition / fontSize, uMsg, getControlKeyState(), wheelDelta);