basalt-win32 0.0.0-rc5

package/native/win32/Win32KeyEvents.cpp

@@ -0,0 +1,126 @@
+#include "Win32KeyEvents.h"
+
+#include <windows.h>
+
+#include <cwctype>
+#include <string>
+
+namespace basalt {
+namespace {
+
+const char *specialNameFor(unsigned int virtualKey) {
+  switch (virtualKey) {
+    case VK_UP:
+      return kKeyArrowUp;
+    case VK_DOWN:
+      return kKeyArrowDown;
+    case VK_LEFT:
+      return kKeyArrowLeft;
+    case VK_RIGHT:
+      return kKeyArrowRight;
+    // Named for paging rather than for priority, which is what PRIOR and NEXT
+    // are about: VK_PRIOR is Page Up.
+    case VK_PRIOR:
+      return kKeyPageUp;
+    case VK_NEXT:
+      return kKeyPageDown;
+    case VK_HOME:
+      return kKeyHome;
+    case VK_END:
+      return kKeyEnd;
+    case VK_DELETE:
+      return kKeyDelete;
+    case VK_BACK:
+      return kKeyBackspace;
+    case VK_RETURN:
+      return kKeyEnter;
+    // Shift-Tab is VK_TAB with shift held here, unlike the other two hosts where
+    // it arrives as its own character or keyval. So there is nothing to fold
+    // together -- it already reports as Tab with the modifier set.
+    case VK_TAB:
+      return kKeyTab;
+    case VK_ESCAPE:
+      return kKeyEscape;
+    case VK_SPACE:
+      // A space is a character named " ", and the layout below would give it
+      // anyway; named here so all three hosts answer it from the same table.
+      return kKeySpace;
+    default:
+      return nullptr;
+  }
+}
+
+bool held(int virtualKey) {
+  // The high bit is "down now"; the low bit is a toggle and means Caps Lock is
+  // on rather than that Shift is held.
+  return (GetKeyState(virtualKey) & 0x8000) != 0;
+}
+
+} // namespace
+
+std::optional<KeyCombination> keyCombinationFrom(unsigned int virtualKey) {
+  KeyModifiers modifiers;
+  // VK_MENU is Alt, which is a name from a time when Alt opened menus.
+  modifiers.alt = held(VK_MENU);
+  modifiers.ctrl = held(VK_CONTROL);
+  modifiers.shift = held(VK_SHIFT);
+  // Either Windows key is `meta`, as Command is on macOS and Super is on Linux:
+  // W3C names the key in that position Meta, so an app binding metaKey presses
+  // the same physical key on all three desktops.
+  modifiers.meta = held(VK_LWIN) || held(VK_RWIN);
+
+  // A bare modifier is not a combination. Offering one would fire a shortcut on
+  // Ctrl alone, and unlike the other two hosts there is no empty character here
+  // to detect it by -- the virtual key has to be recognised.
+  switch (virtualKey) {
+    case VK_SHIFT:
+    case VK_LSHIFT:
+    case VK_RSHIFT:
+    case VK_CONTROL:
+    case VK_LCONTROL:
+    case VK_RCONTROL:
+    case VK_MENU:
+    case VK_LMENU:
+    case VK_RMENU:
+    case VK_LWIN:
+    case VK_RWIN:
+    case VK_CAPITAL:
+      return std::nullopt;
+    default:
+      break;
+  }
+
+  if (const char *special = specialNameFor(virtualKey)) {
+    return KeyCombination{std::string(special), modifiers};
+  }
+
+  // The character this key produces on the current layout. MapVirtualKeyW gives
+  // the *unshifted* character and gives letters in upper case, so the case has to
+  // be applied here -- where GDK's keyval already carries it and AppKit's
+  // `characters` already applies it. Third host, third arrangement, same answer.
+  const UINT mapped = MapVirtualKeyW(virtualKey, MAPVK_VK_TO_CHAR);
+  if (mapped == 0) {
+    return std::nullopt;
+  }
+  // The top bit means a dead key -- part-way through composing an accent -- which
+  // is not a combination any more than a bare modifier is.
+  if ((mapped & 0x80000000u) != 0) {
+    return std::nullopt;
+  }
+  wchar_t character = static_cast<wchar_t>(mapped & 0xFFFFu);
+  if (!modifiers.shift) {
+    // Lowercased rather than left as the layout gave it, so an unshifted A is
+    // "a". Only letters change; punctuation is unaffected by towlower.
+    character = static_cast<wchar_t>(towlower(character));
+  }
+
+  const int needed = WideCharToMultiByte(CP_UTF8, 0, &character, 1, nullptr, 0, nullptr, nullptr);
+  if (needed <= 0) {
+    return std::nullopt;
+  }
+  std::string utf8(static_cast<size_t>(needed), '\0');
+  WideCharToMultiByte(CP_UTF8, 0, &character, 1, utf8.data(), needed, nullptr, nullptr);
+  return KeyCombination{utf8, modifiers};
+}
+
+} // namespace basalt

