okooooooo/msime-windows
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
fb4a2d02c9a034deaa52401c85e6c626e8e75a39
msime-windows/server/src/webview2/windows_webview2.cpp
T
fanlusky fb4a2d02c9 fix(candwnd): keep measure-time WebView bounds after host resize 
Avoid shrinking the candidate WebView to the host client on first show
near a screen edge, which made the card wrap and get clipped.
2026-07-31 02:58:40 +08:00

2984 lines
116 KiB
C++
Raw Blame History

#include "windows_webview2.h"
#include "config/ime_config.h"
#include "defines/globals.h"
#include "utils/common_utils.h"
#include "utils/ime_utils.h"
#include <debugapi.h>
#include <boost/json.hpp>
#include <nlohmann/json.hpp>
#include <string>
#include <windows.h>
#include <dwmapi.h>
#include <winuser.h>
#include "defines/defines.h"
#include "global/globals.h"
#include "fmt/xchar.h"
#include "ipc/ipc.h"
#include "ipc/event_listener.h"
#include "ipc/candidate_ui_action_policy.h"
#include "settings/settings_launcher.h"
#include "voice-input/voice_input_service.h"
#include <WebView2EnvironmentOptions.h>
#include <algorithm>
#pragma comment(lib, "dcomp.lib")
namespace json = boost::json;
int FineTuneWindow(HWND hwnd);
void ApplyConfiguredFloatingToolbarVisibility();
void ApplyConfiguredFloatingToolbarSize();
void ApplyConfiguredInputScheme();
void ApplyConfiguredShuangpinSchema();
bool EnsureSmallWindowsTopmost(const wchar_t *reason);
void UpdateSmallWindowWebviewVisibility(HWND hwnd, bool visible);
std::wstring GetAppdataPath();
HRESULT OnEnvironmentCreated(HWND hwnd, HRESULT result, ICoreWebView2Environment *env);
HRESULT OnMenuWindowEnvironmentCreated(HWND hwnd, HRESULT result, ICoreWebView2Environment *env);
HRESULT OnFtbWindowEnvironmentCreated(HWND hwnd, HRESULT result, ICoreWebView2Environment *env);
constexpr int candidateBoundRightExtra = 1000;
constexpr int candidateBoundBottomExtra = 1000;
std::wstring bodyRes = L"";
namespace
{
ComPtr<ICoreWebView2Environment> smallWindowWebviewEnvironment;
HWND smallWindowCandHwnd = nullptr;
HWND smallWindowMenuHwnd = nullptr;
HWND smallWindowFtbHwnd = nullptr;
enum class SmallWindowInitState
{
Idle,
InProgress,
Ready,
Failed
};
SmallWindowInitState smallWindowInitState = SmallWindowInitState::Idle;
int smallWindowInitAttempts = 0;
bool pendingTrayMenuShow = false;
// WebView2 rejects a CreateCoreWebView2Controller request with E_INVALIDARG when
// another controller creation on the same environment is still in flight. The
// three small windows must therefore be brought up strictly one at a time.
bool smallWindowControllerRequestInFlight = false;
ULONGLONG smallWindowControllerRequestStartTick = 0;
constexpr ULONGLONG kSmallWindowControllerRequestTimeoutMs = 15000;
constexpr int kMaxSmallWindowInitAttempts = 12;
constexpr UINT_PTR kRetrySmallWindowWebviewTimerId = 9001;
bool candidateNavigationReady = false;
bool menuNavigationReady = false;
bool floatingToolbarNavigationReady = false;
bool smallWindowTopmostRequested = false;
bool smallWindowTopmostApplied = false;
void WebviewDebugLog(const std::wstring &message)
{
(void)0;
}
void ScheduleSmallWindowWebviewRetry(DWORD delay_ms);
void BeginSmallWindowWebviewEnvironmentCreate();
void RequestNextSmallWindowController();
void OnSmallWindowWebviewInitFailed(HRESULT hr);
void MaybeFlushPendingTrayMenuShow();
void ResetSmallWindowTopmostGate();
void CALLBACK SmallWindowWebviewRetryTimerProc(HWND hwnd, UINT /*msg*/, UINT_PTR id, DWORD /*time*/)
{
KillTimer(hwnd, id);
// An existing environment must never be rebuilt: that would replace the
// candidate / floating-toolbar controllers that are already working and make
// the toolbar disappear. Only fill in the controllers that are missing.
if (smallWindowWebviewEnvironment)
{
RequestNextSmallWindowController();
return;
}
BeginSmallWindowWebviewEnvironmentCreate();
}
void ScheduleSmallWindowWebviewRetry(DWORD delay_ms)
{
HWND timer_hwnd = smallWindowCandHwnd ? smallWindowCandHwnd : ::global_hwnd;
if (!timer_hwnd)
{
return;
}
KillTimer(timer_hwnd, kRetrySmallWindowWebviewTimerId);
SetTimer(timer_hwnd, kRetrySmallWindowWebviewTimerId, delay_ms, SmallWindowWebviewRetryTimerProc);
}
void ScheduleSmallWindowRetryWithBackoff()
{
if (smallWindowInitAttempts >= kMaxSmallWindowInitAttempts)
{
return;
}
// 1s, 2s, 4s, 8s capped at 10s: covers user-data-folder locks left by
// orphaned WebView2 processes and slow bring-up right after logon.
const DWORD delay_ms =
(std::min)(DWORD{1000} << (std::min)((std::max)(smallWindowInitAttempts - 1, 0), 3), DWORD{10000});
ScheduleSmallWindowWebviewRetry(delay_ms);
}
void OnSmallWindowWebviewInitFailed(HRESULT hr)
{
smallWindowInitState = SmallWindowInitState::Failed;
smallWindowWebviewEnvironment.Reset();
ScheduleSmallWindowRetryWithBackoff();
}
void MaybeFlushPendingTrayMenuShow()
{
if (!pendingTrayMenuShow || !webviewControllerMenuWnd || !menuNavigationReady || !::global_hwnd_menu)
{
return;
}
pendingTrayMenuShow = false;
// Global::Point / Keycode / ModifiersDown still hold the langbar rect from
// the right-click that arrived while the menu WebView was not ready.
PostMessage(::global_hwnd_menu, WM_LANGBAR_RIGHTCLICK, 0, 0);
}
int currentSmallWindowHostIndex = -1;
int lastFailedSmallWindowHostIndex = -1;
// Request a controller for exactly one host at a time, and only for hosts that
// do not have one yet, so neither concurrency nor a retry can disturb siblings
// that already came up. The scan starts after the host that failed last so a
// persistently failing host cannot starve its siblings.
void RequestNextSmallWindowController()
{
ICoreWebView2Environment *env = smallWindowWebviewEnvironment.Get();
if (!env)
{
return;
}
if (smallWindowControllerRequestInFlight)
{
// A completion handler that never runs would otherwise wedge the queue.
if (GetTickCount64() - smallWindowControllerRequestStartTick < kSmallWindowControllerRequestTimeoutMs)
{
return;
}
smallWindowControllerRequestInFlight = false;
}
struct Host
{
const wchar_t *name;
HWND hwnd;
bool hasController;
HRESULT (*request)(HWND, HRESULT, ICoreWebView2Environment *);
};
const Host hosts[] = {
{L"cand", smallWindowCandHwnd, webviewControllerCandWnd != nullptr, &OnEnvironmentCreated},
{L"menu", smallWindowMenuHwnd, webviewControllerMenuWnd != nullptr, &OnMenuWindowEnvironmentCreated},
{L"ftb", smallWindowFtbHwnd, webviewControllerFtbWnd != nullptr, &OnFtbWindowEnvironmentCreated},
};
int chosen = -1;
for (int step = 1; step <= 3; ++step)
{
const int i = (lastFailedSmallWindowHostIndex + step) % 3;
if (!hosts[i].hasController && hosts[i].hwnd)
{
chosen = i;
break;
}
}
if (chosen < 0)
{
MaybeFlushPendingTrayMenuShow();
return;
}
const Host &host = hosts[chosen];
// In a uiAccess=true process a TOPMOST parent makes WebView2's internal
// cross-process SetParent fail with E_INVALIDARG (WebView2Feedback #486),
// and the failure persists as long as WS_EX_TOPMOST stays on the window.
// Demote before creating; the lazy-topmost gate re-pins once all three
// WebViews are ready.
if (GetWindowLongPtrW(host.hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST)
{
SetWindowPos(host.hwnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
}
smallWindowControllerRequestInFlight = true;
smallWindowControllerRequestStartTick = GetTickCount64();
currentSmallWindowHostIndex = chosen;
const HRESULT hr = host.request(host.hwnd, S_OK, env);
if (FAILED(hr))
{
smallWindowControllerRequestInFlight = false;
lastFailedSmallWindowHostIndex = chosen;
++smallWindowInitAttempts;
ScheduleSmallWindowRetryWithBackoff();
}
}
// Called from every controller-created handler so the next host is only started
// once the previous creation has fully settled.
void OnSmallWindowControllerSettled(HRESULT hr)
{
smallWindowControllerRequestInFlight = false;
if (FAILED(hr))
{
lastFailedSmallWindowHostIndex = currentSmallWindowHostIndex;
++smallWindowInitAttempts;
ScheduleSmallWindowRetryWithBackoff();
return;
}
// Forward progress: give the remaining hosts a full attempt budget.
smallWindowInitAttempts = 0;
ScheduleSmallWindowWebviewRetry(1);
}
void BeginSmallWindowWebviewEnvironmentCreate()
{
if (!smallWindowCandHwnd || !smallWindowMenuHwnd || !smallWindowFtbHwnd)
{
return;
}
if (smallWindowInitState == SmallWindowInitState::InProgress)
{
return;
}
if (smallWindowWebviewEnvironment)
{
RequestNextSmallWindowController();
return;
}
smallWindowInitState = SmallWindowInitState::InProgress;
++smallWindowInitAttempts;
ResetSmallWindowTopmostGate();
auto options = Microsoft::WRL::Make<CoreWebView2EnvironmentOptions>();
options->put_AdditionalBrowserArguments( //
L"--disable-features=TranslateUI "
L"--disable-background-networking "
L"--disable-default-apps "
L"--disable-sync "
L"--disable-prompt-on-repost "
L"--no-first-run");
const std::wstring appDataPath = GetAppdataPath();
if (appDataPath.empty() || appDataPath[0] == L'\\')
{
OnSmallWindowWebviewInitFailed(E_INVALIDARG);
return;
}
const HRESULT createHr = CreateCoreWebView2EnvironmentWithOptions(
nullptr, appDataPath.c_str(), options.Get(),
Callback<ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler>(
[](HRESULT result, ICoreWebView2Environment *env) -> HRESULT {
if (FAILED(result) || !env)
{
OnSmallWindowWebviewInitFailed(FAILED(result) ? result : E_FAIL);
return FAILED(result) ? result : E_FAIL;
}
smallWindowWebviewEnvironment = env;
smallWindowInitState = SmallWindowInitState::Ready;
smallWindowInitAttempts = 0;
RequestNextSmallWindowController();
return S_OK;
})
.Get());
if (FAILED(createHr))
{
OnSmallWindowWebviewInitFailed(createHr);
}
}
struct FloatingToolbarState
{
// Keep these defaults aligned with the TSF compartment defaults:
// Chinese input, half-width characters, and Chinese punctuation.
int cn_en = 1;
int double_single_byte = 0;
int punctuation = 1;
};
FloatingToolbarState floatingToolbarState;
bool AreSmallWindowWebviewsReadyUnlocked()
{
return candidateNavigationReady && menuNavigationReady && floatingToolbarNavigationReady &&
webviewCandWnd != nullptr && webviewMenuWnd != nullptr && webviewFtbWnd != nullptr &&
webviewControllerCandWnd != nullptr && webviewControllerMenuWnd != nullptr &&
webviewControllerFtbWnd != nullptr;
}
void ResetSmallWindowTopmostGate()
{
candidateNavigationReady = false;
menuNavigationReady = false;
floatingToolbarNavigationReady = false;
smallWindowTopmostRequested = false;
smallWindowTopmostApplied = false;
(void)0;
}
void LogSmallWindowReadyGateUnlocked(const wchar_t *context)
{
(void)0;
}
void ApplyLazyTopmostUnlocked(const wchar_t *reason)
{
constexpr UINT flag = SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE;
auto pinOne = [flag](HWND hwnd, const wchar_t *name) {
if (!hwnd)
{
(void)0;
return;
}
SetLastError(0);
const BOOL ok = SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, flag);
RECT rect{};
GetWindowRect(hwnd, &rect);
(void)0;
};
smallWindowTopmostApplied = true;
// Later HWND_TOPMOST wins within the topmost band. When the tray menu is
// already showing, pin it last so FTB cannot cover it; otherwise keep FTB
// last so the idle toolbar stays discoverable above other small windows.
const bool menu_visible =
::global_hwnd_menu != nullptr && IsWindowVisible(::global_hwnd_menu) != FALSE;
(void)0;
pinOne(::global_hwnd, L"candidate");
if (menu_visible)
{
pinOne(::global_hwnd_ftb, L"floating-toolbar");
pinOne(::global_hwnd_menu, L"menu");
}
else
{
pinOne(::global_hwnd_menu, L"menu");
pinOne(::global_hwnd_ftb, L"floating-toolbar");
}
LogSmallWindowReadyGateUnlocked(L"after-topmost-applied");
}
void TryApplyPendingLazyTopmost(const wchar_t *reason)
{
if (!smallWindowTopmostRequested || smallWindowTopmostApplied)
{
return;
}
if (!AreSmallWindowWebviewsReadyUnlocked())
{
LogSmallWindowReadyGateUnlocked(L"topmost-still-waiting-webviews");
return;
}
ApplyLazyTopmostUnlocked(reason);
if (::is_global_wnd_cand_shown && ::global_hwnd)
{
(void)0;
FineTuneWindow(::global_hwnd);
}
if (::global_hwnd_menu && IsWindowVisible(::global_hwnd_menu))
{
UpdateSmallWindowWebviewVisibility(::global_hwnd_menu, true);
if (webviewControllerMenuWnd)
{
RECT bounds{};
GetClientRect(::global_hwnd_menu, &bounds);
webviewControllerMenuWnd->put_Bounds(bounds);
webviewControllerMenuWnd->NotifyParentWindowPositionChanged();
}
(void)0;
}
if (::global_hwnd_ftb && IsWindowVisible(::global_hwnd_ftb))
{
UpdateSmallWindowWebviewVisibility(::global_hwnd_ftb, true);
(void)0;
}
}
void NotifySmallWindowNavigationReady(bool &readyFlag, const wchar_t *which)
{
if (readyFlag)
{
(void)0;
return;
}
readyFlag = true;
(void)0;
LogSmallWindowReadyGateUnlocked(L"after-nav-ready");
TryApplyPendingLazyTopmost(L"pending-after-nav-ready");
MaybeFlushPendingTrayMenuShow();
}
bool UpdateBinaryState(int value, int &state)
{
// The existing UI contract only defines 0 and 1. Ignore malformed values
// instead of replacing a known-good cached state.
if ((value == 0 || value == 1) && value != state)
{
state = value;
return true;
}
return false;
}
void RenderFloatingToolbarState(ICoreWebView2 *webview)
{
if (!floatingToolbarNavigationReady || webview == nullptr)
{
return;
}
std::wstring script;
script.reserve(768);
if (floatingToolbarState.cn_en == 1)
{
script.append(L"document.getElementById('cn').style.display = 'flex';");
script.append(L"document.getElementById('en').style.display = 'none';");
}
else
{
script.append(L"document.getElementById('cn').style.display = 'none';");
script.append(L"document.getElementById('en').style.display = 'flex';");
}
if (floatingToolbarState.double_single_byte == 1)
{
script.append(L"document.getElementById('fullwidth').style.display = 'flex';");
script.append(L"document.getElementById('halfwidth').style.display = 'none';");
}
else
{
script.append(L"document.getElementById('fullwidth').style.display = 'none';");
script.append(L"document.getElementById('halfwidth').style.display = 'flex';");
}
if (floatingToolbarState.punctuation == 1)
{
script.append(L"document.getElementById('puncCn').style.display = 'flex';");
script.append(L"document.getElementById('puncEn').style.display = 'none';");
}
else
{
script.append(L"document.getElementById('puncCn').style.display = 'none';");
script.append(L"document.getElementById('puncEn').style.display = 'flex';");
}
if (GetConfiguredCharacterSet() == "traditional")
{
script.append(L"document.getElementById('character-set-simplified').style.display = 'none';");
script.append(L"document.getElementById('character-set-traditional').style.display = 'flex';");
}
else
{
script.append(L"document.getElementById('character-set-simplified').style.display = 'flex';");
script.append(L"document.getElementById('character-set-traditional').style.display = 'none';");
}
const FloatingToolbarItemsConfig &items = GetConfiguredFloatingToolbarItems();
script.append(L"window.setToolbarItem=(id,shown)=>{const item=document.getElementById(id);"
L"if(item)item.style.display=shown?'flex':'none';};");
script.append(items.fullwidth
? L"window.setToolbarItem('char-width-mode',true);"
: L"window.setToolbarItem('char-width-mode',false);");
script.append(items.punctuation
? L"window.setToolbarItem('punctuation-mode',true);"
: L"window.setToolbarItem('punctuation-mode',false);");
script.append(items.character_set
? L"window.setToolbarItem('character-set',true);"
: L"window.setToolbarItem('character-set',false);");
script.append(items.emoji
? L"window.setToolbarItem('emoji-panel',true);"
: L"window.setToolbarItem('emoji-panel',false);");
script.append(items.screen_keyboard
? L"window.setToolbarItem('screen-keyboard',true);"
: L"window.setToolbarItem('screen-keyboard',false);");
script.append(items.settings
? L"window.setToolbarItem('settings',true);"
: L"window.setToolbarItem('settings',false);");
webview->ExecuteScript(script.c_str(), nullptr);
}
void SetWebviewMemoryUsageTarget(ComPtr<ICoreWebView2> webview, COREWEBVIEW2_MEMORY_USAGE_TARGET_LEVEL level)
{
if (!webview) return;
ComPtr<ICoreWebView2_23> webview23;
if (SUCCEEDED(webview.As(&webview23)))
{
webview23->put_MemoryUsageTargetLevel(level);
}
}
}
bool EnsureSmallWindowsTopmost(const wchar_t *reason)
{
smallWindowTopmostRequested = true;
if (smallWindowTopmostApplied)
{
return true;
}
if (!AreSmallWindowWebviewsReadyUnlocked())
{
(void)0;
LogSmallWindowReadyGateUnlocked(L"topmost-deferred");
return false;
}
ApplyLazyTopmostUnlocked(reason);
return true;
}
void RaiseTrayMenuAboveSmallWindows(const wchar_t *reason)
{
if (!::global_hwnd_menu)
{
return;
}
// During startup the menu host is shown DWM-cloaked for WebView2 warmup, so
// IsWindowVisible() based callers can reach this before the menu controller
// exists. Making the host TOPMOST at that point is fatal in a uiAccess=true
// process: UIPI then blocks WebView2's cross-process SetParent and every
// CreateCoreWebView2Controller for this window fails with E_INVALIDARG
// (WebView2Feedback #486). Nothing needs raising before content exists.
if (!webviewControllerMenuWnd)
{
return;
}
// Re-assert TOPMOST after FTB (or a peer) was pinned last. A second
// HWND_TOPMOST is what actually lifts the menu within the topmost band;
// HWND_TOP alone is unreliable here with WS_EX_NOACTIVATE layered hosts.
constexpr UINT flag = SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE;
SetLastError(0);
const BOOL ok = SetWindowPos(::global_hwnd_menu, HWND_TOPMOST, 0, 0, 0, 0, flag);
(void)0;
}
bool AreSmallWindowsTopmostApplied()
{
return smallWindowTopmostApplied;
}
bool AreSmallWindowWebviewsReady()
{
return AreSmallWindowWebviewsReadyUnlocked();
}
void LogSmallWindowReadyGate(const wchar_t *context)
{
LogSmallWindowReadyGateUnlocked(context);
}
void UpdateSmallWindowWebviewVisibility(HWND hwnd, bool visible)
{
ComPtr<ICoreWebView2Controller> controller;
ComPtr<ICoreWebView2> webview;
bool lowerMemoryWhenHidden = false;
if (hwnd == ::global_hwnd)
{
controller = webviewControllerCandWnd;
webview = webviewCandWnd;
}
else if (hwnd == ::global_hwnd_menu)
{
controller = webviewControllerMenuWnd;
webview = webviewMenuWnd;
// The language-bar menu is reopened interactively and must paint on
// the first frame. Returning its renderer from LOW is asynchronous
// and can leave the host window visible with transparent content.
lowerMemoryWhenHidden = false;
}
else if (hwnd == ::global_hwnd_ftb)
{
controller = webviewControllerFtbWnd;
webview = webviewFtbWnd;
// Keep the small, persistent toolbar warm when configuration or
// fullscreen policy temporarily hides it. Switching its WebView back
// from LOW can otherwise produce a visible white repaint.
lowerMemoryWhenHidden = false;
}
else
{
(void)0;
return;
}
if (controller)
{
const HRESULT hr = controller->put_IsVisible(visible ? TRUE : FALSE);
(void)0;
}
else
{
(void)0;
}
if (lowerMemoryWhenHidden)
{
SetWebviewMemoryUsageTarget(
webview,
visible ? COREWEBVIEW2_MEMORY_USAGE_TARGET_LEVEL_NORMAL : COREWEBVIEW2_MEMORY_USAGE_TARGET_LEVEL_LOW);
}
}
std::wstring ReadHtmlFile(const std::wstring &filePath)
{
std::wifstream file(filePath);
if (!file)
{
(void)0;
return L"";
}
// Use Boost Locale to handle UTF-8
file.imbue(boost::locale::generator().generate("en_US.UTF-8"));
std::wstringstream buffer;
buffer << file.rdbuf();
std::wstring content = buffer.str();
(void)0;
return content;
}
std::wstring GetAppdataPath()
{
return string_to_wstring(CommonUtils::get_local_appdata_path()) + //
LR"(\)" + //
GlobalIme::AppName + //
LR"(\)" + //
LR"(webview2)";
}
// An unreadable themed asset must never turn into an empty NavigateToString:
// that renders a blank, title-less page which looks like a dead WebView.
std::wstring ReadHtmlFileWithFallback(const std::wstring &primaryPath, const std::wstring &fallbackPath)
{
std::wstring content = ReadHtmlFile(primaryPath);
if (content.empty() && primaryPath != fallbackPath)
{
content = ReadHtmlFile(fallbackPath);
}
return content;
}
void UpdateHtmlContentWithJavaScript(ComPtr<ICoreWebView2> webview, const std::wstring &newContent)
{
UpdateHtmlContentWithJavaScript(webview, newContent, nullptr);
}
void UpdateHtmlContentWithJavaScript(ComPtr<ICoreWebView2> webview, const std::wstring &newContent,
std::function<void()> onComplete)
{
if (!webview)
{
if (onComplete)
{
onComplete();
}
return;
}
std::wstring script;
script.reserve(newContent.length() + 512);
script.append(L"document.getElementById('realContainer').innerHTML = `");
script.append(newContent);
script.append(L"`;\n");
script.append(L"window.ClearState();\n");
script.append(L"var el = document.getElementById('realContainerParent');\n");
script.append(L"if (el) {\n");
script.append(L" el.style.marginTop = \"");
script.append(std::to_wstring(Global::MarginTop));
script.append(L"px\";\n");
script.append(L" el.style.marginLeft = \"");
script.append(std::to_wstring(Global::MarginLeft));
script.append(L"px\";\n");
script.append(L"}\n");
script.append(L"if (window.SetCandidateSelection) { window.SetCandidateSelection(");
script.append(std::to_wstring(Global::candidate_ui.selected_index_in_page));
script.append(L"); }\n");
script.append(L"if (window.SetCandidatePreeditVisible) { window.SetCandidatePreeditVisible(");
script.append(GetConfiguredCandidateWindowPreeditStyle() == "empty" ? L"false" : L"true");
script.append(L"); }\n");
script.append(L"if (window.SetPreeditCaret) { window.SetPreeditCaret(); }\n");
if (!onComplete)
{
webview->ExecuteScript(script.c_str(), nullptr);
return;
}
webview->ExecuteScript(
script.c_str(),
Callback<ICoreWebView2ExecuteScriptCompletedHandler>(
[onComplete](HRESULT, LPCWSTR) -> HRESULT {
onComplete();
return S_OK;
})
.Get());
}
void PrepareCandidateWebViewBoundsForMeasure(HWND hwnd)
{
if (!webviewControllerCandWnd || !hwnd)
{
return;
}
RECT bounds{};
GetClientRect(hwnd, &bounds);
bounds.right += candidateBoundRightExtra;
bounds.bottom += candidateBoundBottomExtra;
webviewControllerCandWnd->put_Bounds(bounds);
}
void SyncCandidateWebViewBoundsToHost(HWND hwnd)
{
if (!webviewControllerCandWnd || !hwnd)
{
return;
}
// Keep the measure-time reserve instead of shrinking the viewport to the
// host client. MarginLeft pushes the card towards the right of the viewport
// near a screen edge, so an exactly-sized viewport leaves the card less
// room than it was measured with and it wraps into a taller card that the
// window region then clips.
PrepareCandidateWebViewBoundsForMeasure(hwnd);
webviewControllerCandWnd->NotifyParentWindowPositionChanged();
}
int PrepareHtmlForWnds()
{
// e.g. C:\\Users\\SonnyCalcr\\AppData\\Local\\metasequoiaime
std::wstring assetPath = fmt::format( //
L"{}\\{}", //
string_to_wstring(CommonUtils::get_local_appdata_path()), GlobalIme::AppName);
//
// 候选窗口
//
const bool isHorizontal = GetConfiguredCandidateWindowLayout() == "horizontal";
const bool candLight = ResolveConfiguredTheme(GetConfiguredThemeCand()) == "light";
const wchar_t *candThemeSuffix = candLight ? L"light" : L"dark";
std::wstring htmlCandWnd;
std::wstring bodyHtmlCandWnd;
std::wstring measureHtmlCandWnd;
if (isHorizontal)
{
htmlCandWnd = fmt::format(L"/html/webview2/candwnd/horizontal_candidate_window_{}.html", candThemeSuffix);
// Body/measure fragments are theme-agnostic markup; keep the existing dark assets.
bodyHtmlCandWnd = L"/html/webview2/candwnd/body/horizontal_candidate_window_dark.html";
measureHtmlCandWnd = L"/html/webview2/candwnd/body/horizontal_candidate_window_dark_measure.html";
}
else
{
htmlCandWnd = fmt::format(L"/html/webview2/candwnd/vertical_candidate_window_{}.html", candThemeSuffix);
bodyHtmlCandWnd = L"/html/webview2/candwnd/body/vertical_candidate_window_dark.html";
measureHtmlCandWnd = L"/html/webview2/candwnd/body/vertical_candidate_window_dark_measure.html";
}
std::wstring entireHtmlPathCandWnd = assetPath + htmlCandWnd;
::HTMLStringCandWnd = ReadHtmlFileWithFallback(
entireHtmlPathCandWnd,
assetPath + (isHorizontal ? L"/html/webview2/candwnd/horizontal_candidate_window_dark.html"
: L"/html/webview2/candwnd/vertical_candidate_window_dark.html"));
std::wstring bodyHtmlPathCandWnd = assetPath + bodyHtmlCandWnd;
::BodyStringCandWnd = ReadHtmlFile(bodyHtmlPathCandWnd);
std::wstring measureHtmlPathCandWnd = assetPath + measureHtmlCandWnd;
::MeasureStringCandWnd = ReadHtmlFile(measureHtmlPathCandWnd);
(void)0;
//
// 托盘语言区菜单窗口
//
const bool menuLight = ResolveConfiguredTheme(GetConfiguredThemeMenu()) == "light";
std::wstring htmlMenuWnd =
menuLight ? L"/html/webview2/menu/default_light.html" : L"/html/webview2/menu/default.html";
std::wstring entireHtmlPathMenuWnd = assetPath + htmlMenuWnd;
::HTMLStringMenuWnd =
ReadHtmlFileWithFallback(entireHtmlPathMenuWnd, assetPath + L"/html/webview2/menu/default.html");
//
// settings 窗口
// 这里暂时没有用到，因为 settings 窗口使用的是映射 url 导航
//
/*
std::wstring htmlSettingsWnd = L"/html/webview2/settings/default.html";
std::wstring entireHtmlPathSettingsWnd = assetPath + htmlSettingsWnd;
::HTMLStringSettingsWnd = ReadHtmlFile(entireHtmlPathSettingsWnd);
*/
//
// floating toolbar 窗口
//
const bool ftbLight = ResolveConfiguredTheme(GetConfiguredThemeFtb()) == "light";
std::wstring htmlFtbWnd =
ftbLight ? L"/html/webview2/ftb/default_light.html" : L"/html/webview2/ftb/default.html";
std::wstring entireHtmlPathFtbWnd = assetPath + htmlFtbWnd;
::HTMLStringFtbWnd =
ReadHtmlFileWithFallback(entireHtmlPathFtbWnd, assetPath + L"/html/webview2/ftb/default.html");
return 0;
}
bool ApplyConfiguredCandidateWindowLayout()
{
// PrepareHtmlForWnds also refreshes the other small-window templates. They are
// cheap local reads and keeping this in one place prevents the paths drifting.
PrepareHtmlForWnds();
if (!webviewCandWnd || HTMLStringCandWnd.empty())
{
return false;
}
return SUCCEEDED(webviewCandWnd->NavigateToString(HTMLStringCandWnd.c_str()));
}
bool ApplyConfiguredUiThemes()
{
PrepareHtmlForWnds();
bool ok = true;
if (webviewCandWnd && !HTMLStringCandWnd.empty())
{
ok = SUCCEEDED(webviewCandWnd->NavigateToString(HTMLStringCandWnd.c_str())) && ok;
}
if (webviewFtbWnd && !HTMLStringFtbWnd.empty())
{
floatingToolbarNavigationReady = false;
ok = SUCCEEDED(webviewFtbWnd->NavigateToString(HTMLStringFtbWnd.c_str())) && ok;
}
if (webviewMenuWnd && !HTMLStringMenuWnd.empty())
{
ok = SUCCEEDED(webviewMenuWnd->NavigateToString(HTMLStringMenuWnd.c_str())) && ok;
}
return ok;
}
bool ApplyConfiguredCandidateAppearance()
{
if (!webviewCandWnd)
{
return false;
}
nlohmann::json cfg = {{"font", GetConfiguredCandidateFont()},
{"english_font", GetConfiguredCandidateEnglishFont()},
{"default_font", GetConfiguredCandidateDefaultFont()},
{"font_size", GetConfiguredCandidateFontSize()},
{"cand_text_color", GetConfiguredCandidateTextColor()}};
const std::wstring script =
L"(function(c){"
L"const root=document.documentElement;"
L"const quote=function(f){return /\\s/.test(f)?'\"'+String(f).replace(/\"/g,'\\\\\"')+'\"':String(f);};"
L"const family=[c.english_font,c.font,c.default_font,'sans-serif'].filter(Boolean).map(quote).join(', ');"
L"root.style.setProperty('--cand-font-family', family);"
L"root.style.setProperty('--cand-font-size', String(c.font_size||16)+'px');"
L"const color=(c.cand_text_color||'auto');"
L"if(color&&color!=='auto'){"
L"root.style.setProperty('--cand-text', color);"
L"root.style.setProperty('--cand-num', color.length===7?color+'9d':color);"
L"}else{"
L"root.style.removeProperty('--cand-text');"
L"root.style.removeProperty('--cand-num');"
L"}"
L"})(" +
string_to_wstring(cfg.dump()) + L");";
return SUCCEEDED(webviewCandWnd->ExecuteScript(script.c_str(), nullptr));
}
//
//
// 候选窗口 webview
//
//
void UpdateMeasureContentWithJavaScript(ComPtr<ICoreWebView2> webview, const std::wstring &newContent,
std::function<void()> onComplete)
{
if (webview == nullptr)
{
if (onComplete)
{
onComplete();
}
return;
}
std::wstring script;
script.reserve(newContent.length() + 256);
script.append(L"document.getElementById('measureContainer').innerHTML = `");
script.append(newContent);
script.append(L"`;\n");
script.append(L"if (window.SetCandidatePreeditVisible) { window.SetCandidatePreeditVisible(");
script.append(GetConfiguredCandidateWindowPreeditStyle() == "empty" ? L"false" : L"true");
script.append(L"); }\n");
if (!onComplete)
{
webview->ExecuteScript(script.c_str(), nullptr);
return;
}
webview->ExecuteScript(
script.c_str(),
Callback<ICoreWebView2ExecuteScriptCompletedHandler>(
[onComplete](HRESULT, LPCWSTR) -> HRESULT {
onComplete();
return S_OK;
})
.Get());
}
void UpdateMeasureContentWithJavaScript(ComPtr<ICoreWebView2> webview, const std::wstring &newContent)
{
UpdateMeasureContentWithJavaScript(webview, newContent, nullptr);
}
void ResetContainerHoverCandWnd(ComPtr<ICoreWebView2> webview)
{
if (webview != nullptr)
{
std::wstring script = LR"(
const realContainer = document.getElementById('realContainer');
realContainer.classList.remove('hover-active');
)";
webview->ExecuteScript(script.c_str(), nullptr);
}
}
void DisableMouseForAWhileWhenShownCandWnd(ComPtr<ICoreWebView2> webview)
{
if (webview != nullptr)
{
std::wstring script = LR"(
if (window.mouseBlockTimeout) {
clearTimeout(window.mouseBlockTimeout);
}
document.documentElement.style.pointerEvents = "none";
window.mouseBlockTimeout = setTimeout(() => {
document.documentElement.style.pointerEvents = "auto";
window.mouseBlockTimeout = null;
}, 500);
)";
webview->ExecuteScript(script.c_str(), nullptr);
}
}
void InflateCandWnd(std::wstring &str)
{
InflateCandWnd(str, nullptr);
}
void InflateCandWnd(std::wstring &str, std::function<void()> onComplete)
{
std::wstringstream wss(str);
std::wstring token;
std::vector<std::wstring> words;
while (std::getline(wss, token, L','))
{
words.push_back(token);
}
int size = static_cast<int>(words.size());
while (words.size() < 9)
{
words.push_back(L"");
}
std::wstring result = fmt::format( //
BodyStringCandWnd, //
words[0], //
words[1], //
words[2], //
words[3], //
words[4], //
words[5], //
words[6], //
words[7], //
words[8] //
); //
if (size < 9)
{
size_t pos = result.find(fmt::format(L"<!--{}Anchor-->", size));
result = result.substr(0, pos);
}
UpdateHtmlContentWithJavaScript(webviewCandWnd, result, std::move(onComplete));
}
void InflateMeasureDivCandWnd(std::wstring &str)
{
InflateMeasureDivCandWnd(str, nullptr);
}
void InflateMeasureDivCandWnd(std::wstring &str, std::function<void()> onComplete)
{
str.erase(std::remove(str.begin(), str.end(), L'\uE000'), str.end());
std::wstringstream wss(str);
std::wstring token;
std::vector<std::wstring> words;
while (std::getline(wss, token, L','))
{
words.push_back(token);
}
int size = words.size();
while (words.size() < 9)
{
words.push_back(L"");
}
std::wstring result = fmt::format( //
::MeasureStringCandWnd, //
words[0], //
words[1], //
words[2], //
words[3], //
words[4], //
words[5], //
words[6], //
words[7], //
words[8] //
); //
if (size < 9)
{
size_t pos = result.find(fmt::format(L"<!--{}Anchor-->", size));
// result = result.substr(0, pos) + L"</div>";
result = result.substr(0, pos);
}
UpdateMeasureContentWithJavaScript(webviewCandWnd, result, std::move(onComplete));
}
/**
* @brief Handle candidate window webview2 controller creation
*
* @param hwnd
* @param result
* @param controller
* @return HRESULT
*/
HRESULT OnControllerCreatedCandWnd( //
HWND hwnd, //
HRESULT result, //
ICoreWebView2Controller *controller //
)
{
if (!controller || FAILED(result))
{
OnSmallWindowControllerSettled(FAILED(result) ? result : E_FAIL);
return E_FAIL;
}
webviewControllerCandWnd = controller;
const HRESULT getWebviewHr = webviewControllerCandWnd->get_CoreWebView2(webviewCandWnd.GetAddressOf());
if (!webviewCandWnd)
{
webviewControllerCandWnd.Reset();
OnSmallWindowControllerSettled(FAILED(getWebviewHr) ? getWebviewHr : E_FAIL);
return E_FAIL;
}
UpdateSmallWindowWebviewVisibility(hwnd, IsWindowVisible(hwnd) != FALSE);
// Configure WebView settings
ComPtr<ICoreWebView2Settings> settings;
if (SUCCEEDED(webviewCandWnd->get_Settings(&settings)))
{
settings->put_IsScriptEnabled(TRUE);
settings->put_AreDefaultScriptDialogsEnabled(FALSE);
settings->put_IsWebMessageEnabled(TRUE);
settings->put_AreHostObjectsAllowed(FALSE); // Since we only use WebMessages
settings->put_IsZoomControlEnabled(FALSE);
settings->put_IsStatusBarEnabled(FALSE);
settings->put_AreDefaultContextMenusEnabled(FALSE);
settings->put_AreDevToolsEnabled(FALSE);
// Try to disable browser accelerators (Ctrl+R, F5, etc.)
ComPtr<ICoreWebView2Settings3> settings3;
if (SUCCEEDED(settings->QueryInterface(IID_PPV_ARGS(&settings3))))
{
settings3->put_AreBrowserAcceleratorKeysEnabled(FALSE);
// settings3->put_IsPinchZoomEnabled(FALSE); // Unsupported in this header version
}
// Try to disable autofill and password saving
ComPtr<ICoreWebView2Settings5> settings5;
if (SUCCEEDED(settings->QueryInterface(IID_PPV_ARGS(&settings5))))
{
settings5->put_IsGeneralAutofillEnabled(FALSE);
settings5->put_IsPasswordAutosaveEnabled(FALSE);
}
// Try to disable built-in error pages for a cleaner UI
ComPtr<ICoreWebView2Settings6> settings6;
if (SUCCEEDED(settings->QueryInterface(IID_PPV_ARGS(&settings6))))
{
settings6->put_IsBuiltInErrorPageEnabled(FALSE);
}
}
webviewControllerCandWnd->put_ZoomFactor(1.0);
// Configure virtual host path
if (SUCCEEDED(webviewCandWnd->QueryInterface(IID_PPV_ARGS(&webview3CandWnd))))
{
const std::wstring assetPath = fmt::format( //
L"{}\\{}\\html\\webview2\\candwnd", //
string_to_wstring(CommonUtils::get_local_appdata_path()), //
GlobalIme::AppName //
);
// Assets mapping
const HRESULT mappingHr = webview3CandWnd->SetVirtualHostNameToFolderMapping( //
L"candwnd", //
assetPath.c_str(), //
COREWEBVIEW2_HOST_RESOURCE_ACCESS_KIND_DENY_CORS //
); //
(void)0;
}
// Set transparent background
if (SUCCEEDED(controller->QueryInterface(IID_PPV_ARGS(&webviewController2CandWnd))))
{
COREWEBVIEW2_COLOR backgroundColor = {0, 0, 0, 0};
webviewController2CandWnd->put_DefaultBackgroundColor(backgroundColor);
}
// Adjust to window size
RECT bounds;
GetClientRect(hwnd, &bounds);
// The candidate page uses the extra viewport for stable off-screen
// measurement before its host window is resized to the measured content.
bounds.right += candidateBoundRightExtra;
bounds.bottom += candidateBoundBottomExtra;
const HRESULT boundsHr = webviewControllerCandWnd->put_Bounds(bounds);
(void)0;
// Navigate to HTML
HRESULT hr = webviewCandWnd->NavigateToString(HTMLStringCandWnd.c_str());
(void)0;
if (FAILED(hr))
{
ShowErrorMessage(hwnd, L"Failed to navigate to string.");
}
/* Debug console */
// webview->OpenDevToolsWindow();
webviewCandWnd->add_WebMessageReceived(
Microsoft::WRL::Callback<ICoreWebView2WebMessageReceivedEventHandler>(
[hwnd](ICoreWebView2 *sender, ICoreWebView2WebMessageReceivedEventArgs *args) -> HRESULT {
wil::unique_cotaskmem_string message;
HRESULT hr = args->TryGetWebMessageAsString(&message);
if (SUCCEEDED(hr) && message.get())
{
std::wstring msg(message.get());
// 解析 msg，执行相应操作
try
{
json::value val = json::parse(wstring_to_string(msg));
std::string type = json::value_to<std::string>(val.at("type"));
if (type == "delete")
{
int idx = json::value_to<int>(val.at("data"));
if (FanyImeIpc::IsValidCandidateUiOneBasedIndex(idx))
{
PostMessage(::global_hwnd, WM_DELETE_CANDIDATE, idx, 0);
}
}
else if (type == "pin")
{
int idx = json::value_to<int>(val.at("data"));
if (FanyImeIpc::IsValidCandidateUiOneBasedIndex(idx))
{
PostMessage(::global_hwnd, WM_PIN_TO_TOP_CANDIDATE, idx, 0);
}
}
else if (type == "fixPosition")
{
int idx = json::value_to<int>(val.at("data").at("index"));
int position = json::value_to<int>(val.at("data").at("position"));
if (FanyImeIpc::IsValidCandidateUiOneBasedIndex(idx) && position >= 1 && position <= 5)
PostMessage(::global_hwnd, WM_FIX_CANDIDATE_POSITION, idx, position);
}
else if (type == "clearPosition")
{
int idx = json::value_to<int>(val.at("data"));
if (FanyImeIpc::IsValidCandidateUiOneBasedIndex(idx))
PostMessage(::global_hwnd, WM_CLEAR_CANDIDATE_POSITION, idx, 0);
}
else if (type == "contextMenuResize")
{
const auto &data = val.at("data");
const int width = json::value_to<int>(data.at("width"));
const int height = json::value_to<int>(data.at("height"));
int top_expansion = 0;
if (const auto *value = data.as_object().if_contains("topExpansion"))
top_expansion = (std::max)(0, json::value_to<int>(*value));
int left_expansion = 0;
if (const auto *value = data.as_object().if_contains("leftExpansion"))
left_expansion = (std::max)(0, json::value_to<int>(*value));
RECT window_rect{};
GetWindowRect(hwnd, &window_rect);
const FLOAT scale = static_cast<FLOAT>(GetDpiForWindow(hwnd)) / 96.0f;
const int current_width = static_cast<int>(window_rect.right - window_rect.left);
const int current_height = static_cast<int>(window_rect.bottom - window_rect.top);
const int top_expansion_px =
static_cast<int>(std::ceil(top_expansion * scale));
const int left_expansion_px =
static_cast<int>(std::ceil(left_expansion * scale));
SetWindowPos(hwnd, nullptr, window_rect.left - left_expansion_px,
window_rect.top - top_expansion_px,
(std::max)(current_width, static_cast<int>(std::ceil(width * scale))) +
left_expansion_px,
(std::max)(current_height, static_cast<int>(std::ceil(height * scale))) +
top_expansion_px,
SWP_NOZORDER | SWP_NOACTIVATE);
// FineTuneWindow clips the stable candidate host to
// the card. The context menu is allowed to use the
// temporarily expanded host and FineTuneWindow
// reapplies the tight region after it closes.
SetWindowRgn(hwnd, nullptr, TRUE);
RECT bounds{};
GetClientRect(hwnd, &bounds);
webviewControllerCandWnd->put_Bounds(bounds);
if (top_expansion > 0 || left_expansion > 0)
{
const std::wstring script =
L"if(window.ApplyContextMenuTopExpansion)"
L"window.ApplyContextMenuTopExpansion(" +
std::to_wstring(top_expansion) +
L");if(window.ApplyContextMenuLeftExpansion)"
L"window.ApplyContextMenuLeftExpansion(" +
std::to_wstring(left_expansion) + L");";
webviewCandWnd->ExecuteScript(script.c_str(), nullptr);
}
}
else if (type == "contextMenuClosed")
{
const std::wstring preedit = GetConfiguredCandidateWindowPreeditStyle() == "empty"
? std::wstring{} : GetPreeditWithCaretMarker();
std::wstring measurement = preedit + L"," + Global::CandidateString;
InflateMeasureDivCandWnd(measurement, [hwnd]() { FineTuneWindow(hwnd); });
}
else if (type == "candidate")
{
int idx = json::value_to<int>(val.at("data"));
if (FanyImeIpc::IsValidCandidateUiOneBasedIndex(idx))
{
PostMessage(::global_hwnd, WM_COMMIT_CANDIDATE, idx, 0);
}
}
}
catch (const std::exception &e)
{
#ifdef FANY_DEBUG
(void)0;
#endif
return S_OK;
}
}
return S_OK;
})
.Get(),
nullptr);
webviewCandWnd->add_NavigationCompleted(
Microsoft::WRL::Callback<ICoreWebView2NavigationCompletedEventHandler>(
[hwnd](ICoreWebView2 *, ICoreWebView2NavigationCompletedEventArgs *args) -> HRESULT {
BOOL success = FALSE;
COREWEBVIEW2_WEB_ERROR_STATUS errorStatus = COREWEBVIEW2_WEB_ERROR_STATUS_UNKNOWN;
const HRESULT successHr = args->get_IsSuccess(&success);
const HRESULT statusHr = args->get_WebErrorStatus(&errorStatus);
(void)0;
if (success)
{
NotifySmallWindowNavigationReady(candidateNavigationReady, L"candidate");
ApplyConfiguredCandidateAppearance();
}
else
{
(void)0;
}
if (success && ::is_global_wnd_cand_shown)
{
const std::wstring preedit = GetConfiguredCandidateWindowPreeditStyle() == "empty"
? std::wstring{}
: GetPreeditWithCaretMarker();
std::wstring str = preedit + L"," + Global::CandidateString;
InflateMeasureDivCandWnd(str, [hwnd]() {
if (!::is_global_wnd_cand_shown)
{
return;
}
FineTuneWindow(hwnd);
});
}
return S_OK;
})
.Get(),
nullptr);
webviewCandWnd->add_ProcessFailed(
Microsoft::WRL::Callback<ICoreWebView2ProcessFailedEventHandler>(
[](ICoreWebView2 *, ICoreWebView2ProcessFailedEventArgs *args) -> HRESULT {
COREWEBVIEW2_PROCESS_FAILED_KIND kind = COREWEBVIEW2_PROCESS_FAILED_KIND_BROWSER_PROCESS_EXITED;
const HRESULT hr = args->get_ProcessFailedKind(&kind);
(void)0;
return S_OK;
}).Get(),
nullptr);
OnSmallWindowControllerSettled(S_OK);
return S_OK;
}
/**
* @brief Handle candidate window webview2 environment creation
*
* @param hwnd
* @param result
* @param env
* @return HRESULT
*/
HRESULT OnEnvironmentCreated(HWND hwnd, HRESULT result, ICoreWebView2Environment *env)
{
(void)0;
if (FAILED(result) || !env)
{
ShowErrorMessage(hwnd, L"Failed to create WebView2 environment.");
return result;
}
// Create WebView2 controller
const HRESULT hr = env->CreateCoreWebView2Controller( //
hwnd, //
Microsoft::WRL::Callback<ICoreWebView2CreateCoreWebView2ControllerCompletedHandler>( //
[hwnd](HRESULT result, //
ICoreWebView2Controller *controller) -> HRESULT { //
return OnControllerCreatedCandWnd(hwnd, result, controller); //
}) //
.Get() //
); //
(void)0;
return hr;
}
//
//
// 菜单窗口 webview
//
//
/**
* @brief Handle menu window webview2 controller creation
*
* @param hwnd
* @param result
* @param controller
* @return HRESULT
*/
HRESULT OnControllerCreatedMenuWnd( //
HWND hwnd, //
HRESULT result, //
ICoreWebView2Controller *controller //
)
{
if (!controller || FAILED(result))
{
OnSmallWindowControllerSettled(FAILED(result) ? result : E_FAIL);
return E_FAIL;
}
/* 给 controller 和 webview 赋值 */
webviewControllerMenuWnd = controller;
const HRESULT getMenuWebviewHr = webviewControllerMenuWnd->get_CoreWebView2(webviewMenuWnd.GetAddressOf());
if (!webviewMenuWnd)
{
webviewControllerMenuWnd.Reset();
OnSmallWindowControllerSettled(FAILED(getMenuWebviewHr) ? getMenuWebviewHr : E_FAIL);
return E_FAIL;
}
UpdateSmallWindowWebviewVisibility(hwnd, IsWindowVisible(hwnd) != FALSE);
// Configure webviewMenuWindow settings
ComPtr<ICoreWebView2Settings> settings;
if (SUCCEEDED(webviewMenuWnd->get_Settings(&settings)))
{
settings->put_IsScriptEnabled(TRUE);
settings->put_AreDefaultScriptDialogsEnabled(FALSE);
settings->put_IsWebMessageEnabled(TRUE);
settings->put_AreHostObjectsAllowed(FALSE);
settings->put_AreDefaultContextMenusEnabled(FALSE);
settings->put_AreDevToolsEnabled(FALSE);
settings->put_IsZoomControlEnabled(FALSE);
settings->put_IsStatusBarEnabled(FALSE);
ComPtr<ICoreWebView2Settings3> settings3;
if (SUCCEEDED(settings.As(&settings3)))
{
settings3->put_AreBrowserAcceleratorKeysEnabled(FALSE);
}
ComPtr<ICoreWebView2Settings5> settings5;
if (SUCCEEDED(settings.As(&settings5)))
{
settings5->put_IsGeneralAutofillEnabled(FALSE);
settings5->put_IsPasswordAutosaveEnabled(FALSE);
}
}
webviewControllerMenuWnd->put_ZoomFactor(1.0);
// Configure virtual host path
if (SUCCEEDED(webviewMenuWnd->QueryInterface(IID_PPV_ARGS(&webview3MenuWnd))))
{
// Assets mapping
webview3MenuWnd->SetVirtualHostNameToFolderMapping( //
L"appassets", //
GetLocalAssetsPath().c_str(), //
COREWEBVIEW2_HOST_RESOURCE_ACCESS_KIND_DENY_CORS //
); //
}
// Set transparent background
if (SUCCEEDED(controller->QueryInterface(IID_PPV_ARGS(&webviewController2MenuWnd))))
{
COREWEBVIEW2_COLOR backgroundColor = {0, 0, 0, 0};
webviewController2MenuWnd->put_DefaultBackgroundColor(backgroundColor);
}
// Adjust to window size
RECT bounds;
GetClientRect(hwnd, &bounds);
webviewControllerMenuWnd->put_Bounds(bounds);
EventRegistrationToken menuNavigationCompletedToken{};
webviewMenuWnd->add_NavigationCompleted(
Microsoft::WRL::Callback<ICoreWebView2NavigationCompletedEventHandler>(
[hwnd](ICoreWebView2 *sender, ICoreWebView2NavigationCompletedEventArgs *args) -> HRESULT {
BOOL success = FALSE;
if (!args || FAILED(args->get_IsSuccess(&success)) || !success)
{
(void)0;
return S_OK;
}
NotifySmallWindowNavigationReady(menuNavigationReady, L"menu");
// Older menu assets already render the handwriting entry but do not
// give it an id or native click bridge. Wire it at runtime so existing
// installations gain the launcher without replacing their skin.
sender->ExecuteScript(
LR"((() => {
const item = [...document.querySelectorAll('.menu-item')]
.find(element => element.textContent.includes('\u624b\u5199\u8bc6\u522b\u677f'));
if (item && !item.dataset.nativeHandwritingLauncher) {
item.dataset.nativeHandwritingLauncher = 'true';
item.addEventListener('click', () => {
window.chrome.webview.postMessage(JSON.stringify({ type: 'handwritingPanel' }));
});
}
})())",
nullptr);
SyncMenuFloatingToolbarToggle();
PostMessage(hwnd, WM_REFRESH_MENU_SIZE, 0, 0);
return S_OK;
})
.Get(),
&menuNavigationCompletedToken);
// Navigate to HTML
webviewMenuWnd->NavigateToString(::HTMLStringMenuWnd.c_str());
/* Debug console */
// webviewMenuWindow->OpenDevToolsWindow();
webviewMenuWnd->add_WebMessageReceived(
Microsoft::WRL::Callback<ICoreWebView2WebMessageReceivedEventHandler>(
[hwnd](ICoreWebView2 *sender, ICoreWebView2WebMessageReceivedEventArgs *args) -> HRESULT {
wil::unique_cotaskmem_string message;
HRESULT hr = args->TryGetWebMessageAsString(&message);
if (SUCCEEDED(hr) && message.get())
{
std::wstring msg(message.get());
// 解析 msg，执行相应操作
json::value val = json::parse(wstring_to_string(msg));
std::string type = json::value_to<std::string>(val.at("type"));
if (type == "floatingToggle")
{
bool needShown = json::value_to<bool>(val.at("data"));
if (SetConfiguredFloatingToolbarEnabled(needShown))
{
ApplyConfiguredFloatingToolbarVisibility();
PostSettingsConfig();
}
}
else if (type == "settings")
{
OpenSettingsApplication();
ShowWindow(::global_hwnd_menu, SW_HIDE);
}
else if (type == "about")
{
OpenSettingsAboutApplication();
ShowWindow(::global_hwnd_menu, SW_HIDE);
}
else if (type == "emojiSymbols")
{
OpenEmojiPanelApplication();
ShowWindow(::global_hwnd_menu, SW_HIDE);
}
else if (type == "keyboardPanel")
{
OpenKeyboardPanelApplication();
ShowWindow(::global_hwnd_menu, SW_HIDE);
}
else if (type == "handwritingPanel")
{
OpenHandwritingPanelApplication();
ShowWindow(::global_hwnd_menu, SW_HIDE);
}
else if (type == "voiceInput")
{
VoiceInput::ToggleRecording();
ShowWindow(::global_hwnd_menu, SW_HIDE);
}
}
return S_OK;
})
.Get(),
nullptr);
OnSmallWindowControllerSettled(S_OK);
return S_OK;
}
/**
* @brief Handle menu window webview2 environment creation
*
* @param hwnd
* @param result
* @param env
* @return HRESULT
*/
HRESULT OnMenuWindowEnvironmentCreated(HWND hwnd, HRESULT result, ICoreWebView2Environment *env)
{
if (FAILED(result) || !env)
{
#ifdef FANY_DEBUG
(void)0;
#endif
return result;
}
// Create WebView2 controller
return env->CreateCoreWebView2Controller( //
hwnd, //
Microsoft::WRL::Callback<ICoreWebView2CreateCoreWebView2ControllerCompletedHandler>( //
[hwnd](HRESULT result, ICoreWebView2Controller *controller) -> HRESULT { //
return OnControllerCreatedMenuWnd(hwnd, result, controller); //
}) //
.Get() //
); //
}
//
//
// settings 窗口 webview
//
//
HRESULT EnsureCompositionVisualTreeSettingsWnd(HWND hwnd)
{
if (dcompDeviceSettingsWnd && dcompTargetSettingsWnd && dcompRootVisualSettingsWnd)
{
return S_OK;
}
HRESULT hr = DCompositionCreateDevice(nullptr, __uuidof(IDCompositionDevice),
reinterpret_cast<void **>(dcompDeviceSettingsWnd.GetAddressOf()));
if (FAILED(hr))
{
return hr;
}
hr = dcompDeviceSettingsWnd->CreateTargetForHwnd(hwnd, TRUE, &dcompTargetSettingsWnd);
if (FAILED(hr))
{
return hr;
}
hr = dcompDeviceSettingsWnd->CreateVisual(&dcompRootVisualSettingsWnd);
if (FAILED(hr))
{
return hr;
}
hr = dcompTargetSettingsWnd->SetRoot(dcompRootVisualSettingsWnd.Get());
if (FAILED(hr))
{
return hr;
}
return dcompDeviceSettingsWnd->Commit();
}
/**
* @brief Handle settings window webview2 controller creation
*
* @param hwnd
* @param result
* @param controller
* @return HRESULT
*/
HRESULT OnControllerCreatedSettingsWnd( //
HWND hwnd, //
HRESULT result, //
ICoreWebView2CompositionController *controller //
)
{
if (!controller || FAILED(result))
{
#ifdef FANY_DEBUG
(void)0;
#endif
return E_FAIL;
}
/* 给 controller 和 webview 赋值 */
webviewCompositionControllerSettingsWnd = controller;
if (FAILED(webviewCompositionControllerSettingsWnd.As(&webviewControllerSettingsWnd)))
{
#ifdef FANY_DEBUG
(void)0;
#endif
return E_NOINTERFACE;
}
webviewControllerSettingsWnd->get_CoreWebView2(webviewSettingsWnd.GetAddressOf());
if (!webviewSettingsWnd)
{
#ifdef FANY_DEBUG
(void)0;
#endif
return E_FAIL;
}
// Configure webviewSettingsWindow settings
ComPtr<ICoreWebView2Settings> settings;
if (SUCCEEDED(webviewSettingsWnd->get_Settings(&settings)))
{
settings->put_IsScriptEnabled(TRUE);
settings->put_AreDefaultScriptDialogsEnabled(TRUE);
settings->put_IsWebMessageEnabled(TRUE);
settings->put_AreHostObjectsAllowed(TRUE);
settings->put_IsZoomControlEnabled(FALSE);
}
webviewControllerSettingsWnd->put_ZoomFactor(1.0);
// Configure virtual host path
if (SUCCEEDED(webviewSettingsWnd->QueryInterface(IID_PPV_ARGS(&webview3SettingsWnd))))
{
const std::wstring assetPath = fmt::format( //
L"{}\\{}\\html\\webview2\\settings\\ime-settings\\dist", //
string_to_wstring(CommonUtils::get_local_appdata_path()), //
GlobalIme::AppName //
);
// Assets mapping
webview3SettingsWnd->SetVirtualHostNameToFolderMapping( //
L"imesettings", //
assetPath.c_str(), //
COREWEBVIEW2_HOST_RESOURCE_ACCESS_KIND_ALLOW //
); //
}
// The settings page is fully opaque. Keeping the composition surface
// transparent makes DWM briefly expose the host backdrop on input-driven
// WebView repaints, which looks like the window/taskbar is flashing.
if (SUCCEEDED(webviewControllerSettingsWnd.As(&webviewController2SettingsWnd)))
{
const bool settingsLight = ResolveConfiguredTheme(GetConfiguredThemeSettings()) == "light";
COREWEBVIEW2_COLOR backgroundColor =
settingsLight ? COREWEBVIEW2_COLOR{255, 243, 243, 243} : COREWEBVIEW2_COLOR{255, 32, 32, 32};
webviewController2SettingsWnd->put_DefaultBackgroundColor(backgroundColor);
}
const HRESULT compositionResult = EnsureCompositionVisualTreeSettingsWnd(hwnd);
if (FAILED(compositionResult))
{
#ifdef FANY_DEBUG
(void)0;
#endif
return compositionResult;
}
const HRESULT rootVisualResult =
webviewCompositionControllerSettingsWnd->put_RootVisualTarget(dcompRootVisualSettingsWnd.Get());
if (FAILED(rootVisualResult))
{
#ifdef FANY_DEBUG
(void)0;
#endif
return rootVisualResult;
}
dcompDeviceSettingsWnd->Commit();
// Adjust to window size
RECT bounds;
GetClientRect(hwnd, &bounds);
webviewControllerSettingsWnd->put_Bounds(bounds);
// Navigate to HTML
// HRESULT hr = webviewSettingsWnd->NavigateToString(::HTMLStringSettingsWnd.c_str());
std::wstring url = L"https://imesettings/index.html";
HRESULT hr = webviewSettingsWnd->Navigate(url.c_str());
if (FAILED(hr))
{
#ifdef FANY_DEBUG
(void)0;
#endif
}
EventRegistrationToken navCompletedToken;
webviewSettingsWnd->add_NavigationCompleted(
Microsoft::WRL::Callback<ICoreWebView2NavigationCompletedEventHandler>( //
[hwnd](ICoreWebView2 *sender, ICoreWebView2NavigationCompletedEventArgs *args) -> HRESULT {
BOOL success;
args->get_IsSuccess(&success);
if (success)
{
// 隐藏窗口
#ifdef FANY_DEBUG
(void)0;
#endif
BOOL cloak = FALSE;
DwmSetWindowAttribute(hwnd, DWMWA_CLOAK, &cloak, sizeof(cloak));
}
PostSettingsWindowState(hwnd);
PostSettingsConfig();
return S_OK;
})
.Get(),
&navCompletedToken);
/* 处理 js 发过来的消息 */
webviewSettingsWnd->add_WebMessageReceived(
Microsoft::WRL::Callback<ICoreWebView2WebMessageReceivedEventHandler>(
[hwnd](ICoreWebView2 *sender, ICoreWebView2WebMessageReceivedEventArgs *args) -> HRESULT {
wil::unique_cotaskmem_string message;
HRESULT hr = args->TryGetWebMessageAsString(&message);
if (SUCCEEDED(hr) && message.get())
{
std::wstring msg(message.get());
// 解析 msg，执行相应操作
json::value val = json::parse(wstring_to_string(msg));
std::string type = json::value_to<std::string>(val.at("type"));
/* 使 settings 窗口可拖动 */
if (type == "dragStart")
{
ReleaseCapture();
PostMessage(hwnd, WM_NCLBUTTONDOWN, HTCAPTION, 0);
}
else if (type == "resizeHitTest" || type == "resizeStart")
{
std::string hit = json::value_to<std::string>(val.at("data"));
int hitTest = HTCLIENT;
if (hit == "left")
{
hitTest = HTLEFT;
}
else if (hit == "right")
{
hitTest = HTRIGHT;
}
else if (hit == "top")
{
hitTest = HTTOP;
}
else if (hit == "bottom")
{
hitTest = HTBOTTOM;
}
else if (hit == "left-top")
{
hitTest = HTTOPLEFT;
}
else if (hit == "right-top")
{
hitTest = HTTOPRIGHT;
}
else if (hit == "left-bottom")
{
hitTest = HTBOTTOMLEFT;
}
else if (hit == "right-bottom")
{
hitTest = HTBOTTOMRIGHT;
}
if (hitTest != HTCLIENT)
{
ReleaseCapture();
PostMessage(hwnd, WM_NCLBUTTONDOWN, hitTest, 0);
}
}
else if (type == "focus")
{
SetFocus(hwnd);
}
else if (type == "windowControl")
{
std::string value = json::value_to<std::string>(val.at("data"));
if (value == "minimize")
{
ShowWindow(hwnd, SW_MINIMIZE);
}
else if (value == "maximize")
{
ShowWindow(hwnd, SW_MAXIMIZE);
}
else if (value == "close")
{
ShowWindow(hwnd, SW_HIDE);
}
else if (value == "restore")
{
ShowWindow(hwnd, SW_RESTORE);
}
}
else if (type == "maximizeButtonRect")
{
try
{
auto &data = val.at("data").as_object();
double x = data.if_contains("x") ? json::value_to<double>(*data.if_contains("x")) : 0.0;
double y = data.if_contains("y") ? json::value_to<double>(*data.if_contains("y")) : 0.0;
double width =
data.if_contains("width") ? json::value_to<double>(*data.if_contains("width")) : 0.0;
double height =
data.if_contains("height") ? json::value_to<double>(*data.if_contains("height")) : 0.0;
double scale =
data.if_contains("dpr") ? json::value_to<double>(*data.if_contains("dpr")) : 0.0;
if (scale <= 0.0)
{
scale = static_cast<double>(GetDpiForWindow(hwnd)) / 96.0;
}
const int left = static_cast<int>(std::lround(x * scale));
const int top = static_cast<int>(std::lround(y * scale));
const int right = static_cast<int>(std::lround((x + width) * scale));
const int bottom = static_cast<int>(std::lround((y + height) * scale));
maximizeButtonRectSettingsWnd = {left, top, right, bottom};
hasMaximizeButtonRectSettingsWnd = true;
}
catch (const std::exception &)
{
}
}
else if (type == "configRequest")
{
PostSettingsConfig();
}
else if (type == "configUpdate")
{
try
{
const auto &data = val.at("data").as_object();
const std::string path = json::value_to<std::string>(data.at("path"));
if (path == "input.schema")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredInputScheme(value))
{
ApplyConfiguredInputScheme();
PostSettingsConfig();
}
}
else if (path == "input.character_set")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredCharacterSet(value))
{
UpdateFtbCharacterSetState(::webviewFtbWnd);
FanyNamedPipe::EnqueueRefreshCandidatePageTask();
PostSettingsConfig();
}
}
else if (path == "input.default_ime_mode")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredDefaultImeMode(value))
{
PostSettingsConfig();
}
}
else if (path == "input.ime_mode_scope")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredImeModeScope(value))
{
PostSettingsConfig();
}
}
else if (path == "input.shuangpin_schema")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredShuangpinSchema(value))
{
ApplyConfiguredShuangpinSchema();
PostSettingsConfig();
}
}
else if (path == "input.wubi_schema")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredWubiSchema(value))
{
PostSettingsConfig();
}
}
else if (path == "appearance.tsf_preedit_style")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredTsfPreeditStyle(value))
{
BroadcastToTsfWorkerThreadViaNamedpipe(
Global::DataFromServerMsgTypeToTsfWorkerThread::PagingCommaPeriodChanged,
FormatPagingCommaPeriodWorkerPayload());
PostSettingsConfig();
}
}
else if (path == "appearance.candidate_window_layout")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredCandidateWindowLayout(value))
{
ApplyConfiguredCandidateWindowLayout();
PostSettingsConfig();
}
}
else if (path == "appearance.candidate_window_preedit_style")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredCandidateWindowPreeditStyle(value))
{
PostSettingsConfig();
}
}
else if (path == "appearance.page_size")
{
const int value = static_cast<int>(data.at("value").as_int64());
if (SetConfiguredCandidatePageSize(value))
{
FanyNamedPipe::EnqueueApplyCandidatePageSizeTask();
PostSettingsConfig();
}
}
else if (path == "appearance.font")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredCandidateFont(value))
{
ApplyConfiguredCandidateAppearance();
PostSettingsConfig();
}
}
else if (path == "appearance.english_font")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredCandidateEnglishFont(value))
{
ApplyConfiguredCandidateAppearance();
PostSettingsConfig();
}
}
else if (path == "appearance.font_size")
{
const int value = static_cast<int>(data.at("value").as_int64());
if (SetConfiguredCandidateFontSize(value))
{
ApplyConfiguredCandidateAppearance();
PostSettingsConfig();
}
}
else if (path == "appearance.cand_text_color")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredCandidateTextColor(value))
{
ApplyConfiguredCandidateAppearance();
PostSettingsConfig();
}
}
else if (path == "appearance.theme_mode")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredThemeMode(value))
{
ApplyConfiguredUiThemes();
if (webviewController2SettingsWnd)
{
const bool settingsLight =
ResolveConfiguredTheme(GetConfiguredThemeSettings()) == "light";
COREWEBVIEW2_COLOR backgroundColor =
settingsLight ? COREWEBVIEW2_COLOR{255, 243, 243, 243}
: COREWEBVIEW2_COLOR{255, 32, 32, 32};
webviewController2SettingsWnd->put_DefaultBackgroundColor(backgroundColor);
}
PostSettingsConfig();
}
}
else if (path == "appearance.theme_settings")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredThemeSettings(value))
{
if (webviewController2SettingsWnd)
{
const bool settingsLight =
ResolveConfiguredTheme(GetConfiguredThemeSettings()) == "light";
COREWEBVIEW2_COLOR backgroundColor =
settingsLight ? COREWEBVIEW2_COLOR{255, 243, 243, 243}
: COREWEBVIEW2_COLOR{255, 32, 32, 32};
webviewController2SettingsWnd->put_DefaultBackgroundColor(backgroundColor);
}
PostSettingsConfig();
}
}
else if (path == "appearance.theme_cand")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredThemeCand(value))
{
ApplyConfiguredUiThemes();
PostSettingsConfig();
}
}
else if (path == "appearance.theme_ftb")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredThemeFtb(value))
{
ApplyConfiguredUiThemes();
PostSettingsConfig();
}
}
else if (path == "appearance.theme_menu")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredThemeMenu(value))
{
ApplyConfiguredUiThemes();
PostSettingsConfig();
}
}
else if (path == "appearance.theme_emoji")
{
if (SetConfiguredThemeEmoji(json::value_to<std::string>(data.at("value"))))
PostSettingsConfig();
}
else if (path == "appearance.theme_screen_keyboard")
{
if (SetConfiguredThemeScreenKeyboard(json::value_to<std::string>(data.at("value"))))
PostSettingsConfig();
}
else if (path == "appearance.theme_handwriting")
{
if (SetConfiguredThemeHandwriting(json::value_to<std::string>(data.at("value"))))
PostSettingsConfig();
}
else if (path == "appearance.theme_voice")
{
if (SetConfiguredThemeVoice(json::value_to<std::string>(data.at("value"))))
PostSettingsConfig();
}
else if (path == "general.floating_toolbar")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredFloatingToolbarEnabled(value))
{
ApplyConfiguredFloatingToolbarVisibility();
SyncMenuFloatingToolbarToggle();
PostSettingsConfig();
}
}
else if (path == "input.word_to_character")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredWordToCharacterEnabled(value))
{
PostSettingsConfig();
}
}
else if (path.rfind("general.floating_toolbar_", 0) == 0)
{
const std::string item =
path.substr(std::string("general.floating_toolbar_").size());
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredFloatingToolbarItemEnabled(item, value))
{
ApplyConfiguredFloatingToolbarItems();
PostSettingsConfig();
}
}
else if (path == "general.cn_en_mixed_input")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredEnglishCandidatesEnabled(value))
{
PostSettingsConfig();
}
}
else if (path == "general.cloud_candidates")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredCloudCandidatesEnabled(value))
{
PostSettingsConfig();
}
}
else if (path == "utility.unicode_mode")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredUnicodeModeEnabled(value))
{
PostSettingsConfig();
}
}
else if (path == "utility.quick_phrase")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredQuickPhraseEnabled(value))
{
PostSettingsConfig();
}
}
else if (path == "general.paging_minus_equal")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredPagingMinusEqualEnabled(value))
{
PostSettingsConfig();
}
}
else if (path == "general.paging_tab")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredPagingTabEnabled(value))
{
PostSettingsConfig();
}
}
else if (path == "general.paging_comma_period")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredPagingCommaPeriodEnabled(value))
{
BroadcastToTsfWorkerThreadViaNamedpipe(
Global::DataFromServerMsgTypeToTsfWorkerThread::PagingCommaPeriodChanged,
FormatPagingCommaPeriodWorkerPayload());
PostSettingsConfig();
}
}
else if (path == "general.paging_page_up_down")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredPagingPageUpDownEnabled(value))
{
PostSettingsConfig();
}
}
else if (path == "general.candidate_arrow_navigation")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredCandidateArrowNavigationEnabled(value))
{
PostSettingsConfig();
}
}
else if (path == "keybindings.switch_language_shift")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredSwitchLanguageShiftEnabled(value))
{
PostSettingsConfig();
}
}
else if (path == "keybindings.switch_language_ctrl")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredSwitchLanguageCtrlEnabled(value))
{
PostSettingsConfig();
}
}
else if (path == "keybindings.switch_language_ctrl_alt_space")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredSwitchLanguageCtrlAltSpaceEnabled(value))
{
PostSettingsConfig();
}
}
else if (path == "helpcode.show_sp_helpcode_in_candidate_window")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredShowShuangpinHelpcodeInCandidateWindow(value))
{
PostSettingsConfig();
}
}
else if (path == "helpcode.shuangpin_helpcode")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredShuangpinHelpcodeEnabled(value))
{
PostSettingsConfig();
}
}
else if (path == "helpcode.shuangpin_helpcode_schema")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredShuangpinHelpcodeSchema(value))
{
PostSettingsConfig();
}
}
else if (path == "helpcode.quanpin_helpcode")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredQuanpinHelpcodeEnabled(value))
{
PostSettingsConfig();
}
}
else if (path == "helpcode.quanpin_helpcode_schema")
{
const std::string value = json::value_to<std::string>(data.at("value"));
if (SetConfiguredQuanpinHelpcodeSchema(value))
{
PostSettingsConfig();
}
}
else if (path == "helpcode.show_qp_helpcode_in_candidate_window")
{
const bool value = json::value_to<bool>(data.at("value"));
if (SetConfiguredShowQuanpinHelpcodeInCandidateWindow(value))
{
PostSettingsConfig();
}
}
}
catch (const std::exception &)
{
}
}
}
return S_OK;
})
.Get(),
nullptr);
/* Debug console */
// webviewSettingsWindow->OpenDevToolsWindow();
return S_OK;
}
/**
* @brief Handle settings window webview2 environment creation
*
* @param hwnd
* @param result
* @param env
* @return HRESULT
*/
HRESULT OnSettingsWindowEnvironmentCreated(HWND hwnd, HRESULT result, ICoreWebView2Environment *env)
{
if (FAILED(result) || !env)
{
#ifdef FANY_DEBUG
(void)0;
#endif
return result;
}
ComPtr<ICoreWebView2Environment3> env3;
if (FAILED(env->QueryInterface(IID_PPV_ARGS(&env3))) || !env3)
{
#ifdef FANY_DEBUG
(void)0;
#endif
return E_NOINTERFACE;
}
// Create WebView2 controller
return env3->CreateCoreWebView2CompositionController( //
hwnd, //
Microsoft::WRL::Callback<ICoreWebView2CreateCoreWebView2CompositionControllerCompletedHandler>( //
[hwnd](HRESULT result, ICoreWebView2CompositionController *controller) -> HRESULT { //
return OnControllerCreatedSettingsWnd(hwnd, result, controller); //
}) //
.Get() //
); //
}
/**
* @brief Keep tray-menu floating-toolbar toggle aligned with config.toml.
*/
void SyncMenuFloatingToolbarToggle()
{
if (!::webviewMenuWnd)
{
return;
}
// Keep the tray-menu toggle aligned with config.toml so Settings and tray
// never drift apart when either side writes general.floating_toolbar.
const wchar_t *script = GetConfiguredFloatingToolbarEnabled()
? LR"((() => {
const toggle = document.getElementById('floatingToggle');
if (toggle) toggle.classList.add('active');
})())"
: LR"((() => {
const toggle = document.getElementById('floatingToggle');
if (toggle) toggle.classList.remove('active');
})())";
::webviewMenuWnd->ExecuteScript(script, nullptr);
}
/**
* @brief Post the window state of the settings window, 即，是否最大化了，供 settings 窗口的 js 进行相应的调整
*
* @param hwnd
*/
void PostSettingsWindowState(HWND hwnd)
{
if (!::webviewSettingsWnd)
{
return;
}
nlohmann::json payload = {{"type", "windowState"}, {"data", {{"isMaximized", IsZoomed(hwnd) != FALSE}}}};
const std::wstring message = string_to_wstring(payload.dump());
::webviewSettingsWnd->PostWebMessageAsJson(message.c_str());
}
void PostSettingsConfig()
{
if (!::webviewSettingsWnd)
{
return;
}
const FloatingToolbarItemsConfig &toolbar = GetConfiguredFloatingToolbarItems();
nlohmann::json payload = {
{"type", "configSnapshot"},
{"data", {{"input", {{"schema", GetConfiguredInputSchemeName()},
{"character_set", GetConfiguredCharacterSet()},
{"default_ime_mode", GetConfiguredDefaultImeMode()},
{"ime_mode_scope", GetConfiguredImeModeScope()},
{"shuangpin_schema", GetConfiguredShuangpinSchema()},
{"wubi_schema", GetConfiguredWubiSchema()},
{"word_to_character", GetConfiguredWordToCharacterEnabled()}}},
{"general", {{"floating_toolbar", GetConfiguredFloatingToolbarEnabled()},
{"floating_toolbar_fullwidth", toolbar.fullwidth},
{"floating_toolbar_punctuation", toolbar.punctuation},
{"floating_toolbar_character_set", toolbar.character_set},
{"floating_toolbar_emoji", toolbar.emoji},
{"floating_toolbar_screen_keyboard", toolbar.screen_keyboard},
{"floating_toolbar_settings", toolbar.settings},
{"cn_en_mixed_input", GetConfiguredEnglishCandidatesEnabled()},
{"cloud_candidates", GetConfiguredCloudCandidatesEnabled()},
{"paging_minus_equal", GetConfiguredPagingMinusEqualEnabled()},
{"paging_comma_period", GetConfiguredPagingCommaPeriodEnabled()},
{"paging_tab", GetConfiguredPagingTabEnabled()},
{"paging_page_up_down", GetConfiguredPagingPageUpDownEnabled()},
{"candidate_arrow_navigation", GetConfiguredCandidateArrowNavigationEnabled()}}},
{"keybindings", {{"switch_language_shift", GetConfiguredSwitchLanguageShiftEnabled()},
{"switch_language_ctrl", GetConfiguredSwitchLanguageCtrlEnabled()},
{"switch_language_ctrl_alt_space",
GetConfiguredSwitchLanguageCtrlAltSpaceEnabled()}}},
{"utility", {{"unicode_mode", GetConfiguredUnicodeModeEnabled()},
{"quick_phrase", GetConfiguredQuickPhraseEnabled()}}},
{"appearance", {{"candidate_window_layout", GetConfiguredCandidateWindowLayout()},
{"candidate_window_preedit_style", GetConfiguredCandidateWindowPreeditStyle()},
{"tsf_preedit_style", GetConfiguredTsfPreeditStyle()},
{"theme_mode", GetConfiguredThemeMode()},
{"theme_settings", GetConfiguredThemeSettings()},
{"theme_cand", GetConfiguredThemeCand()},
{"theme_ftb", GetConfiguredThemeFtb()},
{"theme_menu", GetConfiguredThemeMenu()},
{"theme_emoji", GetConfiguredThemeEmoji()},
{"theme_screen_keyboard", GetConfiguredThemeScreenKeyboard()},
{"theme_handwriting", GetConfiguredThemeHandwriting()},
{"theme_voice", GetConfiguredThemeVoice()},
{"page_size", GetConfiguredCandidatePageSize()},
{"font", GetConfiguredCandidateFont()},
{"english_font", GetConfiguredCandidateEnglishFont()},
{"default_font", GetConfiguredCandidateDefaultFont()},
{"font_size", GetConfiguredCandidateFontSize()},
{"cand_text_color", GetConfiguredCandidateTextColor()},
{"system_fonts", GetSystemFontFamilies()}}},
{"helpcode",
{{"shuangpin_helpcode", GetConfiguredShuangpinHelpcodeEnabled()},
{"shuangpin_helpcode_schema", GetConfiguredShuangpinHelpcodeSchema()},
{"quanpin_helpcode", GetConfiguredQuanpinHelpcodeEnabled()},
{"quanpin_helpcode_schema", GetConfiguredQuanpinHelpcodeSchema()},
{"show_sp_helpcode_in_candidate_window",
GetConfiguredShowShuangpinHelpcodeInCandidateWindow()},
{"show_qp_helpcode_in_candidate_window",
GetConfiguredShowQuanpinHelpcodeInCandidateWindow()}}}}}};
const std::wstring message = string_to_wstring(payload.dump());
::webviewSettingsWnd->PostWebMessageAsJson(message.c_str());
}
/**
* @brief 初始化 settings 窗口的 webview
*
* @param hwnd
*/
void InitWebviewSettingsWnd(HWND hwnd)
{
std::wstring appDataPath = GetAppdataPath();
CreateCoreWebView2EnvironmentWithOptions( //
nullptr, //
appDataPath.c_str(), //
nullptr, //
Microsoft::WRL::Callback<ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler>( //
[hwnd](HRESULT result, ICoreWebView2Environment *env) -> HRESULT { //
return OnSettingsWindowEnvironmentCreated(hwnd, result, env); //
}) //
.Get() //
); //
}
//
//
// floating toolbar(ftb) 窗口 webview
//
//
/**
* @brief Handle floating toolbar window webview2 controller creation
*
* @param hwnd
* @param result
* @param controller
* @return HRESULT
*/
HRESULT OnControllerCreatedFtbWnd( //
HWND hwnd, //
HRESULT result, //
ICoreWebView2Controller *controller //
)
{
if (!controller || FAILED(result))
{
OnSmallWindowControllerSettled(FAILED(result) ? result : E_FAIL);
return E_FAIL;
}
/* 给 controller 和 webview 赋值 */
webviewControllerFtbWnd = controller;
const HRESULT getFtbWebviewHr = webviewControllerFtbWnd->get_CoreWebView2(webviewFtbWnd.GetAddressOf());
if (!webviewFtbWnd)
{
webviewControllerFtbWnd.Reset();
OnSmallWindowControllerSettled(FAILED(getFtbWebviewHr) ? getFtbWebviewHr : E_FAIL);
return E_FAIL;
}
UpdateSmallWindowWebviewVisibility(hwnd, IsWindowVisible(hwnd) != FALSE);
// Configure webviewFtbWindow settings
ComPtr<ICoreWebView2Settings> settings;
if (SUCCEEDED(webviewFtbWnd->get_Settings(&settings)))
{
settings->put_IsScriptEnabled(TRUE);
settings->put_AreDefaultScriptDialogsEnabled(FALSE);
settings->put_IsWebMessageEnabled(TRUE);
settings->put_AreHostObjectsAllowed(FALSE);
// 禁用右键菜单和开发者工具
settings->put_AreDefaultContextMenusEnabled(FALSE);
settings->put_AreDevToolsEnabled(FALSE);
// 禁止界面缩放
settings->put_IsZoomControlEnabled(FALSE);
settings->put_IsStatusBarEnabled(FALSE);
ComPtr<ICoreWebView2Settings3> settings3;
if (SUCCEEDED(settings.As(&settings3)))
{
settings3->put_AreBrowserAcceleratorKeysEnabled(FALSE);
}
ComPtr<ICoreWebView2Settings5> settings5;
if (SUCCEEDED(settings.As(&settings5)))
{
settings5->put_IsGeneralAutofillEnabled(FALSE);
settings5->put_IsPasswordAutosaveEnabled(FALSE);
}
}
// 初始时缩放设置成 1.0
webviewControllerFtbWnd->put_ZoomFactor(1.0);
// Configure virtual host path
if (SUCCEEDED(webviewFtbWnd->QueryInterface(IID_PPV_ARGS(&webview3FtbWnd))))
{
// Assets mapping
webview3FtbWnd->SetVirtualHostNameToFolderMapping( //
L"appassets", //
GetLocalAssetsPath().c_str(), //
COREWEBVIEW2_HOST_RESOURCE_ACCESS_KIND_DENY_CORS //
); //
}
// Set transparent background
if (SUCCEEDED(controller->QueryInterface(IID_PPV_ARGS(&webviewController2FtbWnd))))
{
COREWEBVIEW2_COLOR backgroundColor = {0, 0, 0, 0};
webviewController2FtbWnd->put_DefaultBackgroundColor(backgroundColor);
}
// Adjust to window size
RECT bounds;
GetClientRect(hwnd, &bounds);
webviewControllerFtbWnd->put_Bounds(bounds);
// State notifications can arrive before the controller exists or while
// NavigateToString is still loading. Only render after a successful
// navigation, then replay the complete cached state in one operation.
floatingToolbarNavigationReady = false;
EventRegistrationToken navigationCompletedToken{};
const HRESULT navigationCompletedResult = webviewFtbWnd->add_NavigationCompleted(
Microsoft::WRL::Callback<ICoreWebView2NavigationCompletedEventHandler>(
[](ICoreWebView2 *sender, ICoreWebView2NavigationCompletedEventArgs *args) -> HRESULT {
BOOL success = FALSE;
if (args)
{
args->get_IsSuccess(&success);
}
if (success)
{
NotifySmallWindowNavigationReady(floatingToolbarNavigationReady, L"floating-toolbar");
RenderFloatingToolbarState(sender);
ApplyConfiguredFloatingToolbarSize();
// The first apply runs before this controller exists, so a
// client that activated during startup left the toolbar
// hidden with no further trigger. Re-evaluate now that the
// toolbar can actually paint.
ApplyConfiguredFloatingToolbarVisibility();
}
else
{
(void)0;
}
return S_OK;
})
.Get(),
&navigationCompletedToken);
if (FAILED(navigationCompletedResult))
{
#ifdef FANY_DEBUG
(void)0;
#endif
return navigationCompletedResult;
}
// Navigate to HTML
HRESULT hr = webviewFtbWnd->NavigateToString(::HTMLStringFtbWnd.c_str());
if (FAILED(hr))
{
#ifdef FANY_DEBUG
(void)0;
#endif
return hr;
}
/* Debug console */
// webviewFtbWindow->OpenDevToolsWindow();
/* 处理 js 发过来的消息 */
webviewFtbWnd->add_WebMessageReceived(
Microsoft::WRL::Callback<ICoreWebView2WebMessageReceivedEventHandler>(
[hwnd](ICoreWebView2 *sender, ICoreWebView2WebMessageReceivedEventArgs *args) -> HRESULT {
wil::unique_cotaskmem_string message;
HRESULT hr = args->TryGetWebMessageAsString(&message);
if (SUCCEEDED(hr) && message.get())
{
std::wstring msg(message.get());
// 解析 msg，执行相应操作
json::value val = json::parse(wstring_to_string(msg));
std::string type = json::value_to<std::string>(val.at("type"));
/* 使 floating toolbar 窗口可拖动 */
if (type == "dragStart")
{
ReleaseCapture();
PostMessage(hwnd, WM_NCLBUTTONDOWN, HTCAPTION, 0);
}
else if (type == "changeIMEMode")
{
std::string mode = json::value_to<std::string>(val.at("data"));
if (mode == "cn") // Change to CN
{
#ifdef FANY_DEBUG
(void)0;
#endif
SendToTsfWorkerThreadViaNamedpipe(Global::DataFromServerMsgTypeToTsfWorkerThread::SwitchToCn,
L"");
}
else if (mode == "en") // Change to EN
{
#ifdef FANY_DEBUG
(void)0;
#endif
SendToTsfWorkerThreadViaNamedpipe(Global::DataFromServerMsgTypeToTsfWorkerThread::SwitchToEn,
L"");
}
}
else if (type == "changeCharMode")
{
std::string mode = json::value_to<std::string>(val.at("data"));
if (mode == "fullwidth")
{
#ifdef FANY_DEBUG
(void)0;
#endif
SendToTsfWorkerThreadViaNamedpipe(
Global::DataFromServerMsgTypeToTsfWorkerThread::SwitchToFullwidth, L"");
}
else if (mode == "halfwidth")
{
#ifdef FANY_DEBUG
(void)0;
#endif
SendToTsfWorkerThreadViaNamedpipe(
Global::DataFromServerMsgTypeToTsfWorkerThread::SwitchToHalfwidth, L"");
}
}
else if (type == "changePuncMode")
{
std::string mode = json::value_to<std::string>(val.at("data"));
if (mode == "puncEn")
{
#ifdef FANY_DEBUG
(void)0;
#endif
SendToTsfWorkerThreadViaNamedpipe(
Global::DataFromServerMsgTypeToTsfWorkerThread::SwitchToPuncEn, L"");
}
else if (mode == "puncCn")
{
#ifdef FANY_DEBUG
(void)0;
#endif
SendToTsfWorkerThreadViaNamedpipe(
Global::DataFromServerMsgTypeToTsfWorkerThread::SwitchToPuncCn, L"");
}
}
else if (type == "changeCharacterSet")
{
const std::string next = GetConfiguredCharacterSet() == "traditional"
? "simplified"
: "traditional";
if (SetConfiguredCharacterSet(next))
{
RenderFloatingToolbarState(sender);
FanyNamedPipe::EnqueueRefreshCandidatePageTask();
PostSettingsConfig();
}
}
else if (type == "openSettings")
{
#ifdef FANY_DEBUG
(void)0;
#endif
OpenSettingsApplication();
}
else if (type == "openEmojiPanel")
{
#ifdef FANY_DEBUG
(void)0;
#endif
OpenEmojiPanelApplication();
}
else if (type == "openKeyboardPanel")
{
OpenKeyboardPanelApplication();
}
}
return S_OK;
})
.Get(),
nullptr);
OnSmallWindowControllerSettled(S_OK);
return S_OK;
}
/**
* @brief Handle floating toolbar window webview2 environment creation
*
* @param hwnd
* @param result
* @param env
* @return HRESULT
*/
HRESULT OnFtbWindowEnvironmentCreated(HWND hwnd, HRESULT result, ICoreWebView2Environment *env)
{
if (FAILED(result) || !env)
{
#ifdef FANY_DEBUG
(void)0;
#endif
return result;
}
// Create WebView2 controller
return env->CreateCoreWebView2Controller( //
hwnd, //
Callback<ICoreWebView2CreateCoreWebView2ControllerCompletedHandler>( //
[hwnd](HRESULT result, ICoreWebView2Controller *controller) -> HRESULT { //
return OnControllerCreatedFtbWnd(hwnd, result, controller); //
}) //
.Get() //
); //
}
/**
* @brief Initialize the candidate, tray menu, and floating toolbar WebViews in
* one environment so they share a browser process and user data folder.
*/
void InitSmallWindowWebviews(HWND candHwnd, HWND menuHwnd, HWND ftbHwnd)
{
smallWindowCandHwnd = candHwnd;
smallWindowMenuHwnd = menuHwnd;
smallWindowFtbHwnd = ftbHwnd;
smallWindowInitAttempts = 0;
smallWindowInitState = SmallWindowInitState::Idle;
smallWindowControllerRequestInFlight = false;
currentSmallWindowHostIndex = -1;
lastFailedSmallWindowHostIndex = -1;
pendingTrayMenuShow = false;
BeginSmallWindowWebviewEnvironmentCreate();
}
bool PrepareTrayMenuWebviewForShow()
{
if (webviewControllerMenuWnd && menuNavigationReady)
{
return true;
}
pendingTrayMenuShow = true;
if (webviewControllerMenuWnd)
{
// Controller exists but nothing ever painted. An unreadable menu asset
// makes NavigateToString run on an empty string, which yields a blank
// document with no title (and therefore no visible WebView2 child entry).
if (::HTMLStringMenuWnd.empty())
{
PrepareHtmlForWnds();
}
if (webviewMenuWnd && !::HTMLStringMenuWnd.empty())
{
webviewMenuWnd->NavigateToString(::HTMLStringMenuWnd.c_str());
}
return false;
}
if (smallWindowInitState != SmallWindowInitState::InProgress)
{
// An explicit right-click is a fresh user intent: reset the attempt
// budget so a long-idle session can still recover the menu.
smallWindowInitAttempts = 0;
ScheduleSmallWindowWebviewRetry(200);
}
return false;
}
void ShutdownWebviews()
{
// WebView2 objects are apartment-bound. Release every controller and
// interface on the UI STA before WinMain balances CoInitializeEx.
ResetSmallWindowTopmostGate();
pendingTrayMenuShow = false;
smallWindowInitState = SmallWindowInitState::Idle;
smallWindowControllerRequestInFlight = false;
if (smallWindowCandHwnd)
{
KillTimer(smallWindowCandHwnd, kRetrySmallWindowWebviewTimerId);
}
if (webviewControllerCandWnd)
{
webviewControllerCandWnd->Close();
}
if (webviewControllerMenuWnd)
{
webviewControllerMenuWnd->Close();
}
if (webviewControllerFtbWnd)
{
webviewControllerFtbWnd->Close();
}
if (webviewControllerSettingsWnd)
{
webviewControllerSettingsWnd->Close();
}
webviewController2CandWnd.Reset();
webviewController2MenuWnd.Reset();
webviewController2FtbWnd.Reset();
webviewController2SettingsWnd.Reset();
webview3CandWnd.Reset();
webview3MenuWnd.Reset();
webview3FtbWnd.Reset();
webview3SettingsWnd.Reset();
webviewCandWnd.Reset();
webviewMenuWnd.Reset();
webviewFtbWnd.Reset();
webviewSettingsWnd.Reset();
webviewCompositionControllerSettingsWnd.Reset();
webviewControllerCandWnd.Reset();
webviewControllerMenuWnd.Reset();
webviewControllerFtbWnd.Reset();
webviewControllerSettingsWnd.Reset();
dcompRootVisualSettingsWnd.Reset();
dcompTargetSettingsWnd.Reset();
dcompDeviceSettingsWnd.Reset();
smallWindowWebviewEnvironment.Reset();
}
/**
* @brief 更新 floating toolbar 窗口的中英文切换状态
*
* @param webview
* @param cnEnState 1: 中文, 0: 英文
*/
void UpdateFtbCnEnState(ComPtr<ICoreWebView2> webview, int cnEnState)
{
if (UpdateBinaryState(cnEnState, floatingToolbarState.cn_en))
{
RenderFloatingToolbarState(webview.Get());
}
}
/**
* @brief 更新 floating toolbar 窗口的中英文切换状态和标点切换状态
*
* @param webview
* @param cnEnState 1: 中文, 0: 英文
* @param puncState 1: 中文标点, 0: 英文标点
*/
void UpdateFtbCnEnAndPuncState(ComPtr<ICoreWebView2> webview, int cnEnState, int puncState)
{
bool changed = UpdateBinaryState(cnEnState, floatingToolbarState.cn_en);
changed |= UpdateBinaryState(puncState, floatingToolbarState.punctuation);
if (changed)
{
RenderFloatingToolbarState(webview.Get());
}
}
/**
* @brief 更新 floating toolbar 窗口的中英文切换状态和标点切换状态
*
* @param webview
* @param cnEnState 1: 中文, 0: 英文
* @param doubleSingleByteState 1: 全角, 0: 半角
* @param puncState 1: 中文标点, 0: 英文标点
*/
void UpdateFtbCnEnAndDoubleSingleAndPuncState( //
ComPtr<ICoreWebView2> webview, //
int cnEnState, //
int doubleSingleByteState, //
int puncState //
)
{
bool changed = UpdateBinaryState(cnEnState, floatingToolbarState.cn_en);
changed |= UpdateBinaryState(doubleSingleByteState, floatingToolbarState.double_single_byte);
changed |= UpdateBinaryState(puncState, floatingToolbarState.punctuation);
if (changed)
{
RenderFloatingToolbarState(webview.Get());
}
}
/**
* @brief 更新 floating toolbar 窗口的标点切换状态
*
* @param webview
* @param puncState 1: 中文标点, 0: 英文标点
*/
void UpdateFtbPuncState(ComPtr<ICoreWebView2> webview, int puncState)
{
if (UpdateBinaryState(puncState, floatingToolbarState.punctuation))
{
RenderFloatingToolbarState(webview.Get());
}
}
/**
* @brief 更新 floating toolbar 窗口的全角和半角状态
*
* @param webview
* @param doubleSingleByteState 0: 半角, 1: 全角
*/
void UpdateFtbDoubleSingleByteState(ComPtr<ICoreWebView2> webview, int doubleSingleByteState)
{
if (UpdateBinaryState(doubleSingleByteState, floatingToolbarState.double_single_byte))
{
RenderFloatingToolbarState(webview.Get());
}
}
void UpdateFtbCharacterSetState(ComPtr<ICoreWebView2> webview)
{
RenderFloatingToolbarState(webview.Get());
}
void ApplyConfiguredFloatingToolbarItems()
{
RenderFloatingToolbarState(::webviewFtbWnd.Get());
ApplyConfiguredFloatingToolbarSize();
}
Reference in new issue View Git Blame Copy Permalink