Fix for different per-monitor scaling (#657)

* Use DPIAware::DEFAULT_DPI

* Make runner DPI-unaware, since it doesn't need to use a Per Monitor V2 DPI.

* Programmatically enable "Per Monitor V2 DPI" for the runner proccess and use a separate DPI-unaware thread for the corresponding API calls

* Increase PCH memory limit for settings project

* Address review issues

* Draw zoneWindows properly scaled

src/common/common.vcxproj

@@ -98,6 +98,7 @@
     <ClInclude Include="d2d_window.h" />
     <ClInclude Include="dpi_aware.h" />
     <ClInclude Include="monitors.h" />
+    <ClInclude Include="on_thread_executor.h" />
     <ClInclude Include="pch.h" />
     <ClInclude Include="settings_helpers.h" />
     <ClInclude Include="settings_objects.h" />
@@ -117,6 +118,7 @@
     <ClCompile Include="d2d_window.cpp" />
     <ClCompile Include="dpi_aware.cpp" />
     <ClCompile Include="monitors.cpp" />
+    <ClCompile Include="on_thread_executor.cpp" />
     <ClCompile Include="pch.cpp">
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>

src/common/common.vcxproj.filters

@@ -69,6 +69,9 @@
     <ClInclude Include="version.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="on_thread_executor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="d2d_svg.cpp">
@@ -108,5 +111,8 @@
     <ClCompile Include="dpi_aware.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="on_thread_executor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

src/common/dpi_aware.cpp

@@ -37,4 +37,8 @@ void DPIAware::Convert(HMONITOR monitor_handle, int &width, int &height) {
     width = width * dpi_x / DEFAULT_DPI;
     height = height * dpi_y / DEFAULT_DPI;
   }
-}
+}
+
+void DPIAware::EnableDPIAwarenessForThisProcess() {
+    SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
+}

src/common/dpi_aware.h

@@ -1,12 +1,11 @@
 #pragma once
 #include "windef.h"
 
-class DPIAware {
-private:
-  static const int DEFAULT_DPI = 96;
+struct DPIAware {
+  static constexpr int DEFAULT_DPI = 96;
 
-public:
   static HRESULT GetScreenDPIForWindow(HWND hwnd, UINT & dpi_x, UINT & dpi_y);
   static HRESULT GetScreenDPIForPoint(POINT p, UINT& dpi_x, UINT& dpi_y);
   static void Convert(HMONITOR monitor_handle, int &width, int &height);
+  static void EnableDPIAwarenessForThisProcess();
 };

src/common/on_thread_executor.cpp

@@ -0,0 +1,38 @@
+#include "pch.h"
+
+#include "on_thread_executor.h"
+
+OnThreadExecutor::OnThreadExecutor()
+  :_worker_thread{[this]() { worker_thread(); }}
+{}
+
+std::future<void> OnThreadExecutor::submit(task_t task) {
+  auto future = task.get_future();
+  std::lock_guard lock{_task_mutex};
+  _task_queue.emplace(std::move(task));
+  _task_cv.notify_one();
+  return future;
+}
+
+void OnThreadExecutor::worker_thread() {
+  while(_active) {
+    task_t task;
+    {
+      std::unique_lock task_lock{_task_mutex};
+      _task_cv.wait(task_lock, [this] { return !_task_queue.empty() || !_active; });
+      if(!_active) {
+        break;
+      }
+      task = std::move(_task_queue.front());
+      _task_queue.pop();
+    }
+    task();
+  }
+}
+
+OnThreadExecutor::~OnThreadExecutor() {
+  _active = false;
+  _task_cv.notify_one();
+  _worker_thread.join();
+}
+

src/common/on_thread_executor.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <future>
+#include <thread>
+#include <functional>
+#include <queue>
+#include <atomic>
+
+// OnThreadExecutor allows its caller to off-load some work to a persistently running background thread.
+// This might come in handy if you use the API which sets thread-wide global state and the state needs
+// to be isolated.
+
+class OnThreadExecutor final {
+public:
+  using task_t = std::packaged_task<void()>;
+
+  OnThreadExecutor();
+  ~OnThreadExecutor();
+  std::future<void> submit(task_t task);
+
+private:
+  void worker_thread();
+
+  std::thread _worker_thread;
+
+  std::mutex _task_mutex;
+  std::condition_variable _task_cv;
+  std::atomic_bool _active;
+  std::queue<std::packaged_task<void()>> _task_queue;
+};