package/native/win32/Win32KeyEvents.h

@@ -0,0 +1,20 @@
+// A Win32 key press as a key combination, in core/KeyEvents.h's vocabulary.
+//
+// The third of three translations, and the one that has to work hardest.
+// `WM_KEYDOWN` carries a virtual key and nothing else: no modifier state, and no
+// character. So the modifiers come from `GetKeyState` and the character from the
+// keyboard layout, where the other two hosts are handed both.
+
+#pragma once
+
+#include "KeyEvents.h"
+
+#include <optional>
+
+namespace basalt {
+
+// Nothing for a press with no key to speak of: a bare modifier, or a dead key.
+// Reads the modifier state itself, because the message does not carry it.
+std::optional<KeyCombination> keyCombinationFrom(unsigned int virtualKey);
+
+} // namespace basalt

package/native/win32/Win32MenuBar.cpp

@@ -0,0 +1,352 @@
+// The Windows half of core/MenuModel.h: a real menu bar, in the window.
+//
+// Windows is the middle case. A menu bar is conventional rather than required,
+// it lives inside the window rather than in a system bar, and -- unlike macOS
+// -- nothing about editing depends on it: an EDIT control implements Ctrl+C,
+// Ctrl+V and Ctrl+Z itself, so the Edit menu is a convenience rather than the
+// thing that makes copying work.
+//
+// Which is why the roles here are posted to the focused control rather than
+// sent down a responder chain. Windows has no responder chain; what it has is
+// `WM_COPY` and friends, which every standard edit control answers and which
+// reach whichever one has focus.
+//
+// The host forwards `WM_COMMAND` here. A menu bar costs client area, so
+// installing one resizes the surface -- which the host already handles, because
+// the same thing happens when a window is resized for any other reason.
+
+#include "Win32MenuBar.h"
+
+#include "MenuModel.h"
+#include "WindowControl.h"
+#include "Win32Strings.h"
+
+#include <windows.h>
+
+#include <iterator>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace basalt {
+
+namespace {
+
+// Command ids. An app's own item carries its own id and a role needs one of
+// these, so they are kept apart by range: an app's ids come from JavaScript and
+// start at 1, and roles start high enough that the two cannot meet.
+constexpr UINT kRoleBase = 0xE000;
+
+struct Role {
+  const char *name;
+  UINT command;
+};
+
+constexpr Role kRoles[] = {
+    {"quit", kRoleBase + 1},
+    {"undo", kRoleBase + 2},
+    {"redo", kRoleBase + 3},
+    {"cut", kRoleBase + 4},
+    {"copy", kRoleBase + 5},
+    {"paste", kRoleBase + 6},
+    {"delete", kRoleBase + 7},
+    {"selectAll", kRoleBase + 8},
+    {"minimize", kRoleBase + 9},
+    {"zoom", kRoleBase + 10},
+    {"close", kRoleBase + 11},
+    {"togglefullscreen", kRoleBase + 12},
+    // "about" has no standard Windows action. An app that wants one shows its
+    // own window, which is an app's own item rather than a role.
+};
+
+UINT commandForRole(const std::string &role) {
+  for (const Role &known : kRoles) {
+    if (role == known.name) {
+      return known.command;
+    }
+  }
+  return 0;
+}
+
+// The platform's own word, plus the shortcut it answers to. Windows draws an
+// accelerator as the text after a tab; nothing here registers one, because the
+// EDIT control already answers these keys.
+std::wstring labelForRole(const std::string &role, const std::string &label) {
+  if (!label.empty()) {
+    return win32::widen(label);
+  }
+  if (role == "quit") {
+    return L"Exit";
+  }
+  if (role == "undo") {
+    return L"Undo\tCtrl+Z";
+  }
+  if (role == "redo") {
+    return L"Redo\tCtrl+Y";
+  }
+  if (role == "cut") {
+    return L"Cut\tCtrl+X";
+  }
+  if (role == "copy") {
+    return L"Copy\tCtrl+C";
+  }
+  if (role == "paste") {
+    return L"Paste\tCtrl+V";
+  }
+  if (role == "delete") {
+    return L"Delete";
+  }
+  if (role == "selectAll") {
+    return L"Select All\tCtrl+A";
+  }
+  if (role == "minimize") {
+    return L"Minimize";
+  }
+  if (role == "zoom") {
+    return L"Maximize";
+  }
+  if (role == "close") {
+    return L"Close";
+  }
+  if (role == "togglefullscreen") {
+    return L"Full Screen";
+  }
+  return {};
+}
+
+std::function<void(int)> &handler() {
+  static std::function<void(int)> value;
+  return value;
+}
+
+HMENU &installed() {
+  static HMENU menu = nullptr;
+  return menu;
+}
+
+void addItems(HMENU menu, const std::vector<MenuItemModel> &items);
+
+void addItem(HMENU menu, const MenuItemModel &item) {
+  if (item.separator) {
+    AppendMenuW(menu, MF_SEPARATOR, 0, nullptr);
+    return;
+  }
+
+  const UINT flags = item.enabled ? MF_ENABLED : MF_GRAYED;
+
+  if (!item.submenu.empty()) {
+    HMENU submenu = CreatePopupMenu();
+    if (submenu == nullptr) {
+      return;
+    }
+    addItems(submenu, item.submenu);
+    AppendMenuW(menu,
+                MF_POPUP | flags,
+                reinterpret_cast<UINT_PTR>(submenu),
+                win32::widen(item.label).c_str());
+    return;
+  }
+
+  if (!item.role.empty()) {
+    const UINT command = commandForRole(item.role);
+    const std::wstring label = labelForRole(item.role, item.label);
+    // An unknown role is dropped: a menu item that does nothing is worse than
+    // one that is not there.
+    if (command != 0 && !label.empty()) {
+      AppendMenuW(menu, MF_STRING | flags, command, label.c_str());
+    }
+    return;
+  }
+
+  if (item.id <= 0) {
+    return;
+  }
+  std::wstring label = win32::widen(item.label);
+  if (!item.accelerator.empty()) {
+    label += L"\t";
+    label += win32::widen(item.accelerator);
+  }
+  AppendMenuW(menu, MF_STRING | flags, static_cast<UINT_PTR>(item.id), label.c_str());
+}
+
+void addItems(HMENU menu, const std::vector<MenuItemModel> &items) {
+  for (const MenuItemModel &item : items) {
+    addItem(menu, item);
+  }
+}
+
+} // namespace
+
+bool applicationMenuSupported() {
+  return true;
+}
+
+namespace {
+
+void describeInto(std::string &out, HMENU menu, int depth) {
+  const int count = GetMenuItemCount(menu);
+  for (int i = 0; i < count; i++) {
+    wchar_t text[512] = {0};
+    MENUITEMINFOW info{};
+    info.cbSize = sizeof(info);
+    info.fMask = MIIM_STRING | MIIM_SUBMENU | MIIM_STATE | MIIM_FTYPE;
+    info.dwTypeData = text;
+    info.cch = static_cast<UINT>(std::size(text) - 1);
+    if (!GetMenuItemInfoW(menu, static_cast<UINT>(i), TRUE, &info)) {
+      continue;
+    }
+
+    out.append(static_cast<size_t>(depth) * 2, ' ');
+    if ((info.fType & MFT_SEPARATOR) != 0) {
+      out += "-\n";
+      continue;
+    }
+    // The accelerator is the text after a tab, which is how Windows stores one;
+    // it reads the same way the macOS dump's bracket does.
+    std::wstring label(text);
+    const size_t tab = label.find(L'\t');
+    if (tab != std::wstring::npos) {
+      out += win32::narrow(label.substr(0, tab));
+      out += " [";
+      out += win32::narrow(label.substr(tab + 1));
+      out += "]";
+    } else {
+      out += win32::narrow(label);
+    }
+    if ((info.fState & MFS_DISABLED) != 0) {
+      out += " (disabled)";
+    }
+    out += "\n";
+    if (info.hSubMenu != nullptr) {
+      describeInto(out, info.hSubMenu, depth + 1);
+    }
+  }
+}
+
+} // namespace
+
+std::string describeApplicationMenu() {
+  std::string out;
+  if (installed() != nullptr) {
+    describeInto(out, installed(), 0);
+  }
+  return out;
+}
+
+void setApplicationMenu(const MenuModel &menu, std::function<void(int)> onChosen) {
+  HWND window = GetActiveWindow();
+  if (window == nullptr) {
+    window = GetForegroundWindow();
+  }
+  if (window == nullptr) {
+    return;
+  }
+
+  handler() = std::move(onChosen);
+
+  // An empty menu takes the bar away, which is what Windows' own default is:
+  // unlike macOS there is nothing an application needs a menu bar to do.
+  if (menu.empty()) {
+    SetMenu(window, nullptr);
+    if (installed() != nullptr) {
+      DestroyMenu(installed());
+      installed() = nullptr;
+    }
+    DrawMenuBar(window);
+    return;
+  }
+
+  HMENU bar = CreateMenu();
+  if (bar == nullptr) {
+    return;
+  }
+  for (const MenuItemModel &top : menu) {
+    // A bare command in a menu bar is not a thing any desktop has.
+    if (top.submenu.empty()) {
+      continue;
+    }
+    HMENU submenu = CreatePopupMenu();
+    if (submenu == nullptr) {
+      continue;
+    }
+    addItems(submenu, top.submenu);
+    AppendMenuW(bar,
+                MF_POPUP,
+                reinterpret_cast<UINT_PTR>(submenu),
+                win32::widen(top.label).c_str());
+  }
+
+  SetMenu(window, bar);
+  // Destroyed after the new one is in: a menu still attached to a window
+  // cannot be freed, and freeing the old one first would leave the window
+  // pointing at nothing for the length of a call.
+  if (installed() != nullptr) {
+    DestroyMenu(installed());
+  }
+  installed() = bar;
+  DrawMenuBar(window);
+}
+
+namespace win32 {
+
+bool handleMenuCommand(unsigned int command) {
+  if (command < kRoleBase) {
+    // An app's own item. Zero is "not from a menu", which WM_COMMAND also uses
+    // for accelerators and controls.
+    if (command == 0 || !handler()) {
+      return false;
+    }
+    handler()(static_cast<int>(command));
+    return true;
+  }
+
+  HWND window = GetActiveWindow();
+  HWND focused = GetFocus();
+  switch (command) {
+    case kRoleBase + 1:
+      PostMessageW(window, WM_CLOSE, 0, 0);
+      return true;
+    // Posted to whatever has focus, which for these is a real EDIT control and
+    // answers every one of them itself. Windows has no responder chain; this is
+    // the equivalent.
+    case kRoleBase + 2:
+      SendMessageW(focused, WM_UNDO, 0, 0);
+      return true;
+    case kRoleBase + 3:
+      // EDIT has no redo. Reported as handled anyway: the alternative is the
+      // key travelling on to something that will do something else with it.
+      return true;
+    case kRoleBase + 4:
+      SendMessageW(focused, WM_CUT, 0, 0);
+      return true;
+    case kRoleBase + 5:
+      SendMessageW(focused, WM_COPY, 0, 0);
+      return true;
+    case kRoleBase + 6:
+      SendMessageW(focused, WM_PASTE, 0, 0);
+      return true;
+    case kRoleBase + 7:
+      SendMessageW(focused, WM_CLEAR, 0, 0);
+      return true;
+    case kRoleBase + 8:
+      SendMessageW(focused, EM_SETSEL, 0, -1);
+      return true;
+    case kRoleBase + 9:
+      ShowWindow(window, SW_MINIMIZE);
+      return true;
+    case kRoleBase + 10:
+      ShowWindow(window, IsZoomed(window) ? SW_RESTORE : SW_MAXIMIZE);
+      return true;
+    case kRoleBase + 11:
+      PostMessageW(window, WM_CLOSE, 0, 0);
+      return true;
+    case kRoleBase + 12:
+      setWindowFullScreen(!windowBounds().fullScreen);
+      return true;
+    default:
+      return false;
+  }
+}
+
+} // namespace win32
+} // namespace basalt

package/native/win32/Win32MenuBar.h

@@ -0,0 +1,16 @@
+// The host's half of the Windows menu bar: forwarding WM_COMMAND.
+//
+// A menu bar's items arrive as WM_COMMAND on the window that owns it, and the
+// window procedure is the host's. This is the one line it has to pass on. See
+// Win32MenuBar.cpp for what happens to it.
+
+#pragma once
+
+namespace basalt::win32 {
+
+// Handles a WM_COMMAND from the application menu. Returns false when the
+// command was not one of its own, so the host can go on treating it as whatever
+// else a WM_COMMAND is -- a control's notification, in this host's case.
+bool handleMenuCommand(unsigned int command);
+
+} // namespace basalt::win32