1915 lines
83 KiB
C++
1915 lines
83 KiB
C++
#include "window/candidate_presenter.h"
|
||
|
||
#include "config/ime_config.h"
|
||
#include "defines/defines.h"
|
||
#include "defines/globals.h"
|
||
#include "global/globals.h"
|
||
#include "ipc/candidate_translation_policy.h"
|
||
#include "ipc/ipc.h"
|
||
#include "log/candidate_diag_log.h"
|
||
#include "skin/candidate_skin_catalog.h"
|
||
#include "window/candidate_skin_overlay.h"
|
||
#include "utils/common_utils.h"
|
||
#include "utils/ime_utils.h"
|
||
#include "utils/window_utils.h"
|
||
#include "webview2/windows_webview2.h"
|
||
#include "window/candidate_skin_palette.h"
|
||
#include "window/candidate_wheel_paging.h"
|
||
#include "window/ime_windows.h"
|
||
|
||
#include "msimeui/Controls.h"
|
||
#include "msimeui/DeviceResources.h"
|
||
#include "msimeui/Layout.h"
|
||
#include "msimeui/Scene.h"
|
||
#include "msimeui/Theme.h"
|
||
#include "msimeui/Window.h"
|
||
|
||
#include "engine/common/helpcode_utils.h"
|
||
#include "engine/core/scheme_type.h"
|
||
#include "engine/core/word_item.h"
|
||
|
||
#include <d2d1.h>
|
||
#include <dwmapi.h>
|
||
#include <windowsx.h>
|
||
|
||
#include <algorithm>
|
||
#include <atomic>
|
||
#include <cmath>
|
||
#include <cctype>
|
||
#include <filesystem>
|
||
#include <fstream>
|
||
#include <functional>
|
||
#include <optional>
|
||
#include <sstream>
|
||
#include <string>
|
||
#include <vector>
|
||
|
||
namespace
|
||
{
|
||
D2D1_COLOR_F ColorFromRgb(UINT rgb, float alpha = 1.0f)
|
||
{
|
||
return CandidateColorFromRgb(rgb, alpha);
|
||
}
|
||
|
||
D2D1_COLOR_F ParseCssColor(const std::string &text, D2D1_COLOR_F fallback)
|
||
{
|
||
return ParseCandidateCssColor(text, fallback);
|
||
}
|
||
|
||
int AlignHostPixels(int value)
|
||
{
|
||
constexpr int kBucket = 64;
|
||
if (value < 1)
|
||
{
|
||
value = 1;
|
||
}
|
||
return ((value + kBucket - 1) / kBucket) * kBucket;
|
||
}
|
||
|
||
// Recompute half-screen DIP limits against `scale` when it differs from the
|
||
// monitor-derived scale, so clamping and window sizing stay on one scale
|
||
// (mirrors the webview path's rasterization-scale composition).
|
||
HalfScreenDipLimits ApplyScaleToHalfScreenLimits(POINT pt, FLOAT scale)
|
||
{
|
||
HalfScreenDipLimits limits = QueryHalfScreenDipLimitsForPoint(pt);
|
||
if (scale > 0.0f)
|
||
{
|
||
const double monitorWidthPx = static_cast<double>((std::max)(1, limits.monitor.right - limits.monitor.left));
|
||
const double monitorHeightPx = static_cast<double>((std::max)(1, limits.monitor.bottom - limits.monitor.top));
|
||
limits.scale = scale;
|
||
limits.maxWidthDip = (monitorWidthPx * 0.5) / static_cast<double>(scale);
|
||
limits.maxHeightDip = (monitorHeightPx * 0.5) / static_cast<double>(scale);
|
||
}
|
||
return limits;
|
||
}
|
||
|
||
struct CandSkinTokens
|
||
{
|
||
D2D1_COLOR_F surface{};
|
||
D2D1_COLOR_F border{};
|
||
D2D1_COLOR_F text{};
|
||
D2D1_COLOR_F number = ParseCssColor("#e9e8e89d", ColorFromRgb(0xE9E8E8, 0.616f));
|
||
D2D1_COLOR_F selected = ParseCssColor("#3e3e3eb9", ColorFromRgb(0x3E3E3E, 0.725f));
|
||
D2D1_COLOR_F hover = ColorFromRgb(0x414141);
|
||
D2D1_COLOR_F accent = ColorFromRgb(0x6B69D6);
|
||
// Alpha 0: follow the candidate text at the CSS opacity .62 (see CandidateList::Appearance).
|
||
D2D1_COLOR_F translation = D2D1::ColorF(0, 0.0f);
|
||
float radius = 6.0f;
|
||
float borderWidth = 1.5f;
|
||
float containerPad = 5.0f;
|
||
bool showSelectedBar = true;
|
||
// Row corner radius, selected-row text colors and context-menu palette.
|
||
// Defaults are fluent dark; the fluent light branch and per-skin branches
|
||
// override. rowTextSelected/rowLabelSelected alpha 0 keeps the normal
|
||
// colors (bar-style selection, like the fluent CSS).
|
||
float itemRadius = 4.0f;
|
||
// > 0: rows touching the card's corners take this radius there instead.
|
||
float outerItemRadius = 0.0f;
|
||
// Row box geometry. Defaults suit the inset-highlight skins; full-bleed
|
||
// skins (willow green) pad the rows themselves because the card does not.
|
||
float itemGap = 2.0f;
|
||
float itemExtraHeight = 2.0f;
|
||
float itemPadLeft = 0.0f;
|
||
float itemPadRight = 0.0f;
|
||
// 横排时把卡片多出的宽度均分给同一行各项，铺满高亮的皮肤（杨柳青）末项才能贴到卡片右边。
|
||
bool justifyRows = false;
|
||
// 序号字号相对候选字号的比例、序号与候选之间的空、横排每项的最小宽度（0 为不限）。
|
||
float labelScale = 0.8f;
|
||
float labelGap = 1.5f;
|
||
float minItemWidth = 0.0f;
|
||
// 选中条的尺寸；selectedBarInside 让它落在高亮左缘之内，而不是骑在左缘上。
|
||
float selectedBarWidth = 3.0f;
|
||
float selectedBarHeightEm = 0.85f;
|
||
bool selectedBarInside = false;
|
||
// 翻页箭头画成候选文字色的实心三角（微软拼音那样），横排时前面再加一条分隔线。
|
||
bool trianglePager = false;
|
||
// 预编辑行隐藏时抵掉它与列表之间的 2px 行距，让卡片上下内边距一致。贴角皮肤总是这样做。
|
||
bool trimHiddenPreeditGap = false;
|
||
D2D1_COLOR_F pagerDivider = D2D1::ColorF(0, 0.0f);
|
||
msimeui::Thickness preeditMargin{};
|
||
D2D1_COLOR_F rowTextSelected = D2D1::ColorF(0, 0.0f);
|
||
D2D1_COLOR_F rowLabelSelected = D2D1::ColorF(0, 0.0f);
|
||
D2D1_COLOR_F menuFill = D2D1::ColorF(0x2D2D2D);
|
||
D2D1_COLOR_F menuBorder = ParseCssColor("#9b9b9b2e", D2D1::ColorF(0x3A3A3A, 0.18f));
|
||
D2D1_COLOR_F menuText = D2D1::ColorF(0xE9E8E8);
|
||
D2D1_COLOR_F menuHover = ColorFromRgb(0x414141);
|
||
// 外部皮肤的细分配色。alpha 0 表示没写：光标与选中条跟 accent，选中行翻译跟 translation，
|
||
// 预编辑背景与分隔线不画。
|
||
D2D1_COLOR_F preeditCaret = D2D1::ColorF(0, 0.0f);
|
||
D2D1_COLOR_F selectedBar = D2D1::ColorF(0, 0.0f);
|
||
D2D1_COLOR_F rowTranslationSelected = D2D1::ColorF(0, 0.0f);
|
||
// 翻译里的词性与分隔符。alpha 0 表示与本行翻译同色。
|
||
D2D1_COLOR_F translationPos = D2D1::ColorF(0, 0.0f);
|
||
D2D1_COLOR_F translationSeparator = D2D1::ColorF(0, 0.0f);
|
||
D2D1_COLOR_F rowTranslationPosSelected = D2D1::ColorF(0, 0.0f);
|
||
D2D1_COLOR_F rowTranslationSeparatorSelected = D2D1::ColorF(0, 0.0f);
|
||
D2D1_COLOR_F preeditBackground = D2D1::ColorF(0, 0.0f);
|
||
D2D1_COLOR_F preeditDivider = D2D1::ColorF(0, 0.0f);
|
||
};
|
||
|
||
// 内置皮肤翻译里词性与分隔符的不透明度，对应 CSS 里 8 位十六进制颜色的 99 与 73。
|
||
constexpr float kTranslationPosAlpha = 0x80 / 255.0f;
|
||
constexpr float kTranslationSeparatorAlpha = 0x73 / 255.0f;
|
||
|
||
// 内置皮肤的翻译配色取自 Notion 调色板（https://docs.super.so/notion-colors），与
|
||
// ui-html/webview2/candwnd/skins/<skin>/*.css 里的 .cand-translation 同值。词性用相邻的另一个色相再调淡，
|
||
// 和英文单词区分开；分隔符是单词色降不透明度。
|
||
void SetTranslationColors(CandSkinTokens &tokens, UINT rgb, UINT posRgb)
|
||
{
|
||
tokens.translation = ColorFromRgb(rgb);
|
||
tokens.translationPos = ColorFromRgb(posRgb, kTranslationPosAlpha);
|
||
tokens.translationSeparator = ColorFromRgb(rgb, kTranslationSeparatorAlpha);
|
||
}
|
||
|
||
// 选中行铺了实色高亮的皮肤，翻译在选中行另换一组颜色，避免彩色字压在高亮色上。
|
||
// 词性的不透明度单独给：实色高亮上按普通行的比例调淡会糊进底色。
|
||
void SetSelectedTranslationColors(CandSkinTokens &tokens, UINT rgb, float alpha, UINT posRgb, float posAlpha)
|
||
{
|
||
tokens.rowTranslationSelected = ColorFromRgb(rgb, alpha);
|
||
tokens.rowTranslationPosSelected = ColorFromRgb(posRgb, posAlpha);
|
||
tokens.rowTranslationSeparatorSelected = ColorFromRgb(rgb, alpha * kTranslationSeparatorAlpha);
|
||
}
|
||
|
||
// 皮肤阴影档位只缩放两层阴影的不透明度，几何不变；none 由调用方直接关掉阴影。
|
||
float ShadowAlphaScale(const std::string &shadow)
|
||
{
|
||
if (shadow == "soft")
|
||
return 0.5f;
|
||
if (shadow == "strong")
|
||
return 1.6f;
|
||
return 1.0f;
|
||
}
|
||
|
||
void ApplyPackageColors(const CandidateSkinCatalog::CandidateColors &colors, CandSkinTokens &tokens)
|
||
{
|
||
const auto apply = [](const std::string &value, D2D1_COLOR_F &out) {
|
||
if (!value.empty())
|
||
out = ParseCssColor(value, out);
|
||
};
|
||
apply(colors.preeditCaret, tokens.preeditCaret);
|
||
apply(colors.selectedBar, tokens.selectedBar);
|
||
apply(colors.selectedText, tokens.rowTextSelected);
|
||
apply(colors.selectedNumber, tokens.rowLabelSelected);
|
||
// 包换了翻译色就不再用基础皮肤的词性/分隔符配色：普通行回到与翻译同色，选中行跟随 selected_translation。
|
||
// 与 WebView2 端的 `color: inherit` 重置一致。
|
||
if (!colors.translation.empty())
|
||
{
|
||
tokens.translationPos = D2D1::ColorF(0, 0.0f);
|
||
tokens.translationSeparator = D2D1::ColorF(0, 0.0f);
|
||
}
|
||
if (!colors.selectedTranslation.empty())
|
||
{
|
||
apply(colors.selectedTranslation, tokens.rowTranslationSelected);
|
||
tokens.rowTranslationPosSelected = tokens.rowTranslationSelected;
|
||
tokens.rowTranslationSeparatorSelected = tokens.rowTranslationSelected;
|
||
}
|
||
apply(colors.translationPos, tokens.translationPos);
|
||
apply(colors.translationSeparator, tokens.translationSeparator);
|
||
apply(colors.selectedTranslationPos, tokens.rowTranslationPosSelected);
|
||
apply(colors.selectedTranslationSeparator, tokens.rowTranslationSeparatorSelected);
|
||
apply(colors.preeditBackground, tokens.preeditBackground);
|
||
apply(colors.preeditDivider, tokens.preeditDivider);
|
||
apply(colors.menuBackground, tokens.menuFill);
|
||
apply(colors.menuBorder, tokens.menuBorder);
|
||
apply(colors.menuText, tokens.menuText);
|
||
apply(colors.menuHover, tokens.menuHover);
|
||
if (!colors.accent.empty())
|
||
{
|
||
tokens.accent = ParseCssColor(colors.accent, tokens.accent);
|
||
}
|
||
if (!colors.selected.empty())
|
||
{
|
||
tokens.selected = ParseCssColor(colors.selected, tokens.selected);
|
||
}
|
||
if (!colors.hover.empty())
|
||
{
|
||
tokens.hover = ParseCssColor(colors.hover, tokens.hover);
|
||
}
|
||
if (!colors.number.empty())
|
||
{
|
||
tokens.number = ParseCssColor(colors.number, tokens.number);
|
||
}
|
||
if (!colors.translation.empty())
|
||
{
|
||
tokens.translation = ParseCssColor(colors.translation, tokens.translation);
|
||
}
|
||
if (colors.showSelectedBar.has_value())
|
||
{
|
||
tokens.showSelectedBar = *colors.showSelectedBar;
|
||
}
|
||
}
|
||
|
||
std::wstring AssetRoot()
|
||
{
|
||
return CommonUtils::get_ime_data_path_w();
|
||
}
|
||
|
||
constexpr float kShadowPadLeft = 32.0f;
|
||
constexpr float kShadowPadTop = 20.0f;
|
||
constexpr float kShadowPadRight = 32.0f;
|
||
constexpr float kShadowPadBottom = 40.0f;
|
||
constexpr float kCandidateMinWidthDip = 160.0f;
|
||
|
||
msimeui::ImageStretch BackgroundStretch(const std::string &fit)
|
||
{
|
||
if (fit == "contain")
|
||
return msimeui::ImageStretch::Uniform;
|
||
if (fit == "stretch")
|
||
return msimeui::ImageStretch::Fill;
|
||
return msimeui::ImageStretch::UniformToFill;
|
||
}
|
||
|
||
msimeui::HorizontalAlignment DecorationAlignment(const std::string &align)
|
||
{
|
||
if (align == "left")
|
||
return msimeui::HorizontalAlignment::Leading;
|
||
if (align == "center")
|
||
return msimeui::HorizontalAlignment::Center;
|
||
return msimeui::HorizontalAlignment::Trailing;
|
||
}
|
||
// Below this fraction of the kept extent, the page really got smaller (fewer or
|
||
// shorter candidates) and the card follows it; above it, the difference is a
|
||
// late addition coming or going and the card keeps its size. Mirrors
|
||
// kStickyShrinkRatio in the WebView2 candidate script.
|
||
constexpr float kStickyCardShrinkRatio = 0.7f;
|
||
|
||
float StickyCardExtent(float kept, float natural)
|
||
{
|
||
return natural >= kept || natural < kept * kStickyCardShrinkRatio ? natural : kept;
|
||
}
|
||
|
||
// 横排且皮肤开了翻页箭头时的候选行：列表占去箭头以外的全部宽度，箭头贴在最右侧，
|
||
// 相当于在候选右边多出一列窄列；箭头的竖直位置由它自己的外边距对齐到最后一行。
|
||
class CandidateRowWithPager : public msimeui::Panel
|
||
{
|
||
public:
|
||
CandidateRowWithPager(std::shared_ptr<msimeui::Visual> list, std::shared_ptr<msimeui::Visual> pager)
|
||
: list_(list.get()), pager_(pager.get())
|
||
{
|
||
AddChild(std::move(list));
|
||
AddChild(std::move(pager));
|
||
}
|
||
|
||
msimeui::SizeF Measure(const msimeui::SizeF &availableSize) override
|
||
{
|
||
const msimeui::SizeF pager = pager_->MeasureInLayout(availableSize);
|
||
const msimeui::SizeF list =
|
||
list_->MeasureInLayout({(std::max)(availableSize.width - pager.width, 1.0f), availableSize.height});
|
||
pagerWidth_ = pager.width;
|
||
return {list.width + pager.width, (std::max)(list.height, pager.height)};
|
||
}
|
||
|
||
void Arrange(const msimeui::RectF &finalRect) override
|
||
{
|
||
bounds_ = finalRect;
|
||
const float listWidth = (std::max)(finalRect.width - pagerWidth_, 0.0f);
|
||
list_->ArrangeInLayout({finalRect.x, finalRect.y, listWidth, finalRect.height});
|
||
pager_->ArrangeInLayout({finalRect.x + listWidth, finalRect.y, pagerWidth_, finalRect.height});
|
||
}
|
||
|
||
void Render(msimeui::DeviceResources &deviceResources) override
|
||
{
|
||
for (const auto &child : children_)
|
||
{
|
||
child->Render(deviceResources);
|
||
}
|
||
}
|
||
|
||
private:
|
||
msimeui::Visual *list_ = nullptr;
|
||
msimeui::Visual *pager_ = nullptr;
|
||
float pagerWidth_ = 0.0f;
|
||
};
|
||
|
||
D2D1_COLOR_F WithAlpha(D2D1_COLOR_F color, float alpha)
|
||
{
|
||
color.a *= alpha;
|
||
return color;
|
||
}
|
||
|
||
} // namespace
|
||
|
||
struct CandidatePresenter::Impl
|
||
{
|
||
msimeui::DeviceResources resources;
|
||
std::unique_ptr<msimeui::Window> window;
|
||
std::shared_ptr<msimeui::StackPanel> root;
|
||
std::shared_ptr<msimeui::Image> decoration;
|
||
std::shared_ptr<msimeui::Card> card;
|
||
// 卡片与 v2 挂件层放在同一格里：挂件层测量为 0，格子仍由卡片决定，挂件按 anchor 画到卡片外沿。
|
||
std::shared_ptr<msimeui::Grid> overlayGrid;
|
||
std::shared_ptr<CandidateSkinOverlay> skinOverlay;
|
||
// 装饰图与卡片同列：列宽即卡片宽，装饰图在列内按 align 对齐，对应 CSS 里
|
||
// .containerParent 为 fit-content、::before 相对它定位。
|
||
std::shared_ptr<msimeui::StackPanel> cardColumn;
|
||
std::shared_ptr<msimeui::Container> frame;
|
||
std::shared_ptr<msimeui::StackPanel> body;
|
||
std::shared_ptr<msimeui::TextBlock> preedit;
|
||
std::shared_ptr<msimeui::CandidateList> list;
|
||
// 皮肤关掉翻页箭头时为空。场景按 sceneHorizontal / scenePageArrows 搭建，两者变了就重建。
|
||
std::shared_ptr<msimeui::PagerArrows> pager;
|
||
bool sceneHorizontal = false;
|
||
bool scenePageArrows = false;
|
||
std::shared_ptr<msimeui::Popup> contextMenu;
|
||
std::shared_ptr<msimeui::Popup> contextSubmenu;
|
||
std::shared_ptr<msimeui::MenuFlyoutItem> fixPositionItem;
|
||
D2D1_COLOR_F menuFill = D2D1::ColorF(0x2D2D2D);
|
||
D2D1_COLOR_F menuBorder = ParseCssColor("#9b9b9b2e", D2D1::ColorF(0x3A3A3A, 0.18f));
|
||
D2D1_COLOR_F menuText = D2D1::ColorF(0xE9E8E8);
|
||
D2D1_COLOR_F menuHover = D2D1::ColorF(0x414141);
|
||
RECT hostRectBeforeMenu{};
|
||
bool contextMenuOpen = false;
|
||
bool contextSubmenuOpen = false;
|
||
bool hostExpandedForMenu = false;
|
||
size_t contextMenuPageIndex = 0;
|
||
};
|
||
|
||
CandidatePresenter::CandidatePresenter() = default;
|
||
|
||
CandidatePresenter &CandidatePresenter::Instance()
|
||
{
|
||
static CandidatePresenter instance;
|
||
return instance;
|
||
}
|
||
|
||
bool CandidatePresenter::IsBound() const
|
||
{
|
||
return bound_;
|
||
}
|
||
|
||
bool CandidatePresenter::Bind(HWND hwnd)
|
||
{
|
||
hwnd_ = hwnd;
|
||
if (!hwnd)
|
||
{
|
||
bound_ = false;
|
||
impl_.reset();
|
||
return false;
|
||
}
|
||
impl_ = std::make_unique<Impl>();
|
||
impl_->window = std::make_unique<msimeui::Window>(L"metasequoiaime_windows", L"cand", 1, 1);
|
||
impl_->window->AdoptExistingHwnd(hwnd);
|
||
impl_->window->SetStealFocusOnClick(false);
|
||
bound_ = impl_->resources.EnsureForComposition(hwnd);
|
||
RebuildScene();
|
||
CAND_DIAG_LOGF(L"candidate-d2d bind hwnd={:#x} composition={}", reinterpret_cast<uintptr_t>(hwnd), bound_ ? 1 : 0);
|
||
return bound_;
|
||
}
|
||
|
||
void CandidatePresenter::RebuildScene()
|
||
{
|
||
if (!impl_ || !impl_->window)
|
||
{
|
||
return;
|
||
}
|
||
lastSkinFingerprint_.clear();
|
||
impl_->root = std::make_shared<msimeui::StackPanel>(0.0f);
|
||
impl_->decoration = std::make_shared<msimeui::Image>(L"");
|
||
impl_->decoration->SetHorizontalAlignment(msimeui::HorizontalAlignment::Trailing);
|
||
impl_->decoration->SetStretch(msimeui::ImageStretch::Uniform);
|
||
impl_->preedit = std::make_shared<msimeui::TextBlock>(L"", 14.0f, D2D1::ColorF(0xF5F5F5));
|
||
impl_->preedit->SetTextLayoutPadding({0.0f, 1.0f, 0.0f, 1.0f});
|
||
impl_->preedit->SetHorizontalAlignment(msimeui::HorizontalAlignment::Leading);
|
||
impl_->list = std::make_shared<msimeui::CandidateList>(28.0f);
|
||
impl_->list->SetOnItemActivated([this](size_t index) { CommitItem(index); });
|
||
impl_->list->SetOnContextMenu(
|
||
[this](size_t index, const POINT &clientPoint) { ShowItemContextMenu(index, clientPoint); });
|
||
impl_->body = std::make_shared<msimeui::StackPanel>(2.0f);
|
||
impl_->body->SetPadding({0.0f, 0.0f, 0.0f, 0.0f});
|
||
impl_->body->AddChild(impl_->preedit);
|
||
impl_->pager.reset();
|
||
if (impl_->scenePageArrows)
|
||
{
|
||
impl_->pager = std::make_shared<msimeui::PagerArrows>();
|
||
// 箭头在自己的槽位里贴右下角，槽位铺满即可（竖排是整行宽，横排是列表的整个高度）。
|
||
impl_->pager->SetVerticalAlignment(msimeui::VerticalAlignment::Stretch);
|
||
impl_->pager->SetOnClick([this](msimeui::PagerArrows::Part part) {
|
||
if (hwnd_)
|
||
{
|
||
PostMessageW(hwnd_, WM_PAGE_CANDIDATE_ARROW,
|
||
part == msimeui::PagerArrows::Part::Next ? CANDIDATE_PAGE_NEXT : CANDIDATE_PAGE_PREVIOUS,
|
||
1);
|
||
}
|
||
});
|
||
}
|
||
if (impl_->pager && impl_->sceneHorizontal)
|
||
{
|
||
impl_->body->AddChild(std::make_shared<CandidateRowWithPager>(impl_->list, impl_->pager));
|
||
}
|
||
else
|
||
{
|
||
// 竖排时箭头是列表下方单独的一矮行，靠右。
|
||
impl_->body->AddChild(impl_->list);
|
||
if (impl_->pager)
|
||
impl_->body->AddChild(impl_->pager);
|
||
}
|
||
msimeui::Brush brush;
|
||
brush.fill = D2D1::ColorF(0x202020);
|
||
brush.stroke = ParseCssColor("#9b9b9b2e", D2D1::ColorF(0x3A3A3A, 0.18f));
|
||
brush.strokeWidth = 1.5f;
|
||
brush.radiusX = 6.0f;
|
||
brush.radiusY = 6.0f;
|
||
impl_->card = std::make_shared<msimeui::Card>(brush, 5.0f);
|
||
impl_->card->SetHorizontalAlignment(msimeui::HorizontalAlignment::Leading);
|
||
impl_->card->AddChild(impl_->body);
|
||
impl_->root->SetHorizontalContentAlignment(msimeui::HorizontalAlignment::Leading);
|
||
impl_->overlayGrid = std::make_shared<msimeui::Grid>();
|
||
impl_->overlayGrid->AddRow(msimeui::GridLength{msimeui::GridUnitType::Auto, 1.0f});
|
||
impl_->overlayGrid->AddColumn(msimeui::GridLength{msimeui::GridUnitType::Auto, 1.0f});
|
||
impl_->overlayGrid->AddChild(impl_->card, 0, 0);
|
||
impl_->skinOverlay = std::make_shared<CandidateSkinOverlay>();
|
||
impl_->skinOverlay->SetHorizontalAlignment(msimeui::HorizontalAlignment::Stretch);
|
||
impl_->skinOverlay->SetVerticalAlignment(msimeui::VerticalAlignment::Stretch);
|
||
impl_->overlayGrid->AddChild(impl_->skinOverlay, 0, 0);
|
||
impl_->cardColumn = std::make_shared<msimeui::StackPanel>(0.0f);
|
||
impl_->cardColumn->SetHorizontalAlignment(msimeui::HorizontalAlignment::Leading);
|
||
impl_->cardColumn->SetHorizontalContentAlignment(msimeui::HorizontalAlignment::Stretch);
|
||
impl_->cardColumn->AddChild(impl_->decoration);
|
||
impl_->cardColumn->AddChild(impl_->overlayGrid);
|
||
impl_->frame = std::make_shared<msimeui::Container>();
|
||
impl_->frame->SetPadding({kShadowPadLeft, kShadowPadTop, kShadowPadRight, kShadowPadBottom});
|
||
impl_->frame->SetChild(impl_->cardColumn);
|
||
impl_->root->AddChild(impl_->frame);
|
||
auto scene = std::make_unique<msimeui::Scene>();
|
||
scene->SetRoot(impl_->root);
|
||
impl_->window->SetScene(std::move(scene));
|
||
}
|
||
|
||
void CandidatePresenter::ApplySkin()
|
||
{
|
||
if (!impl_ || !impl_->list || !impl_->preedit || !impl_->window)
|
||
{
|
||
return;
|
||
}
|
||
const std::string skinId = GetConfiguredCandidateSkin();
|
||
// Resolve the effective light/dark mode before the cache check: with
|
||
// theme_cand = "follow" the raw setting is unchanged when theme_mode or
|
||
// the Windows theme flips, but the resolved colors are what we render
|
||
// with, so the resolved mode must participate in the fingerprint.
|
||
const bool candLight = ResolveConfiguredTheme(GetConfiguredThemeCand()) == "light";
|
||
std::ostringstream fingerprint;
|
||
fingerprint << skinId << '|' << GetConfiguredThemeCand() << '|' << (candLight ? 'L' : 'D') << '|'
|
||
<< GetConfiguredCandidateFont() << '|' << GetConfiguredCandidateFontSize() << '|'
|
||
<< GetConfiguredCandidateWindowPreeditFontSize() << '|' << GetConfiguredCandidateWindowLayout() << '|'
|
||
<< GetConfiguredCandidateTextColor() << '|' << GetConfiguredCandidateWindowPreeditStyle();
|
||
fingerprint << '|' << GetConfiguredCandidateEnglishFont() << '|' << GetConfiguredCandidateWindowFitContent();
|
||
// 同一个外部皮肤的 skin.toml 或图片改了，只有强制重载能看出来；带上重载代数让 D2D 也重读 manifest。
|
||
fingerprint << '|' << GetCandidateSkinReloadRevision();
|
||
for (const auto &font : GetConfiguredCandidateFallbackFonts())
|
||
fingerprint << '|' << font.size() << ':' << font;
|
||
const std::string skinKey = fingerprint.str();
|
||
if (skinKey == lastSkinFingerprint_ && impl_->card)
|
||
{
|
||
return;
|
||
}
|
||
lastSkinFingerprint_ = skinKey;
|
||
CandSkinTokens tokens;
|
||
if (candLight)
|
||
{
|
||
tokens.number = D2D1::ColorF(26.0f / 255.0f, 26.0f / 255.0f, 26.0f / 255.0f, 0.55f);
|
||
tokens.selected = ColorFromRgb(0xE8E8E8);
|
||
tokens.hover = ColorFromRgb(0xECECEC);
|
||
tokens.menuFill = ColorFromRgb(0xFFFFFF);
|
||
tokens.menuBorder = D2D1::ColorF(0, 0.12f);
|
||
tokens.menuText = ColorFromRgb(0x1A1A1A);
|
||
tokens.menuHover = ColorFromRgb(0xECECEC);
|
||
}
|
||
const std::wstring skinsRoot = AssetRoot() + L"\\skins";
|
||
std::optional<CandidateSkinCatalog::Package> package;
|
||
if (!CandidateSkinCatalog::IsBuiltIn(skinId))
|
||
{
|
||
package = CandidateSkinCatalog::Load(std::filesystem::path(skinsRoot), skinId);
|
||
}
|
||
// 自定义包的几何取自它的 base 皮肤，与 WebView2 端注入 base 皮肤 CSS 一致；颜色随后由包覆盖。
|
||
const std::string baseSkin = package ? package->base : skinId;
|
||
// Built-in skin palettes mirror ui-html/webview2/candwnd/skins/<skin>/;
|
||
// the WebView2 CSS is the reference for both the light and dark values.
|
||
// 横排时高亮内缩于外框，首项、尾项落在卡片四角上的那几个角与卡片同 R，其余角保持
|
||
// itemRadius，对应 CSS 横排的 .pinyin + .row-wrapper / .last-visible 规则。
|
||
const bool horizontalLayout = GetConfiguredCandidateWindowLayout() == "horizontal";
|
||
// 翻页箭头改变的是场景结构（竖排多一行、横排多一列），开关或排列方式变了就整棵重建，
|
||
// 再往下套用配色与尺寸。重建会清掉指纹，这里补回去。
|
||
const bool pageArrows = CandidateSkinCatalog::ResolvePageArrows(std::filesystem::path(skinsRoot), skinId,
|
||
package ? &*package : nullptr);
|
||
if (pageArrows != impl_->scenePageArrows || horizontalLayout != impl_->sceneHorizontal)
|
||
{
|
||
impl_->scenePageArrows = pageArrows;
|
||
impl_->sceneHorizontal = horizontalLayout;
|
||
RebuildScene();
|
||
lastSkinFingerprint_ = skinKey;
|
||
}
|
||
fitContent_ = GetConfiguredCandidateWindowFitContent() ||
|
||
CandidateSkinCatalog::ResolveFitContent(std::filesystem::path(skinsRoot), skinId,
|
||
package ? &*package : nullptr);
|
||
const float fontSize = static_cast<float>((std::max)(12, GetConfiguredCandidateFontSize()));
|
||
if (baseSkin == "fluent")
|
||
{
|
||
if (horizontalLayout)
|
||
tokens.outerItemRadius = tokens.radius;
|
||
// 单词 Notion Purple，与强调色同一色相；词性 Notion Pink。
|
||
SetTranslationColors(tokens, candLight ? 0x6940A5 : 0x9A6DD7, candLight ? 0xAD1A72 : 0xE255A1);
|
||
}
|
||
else if (baseSkin == "wechat")
|
||
{
|
||
tokens.borderWidth = 1.0f;
|
||
tokens.radius = 5.0f;
|
||
tokens.containerPad = 2.0f;
|
||
if (horizontalLayout)
|
||
tokens.outerItemRadius = tokens.radius;
|
||
tokens.accent = ColorFromRgb(0x07C160);
|
||
tokens.selected = ColorFromRgb(0x07C160);
|
||
tokens.showSelectedBar = false;
|
||
tokens.rowTextSelected = ColorFromRgb(0xFFFFFF);
|
||
tokens.rowLabelSelected = ColorFromRgb(0xFFFFFF);
|
||
// 单词 Notion Blue，词性 Notion Green；选中行是实色绿底，单词换成半透明白，词性换 Notion Yellow。
|
||
SetTranslationColors(tokens, candLight ? 0x0B6E99 : 0x529CCA, candLight ? 0x0F7B6C : 0x4DAB9A);
|
||
SetSelectedTranslationColors(tokens, 0xFFFFFF, 0.8f, 0xFFDC49, 0.85f);
|
||
if (candLight)
|
||
{
|
||
tokens.hover = D2D1::ColorF(7.0f / 255.0f, 193.0f / 255.0f, 96.0f / 255.0f, 0.14f);
|
||
tokens.number = ColorFromRgb(0x757575);
|
||
tokens.menuFill = ColorFromRgb(0xFFFFFF);
|
||
tokens.menuBorder = ColorFromRgb(0xD9D9D9);
|
||
tokens.menuText = ColorFromRgb(0x333333);
|
||
tokens.menuHover = ColorFromRgb(0xEEEEEE);
|
||
}
|
||
else
|
||
{
|
||
tokens.hover = D2D1::ColorF(7.0f / 255.0f, 193.0f / 255.0f, 96.0f / 255.0f, 0.32f);
|
||
tokens.number = ColorFromRgb(0x858585);
|
||
tokens.menuFill = ColorFromRgb(0x1F1F1F);
|
||
tokens.menuBorder = ColorFromRgb(0x343434);
|
||
tokens.menuText = ColorFromRgb(0xD0D0D0);
|
||
tokens.menuHover = ColorFromRgb(0x2A2A2A);
|
||
}
|
||
}
|
||
else if (baseSkin == "willow_green")
|
||
{
|
||
tokens.borderWidth = 0.0f;
|
||
tokens.radius = 9.0f;
|
||
tokens.containerPad = 0.0f;
|
||
// 高亮整行（竖排）/整列（横排）铺满、左右贴着卡片边，行本身是直角；CSS 靠
|
||
// 容器 clip-path 裁出窗口圆角。D2D 的 Card 不裁剪子控件，所以改由列表把
|
||
// 落在卡片四角上的那几个角画成卡片的 9px，其余角保持直角。
|
||
tokens.itemRadius = 0.0f;
|
||
tokens.outerItemRadius = 9.0f;
|
||
tokens.itemGap = 0.0f;
|
||
tokens.justifyRows = true;
|
||
// 行内边距对齐 CSS 的 .row.cand padding（加上 .text 的左内边距），预编辑行对齐 .row.pinyin。
|
||
if (GetConfiguredCandidateWindowLayout() == "horizontal")
|
||
{
|
||
tokens.itemExtraHeight = 10.0f;
|
||
tokens.itemPadLeft = 6.0f;
|
||
tokens.itemPadRight = 10.0f;
|
||
tokens.preeditMargin = {3.0f, 6.0f, 5.0f, 1.0f};
|
||
}
|
||
else
|
||
{
|
||
tokens.itemExtraHeight = 8.0f;
|
||
tokens.itemPadLeft = 9.0f;
|
||
tokens.itemPadRight = 14.0f;
|
||
tokens.preeditMargin = {3.0f, 6.0f, 7.0f, 2.0f};
|
||
}
|
||
tokens.showSelectedBar = false;
|
||
tokens.rowTextSelected = ColorFromRgb(0xFFFFFF);
|
||
tokens.rowLabelSelected = ColorFromRgb(0xFFFFFF);
|
||
// 单词 Notion Green，词性 Notion Blue；选中行是实色绿底，单词换成半透明白，词性换 Notion Yellow。
|
||
SetTranslationColors(tokens, candLight ? 0x0F7B6C : 0x4DAB9A, candLight ? 0x0B6E99 : 0x529CCA);
|
||
SetSelectedTranslationColors(tokens, 0xFFFFFF, 0.8f, 0xFFDC49, 0.85f);
|
||
if (candLight)
|
||
{
|
||
tokens.accent = ColorFromRgb(0x58B980);
|
||
tokens.selected = ColorFromRgb(0x58B980);
|
||
tokens.hover = D2D1::ColorF(88.0f / 255.0f, 185.0f / 255.0f, 128.0f / 255.0f, 0.16f);
|
||
tokens.number = ColorFromRgb(0x686F6A);
|
||
tokens.menuFill = ColorFromRgb(0xFBFCFA);
|
||
tokens.menuBorder = ColorFromRgb(0xD8DED9);
|
||
tokens.menuText = ColorFromRgb(0x343936);
|
||
tokens.menuHover = ColorFromRgb(0xE9EEEA);
|
||
}
|
||
else
|
||
{
|
||
tokens.accent = ColorFromRgb(0x65C98D);
|
||
tokens.selected = ColorFromRgb(0x65C98D);
|
||
tokens.hover = D2D1::ColorF(101.0f / 255.0f, 201.0f / 255.0f, 141.0f / 255.0f, 0.22f);
|
||
tokens.number = ColorFromRgb(0xA6ABA7);
|
||
tokens.menuFill = ColorFromRgb(0x343635);
|
||
tokens.menuBorder = ColorFromRgb(0x454845);
|
||
tokens.menuText = ColorFromRgb(0xE0E2DF);
|
||
tokens.menuHover = ColorFromRgb(0x414441);
|
||
}
|
||
}
|
||
else if (baseSkin == "graphite")
|
||
{
|
||
tokens.borderWidth = 1.0f;
|
||
tokens.radius = 3.0f;
|
||
tokens.containerPad = 5.0f;
|
||
tokens.itemRadius = 2.0f;
|
||
tokens.selected = D2D1::ColorF(0, 0.0f);
|
||
tokens.showSelectedBar = false;
|
||
// 单词 Notion Brown，石墨铅笔的木杆色，压在冷灰底上不抢候选；词性 Notion Orange。
|
||
SetTranslationColors(tokens, candLight ? 0x64473A : 0x937264, candLight ? 0xD9730D : 0xFFA344);
|
||
if (candLight)
|
||
{
|
||
tokens.accent = ColorFromRgb(0x5F6B7A);
|
||
tokens.hover = D2D1::ColorF(31.0f / 255.0f, 41.0f / 255.0f, 55.0f / 255.0f, 0.055f);
|
||
tokens.number = ColorFromRgb(0x8993A1);
|
||
tokens.rowTextSelected = ColorFromRgb(0x111827);
|
||
tokens.rowLabelSelected = ColorFromRgb(0x111827);
|
||
tokens.menuFill = ColorFromRgb(0xFFFFFF);
|
||
tokens.menuBorder = ColorFromRgb(0xDFE3E8);
|
||
tokens.menuText = ColorFromRgb(0x374151);
|
||
tokens.menuHover = ColorFromRgb(0xF1F3F5);
|
||
}
|
||
else
|
||
{
|
||
tokens.accent = ColorFromRgb(0x8993A0);
|
||
tokens.hover = D2D1::ColorF(1.0f, 1.0f, 1.0f, 0.055f);
|
||
tokens.number = ColorFromRgb(0x707987);
|
||
tokens.rowTextSelected = ColorFromRgb(0xF1F3F5);
|
||
tokens.rowLabelSelected = ColorFromRgb(0xF1F3F5);
|
||
tokens.menuFill = ColorFromRgb(0x23272C);
|
||
tokens.menuBorder = ColorFromRgb(0x3A4047);
|
||
tokens.menuText = ColorFromRgb(0xC7CDD5);
|
||
tokens.menuHover = ColorFromRgb(0x30353B);
|
||
}
|
||
}
|
||
else if (baseSkin == "autumn_osmanthus")
|
||
{
|
||
tokens.borderWidth = 0.0f;
|
||
tokens.radius = 10.0f;
|
||
tokens.containerPad = 5.0f;
|
||
// 高亮块内缩在卡片里：普通角 6px，贴着卡片四角的那几个角与卡片同为 10px
|
||
// （首项顶部两角、尾项底部两角），对应 CSS 的 --ao-radius / --ao-item-radius。
|
||
tokens.itemRadius = 6.0f;
|
||
tokens.outerItemRadius = 10.0f;
|
||
tokens.showSelectedBar = false;
|
||
// 翻译：浅色单词 Notion Orange、词性 Notion Red，选中行的淡黄高亮上单词换 Notion Brown；
|
||
// 深色单词 Notion Yellow、词性 Notion Orange，选中行橙底上单词换半透明白、词性换 Notion Brown。
|
||
if (candLight)
|
||
{
|
||
SetTranslationColors(tokens, 0xD9730D, 0xE03E3E);
|
||
SetSelectedTranslationColors(tokens, 0x64473A, 1.0f, 0xE03E3E, kTranslationPosAlpha);
|
||
tokens.accent = ColorFromRgb(0xE6A817);
|
||
tokens.selected = ColorFromRgb(0xFFE399);
|
||
tokens.hover = D2D1::ColorF(255.0f / 255.0f, 227.0f / 255.0f, 153.0f / 255.0f, 0.55f);
|
||
tokens.number = ColorFromRgb(0x5B727B);
|
||
tokens.rowTextSelected = ColorFromRgb(0x1A1A1A);
|
||
tokens.rowLabelSelected = ColorFromRgb(0x1A1A1A);
|
||
tokens.menuFill = ColorFromRgb(0xE8F5F7);
|
||
tokens.menuBorder = ColorFromRgb(0xBCD8DE);
|
||
tokens.menuText = ColorFromRgb(0x1F3138);
|
||
tokens.menuHover = ColorFromRgb(0xD2E8EC);
|
||
}
|
||
else
|
||
{
|
||
SetTranslationColors(tokens, 0xFFDC49, 0xFFA344);
|
||
SetSelectedTranslationColors(tokens, 0xFFFFFF, 0.8f, 0x64473A, 0.85f);
|
||
tokens.accent = ColorFromRgb(0xF97D0A);
|
||
tokens.selected = ColorFromRgb(0xF97D0A);
|
||
tokens.hover = D2D1::ColorF(249.0f / 255.0f, 125.0f / 255.0f, 10.0f / 255.0f, 0.30f);
|
||
tokens.number = ColorFromRgb(0xE1E8EC);
|
||
tokens.rowTextSelected = ColorFromRgb(0xFFFFFF);
|
||
tokens.rowLabelSelected = ColorFromRgb(0xFFFFFF);
|
||
tokens.menuFill = ColorFromRgb(0x6F8491);
|
||
tokens.menuBorder = ColorFromRgb(0x8CA0AC);
|
||
tokens.menuText = ColorFromRgb(0xF5F8FA);
|
||
tokens.menuHover = ColorFromRgb(0x637885);
|
||
}
|
||
}
|
||
else if (baseSkin == "microsoft")
|
||
{
|
||
// 几何随字号缩放，对应 CSS 里以 em 写的尺寸（ui-html/webview2/candwnd/skins/microsoft/）。
|
||
tokens.borderWidth = 1.0f;
|
||
tokens.radius = 8.0f;
|
||
tokens.containerPad = std::round(fontSize * 0.3f);
|
||
tokens.itemRadius = 4.0f;
|
||
tokens.itemExtraHeight = std::round(fontSize * 0.47f);
|
||
// 序号左端距高亮左缘 0.76em，其中 5 DIP 是列表固定的 textPadLeft。
|
||
tokens.itemPadLeft = (std::max)(0.0f, std::round(fontSize * 0.76f) - 5.0f);
|
||
tokens.itemPadRight = std::round(fontSize * 0.9f);
|
||
if (horizontalLayout)
|
||
{
|
||
tokens.itemGap = std::round(fontSize * 0.28f);
|
||
tokens.minItemWidth = std::round(fontSize * 4.35f);
|
||
}
|
||
tokens.labelScale = 1.0f;
|
||
tokens.labelGap = std::round(fontSize * 0.2f);
|
||
tokens.selectedBarWidth = (std::max)(3.0f, fontSize * 0.24f);
|
||
tokens.selectedBarHeightEm = 1.1f;
|
||
tokens.selectedBarInside = true;
|
||
tokens.trianglePager = true;
|
||
tokens.trimHiddenPreeditGap = true;
|
||
tokens.accent = ColorFromRgb(0xE183D9);
|
||
// 单词 Notion Pink，与粉色选中条同一色相；词性 Notion Purple。
|
||
SetTranslationColors(tokens, candLight ? 0xAD1A72 : 0xE255A1, candLight ? 0x6940A5 : 0x9A6DD7);
|
||
if (candLight)
|
||
{
|
||
tokens.selected = ColorFromRgb(0xEAEAEA);
|
||
tokens.hover = ColorFromRgb(0xF0F0F0);
|
||
tokens.number = ColorFromRgb(0x5F5F5F);
|
||
tokens.pagerDivider = ColorFromRgb(0xE0E0E0);
|
||
tokens.menuFill = ColorFromRgb(0xF9F9F9);
|
||
tokens.menuBorder = D2D1::ColorF(0, 0.1f);
|
||
tokens.menuText = ColorFromRgb(0x1A1A1A);
|
||
tokens.menuHover = ColorFromRgb(0xEAEAEA);
|
||
}
|
||
else
|
||
{
|
||
tokens.selected = ColorFromRgb(0x383838);
|
||
tokens.hover = ColorFromRgb(0x353535);
|
||
tokens.number = ColorFromRgb(0xCFCFCF);
|
||
tokens.pagerDivider = ColorFromRgb(0x3D3D3D);
|
||
tokens.menuFill = ColorFromRgb(0x2C2C2C);
|
||
tokens.menuBorder = ColorFromRgb(0x1C1C1C);
|
||
tokens.menuText = ColorFromRgb(0xFFFFFF);
|
||
tokens.menuHover = ColorFromRgb(0x383838);
|
||
}
|
||
}
|
||
|
||
if (package)
|
||
{
|
||
ApplyPackageColors(candLight ? package->light : package->dark, tokens);
|
||
// 自定义圆角：外框和贴着外框四角的高亮角一起换成 R，普通高亮角不变。
|
||
if (package->cornerRadiusDip)
|
||
{
|
||
tokens.radius = static_cast<float>(*package->cornerRadiusDip);
|
||
// 贴角规则以 outerItemRadius > 0 为开关；R 为 0 时仍要保持开启，否则贴角的
|
||
// 高亮会退回普通圆角、从直角外框里探出来。
|
||
if (tokens.outerItemRadius > 0.0f)
|
||
tokens.outerItemRadius = (std::max)(tokens.radius, 0.01f);
|
||
}
|
||
if (package->borderWidthDip)
|
||
tokens.borderWidth = static_cast<float>(*package->borderWidthDip);
|
||
// 只改普通高亮角；贴着卡片四角的那几个角仍跟卡片圆角。
|
||
if (package->itemCornerRadiusDip)
|
||
tokens.itemRadius = static_cast<float>(*package->itemCornerRadiusDip);
|
||
}
|
||
const CandidateSkinCatalog::CandidateColors *packageColors =
|
||
package ? &(candLight ? package->light : package->dark) : nullptr;
|
||
const CandidateSkinPalette palette = ResolveCandidateSkinPalette(
|
||
skinId, candLight, GetConfiguredCandidateTextColor(), packageColors, package ? package->base : std::string{});
|
||
tokens.surface = palette.surface;
|
||
tokens.border = palette.border;
|
||
tokens.text = palette.text;
|
||
// 阴影跟皮肤走，与 WebView2 端同一参照：四套内置皮肤与自定义包共用的皮肤 CSS
|
||
// （ui-html/webview2/candwnd/skins/*/horizontal_*.css）带同一对 box-shadow——
|
||
// light `8px 10px 24px rgba(0,0,0,.18), 2px 3px 8px rgba(0,0,0,.10)`，dark α .34/.22；
|
||
// σ = blur ÷ 2。默认皮肤（webview 端只有 body HTML，无 box-shadow）直接关阴影。
|
||
if (impl_->card)
|
||
{
|
||
const std::string shadow = package ? package->shadow : std::string{};
|
||
if ((CandidateSkinCatalog::IsBuiltIn(skinId) || package) && shadow != "none")
|
||
{
|
||
// 外部皮肤的 shadow = soft / strong 按同一系数缩放两层不透明度，与 WebView2 端一致。
|
||
const float scale = ShadowAlphaScale(shadow);
|
||
const auto alpha = [scale](float value) { return (std::min)(value * scale, 1.0f); };
|
||
const std::vector<msimeui::ShadowPass> shadowPasses = {
|
||
{12.0f, alpha(candLight ? 0.18f : 0.34f), 8.0f, 10.0f},
|
||
{4.0f, alpha(candLight ? 0.10f : 0.22f), 2.0f, 3.0f},
|
||
};
|
||
impl_->card->SetShadowEnabled(true);
|
||
impl_->card->SetShadowPasses(shadowPasses);
|
||
}
|
||
else
|
||
{
|
||
impl_->card->SetShadowEnabled(false);
|
||
}
|
||
}
|
||
|
||
msimeui::Theme theme = msimeui::ThemeManager::GetCurrent();
|
||
theme.textInputFontFamily = string_to_wstring(GetConfiguredCandidateFont());
|
||
if (theme.textInputFontFamily.empty())
|
||
{
|
||
theme.textInputFontFamily = L"Microsoft YaHei UI";
|
||
}
|
||
theme.uiFontFamily = theme.textInputFontFamily;
|
||
theme.surface = tokens.surface;
|
||
theme.border = tokens.border;
|
||
theme.textPrimary = palette.text;
|
||
theme.textSecondary = tokens.number;
|
||
theme.primary = tokens.accent;
|
||
theme.windowBackground = D2D1::ColorF(0, 0.0f);
|
||
msimeui::ThemeManager::SetCurrent(theme);
|
||
|
||
const float preeditSize = static_cast<float>((std::max)(12, GetConfiguredCandidateWindowPreeditFontSize()));
|
||
msimeui::CandidateList::Appearance appearance;
|
||
appearance.fontFamily = string_to_wstring(ResolveSystemFontFamilyForCss(GetConfiguredCandidateEnglishFont()));
|
||
// 皮肤的 font_family 排在最前，用户配置的字体整体退为回退，与 WebView2 端的 font-family 列表同序。
|
||
if (package && !package->fontFamily.empty())
|
||
{
|
||
appearance.fallbackFontFamilies.push_back(appearance.fontFamily);
|
||
appearance.fontFamily = string_to_wstring(ResolveSystemFontFamilyForCss(package->fontFamily));
|
||
}
|
||
for (const auto &font : GetConfiguredCandidateFallbackFontFamilies())
|
||
appearance.fallbackFontFamilies.push_back(string_to_wstring(font));
|
||
appearance.itemHeight = fontSize * 1.35f + tokens.itemExtraHeight;
|
||
appearance.itemGap = tokens.itemGap;
|
||
appearance.fontSize = fontSize;
|
||
appearance.labelFontSize = fontSize * tokens.labelScale;
|
||
appearance.annotationFontSize = fontSize;
|
||
appearance.contentPadLeft = tokens.itemPadLeft;
|
||
appearance.contentPadRight = tokens.itemPadRight;
|
||
// itemExtraHeight 上下各半：横排翻译换到第二行时从下半段内边距上方开始，内边距留在翻译下面，
|
||
// 对应 CSS 里 .row.cand 的 padding 包住整个 .text（杨柳青横排上下各 6px）。
|
||
appearance.contentPadBottom = tokens.itemExtraHeight * 0.5f;
|
||
appearance.textPadLeft = 5.0f;
|
||
appearance.labelGap = tokens.labelGap;
|
||
appearance.minItemWidth = tokens.minItemWidth;
|
||
// 收紧宽度时右侧留白与序号左侧的留白相同，卡片两边对称。
|
||
appearance.fitContent = fitContent_;
|
||
if (fitContent_)
|
||
appearance.contentPadRight = appearance.contentPadLeft + appearance.textPadLeft;
|
||
appearance.selectedBarWidth = tokens.selectedBarWidth;
|
||
appearance.selectedBarHeight = fontSize * tokens.selectedBarHeightEm;
|
||
appearance.selectedBarInside = tokens.selectedBarInside;
|
||
appearance.showSelectedBar = tokens.showSelectedBar;
|
||
appearance.selectedBarColor = tokens.selectedBar.a > 0.001f ? tokens.selectedBar : tokens.accent;
|
||
appearance.cornerRadius = tokens.itemRadius;
|
||
// 预编辑行隐藏时列表顶边才贴着卡片顶边，与 CSS 的 .preedit-hidden 同一判据。
|
||
const bool preeditHidden = GetConfiguredCandidateWindowPreeditStyle() == "empty";
|
||
appearance.outerCornerRadius = tokens.outerItemRadius;
|
||
appearance.outerTopCornersEnabled = preeditHidden;
|
||
appearance.justifyHorizontalRows = tokens.justifyRows;
|
||
// 隐藏的预编辑行高度为 0，但 body 仍在它和列表之间留 2px 行距；贴角皮肤把它抵掉，
|
||
// 让首项贴着卡片的内容顶边（秋桂四边内边距一致，杨柳青高亮直抵卡片顶边）。
|
||
if (preeditHidden)
|
||
impl_->preedit->SetMargin(
|
||
{0.0f, 0.0f, 0.0f, tokens.outerItemRadius > 0.0f || tokens.trimHiddenPreeditGap ? -2.0f : 0.0f});
|
||
else
|
||
impl_->preedit->SetMargin(tokens.preeditMargin);
|
||
appearance.textColor = palette.candidateText;
|
||
appearance.labelColor = tokens.number;
|
||
appearance.annotationColor = palette.candidateText;
|
||
appearance.translationColor = tokens.translation;
|
||
appearance.rowTranslationSelected = tokens.rowTranslationSelected;
|
||
appearance.translationSecondaryColor = tokens.translationPos;
|
||
appearance.translationDelimiterColor = tokens.translationSeparator;
|
||
appearance.rowTranslationSecondarySelected = tokens.rowTranslationPosSelected;
|
||
appearance.rowTranslationDelimiterSelected = tokens.rowTranslationSeparatorSelected;
|
||
appearance.rowFillSelected = tokens.selected;
|
||
appearance.rowFillHover = tokens.hover;
|
||
appearance.rowFillPressed = tokens.selected;
|
||
appearance.rowTextSelected = tokens.rowTextSelected;
|
||
appearance.rowLabelSelected = tokens.rowLabelSelected;
|
||
impl_->menuFill = tokens.menuFill;
|
||
impl_->menuBorder = tokens.menuBorder;
|
||
impl_->menuText = tokens.menuText;
|
||
impl_->menuHover = tokens.menuHover;
|
||
impl_->list->SetAppearance(appearance);
|
||
impl_->list->SetOrientation(GetConfiguredCandidateWindowLayout() == "horizontal"
|
||
? msimeui::CandidateList::Orientation::Horizontal
|
||
: msimeui::CandidateList::Orientation::Vertical);
|
||
if (impl_->pager)
|
||
{
|
||
// 箭头跟着候选字号缩放，与序号差不多大；颜色用序号色，悬停底色沿用候选项的悬停色。
|
||
msimeui::PagerArrows::Appearance pagerAppearance;
|
||
pagerAppearance.buttonWidth = std::round(fontSize * 0.72f);
|
||
pagerAppearance.buttonHeight = std::round(fontSize * 0.9f);
|
||
pagerAppearance.gap = 1.0f;
|
||
pagerAppearance.glyphSize = fontSize * 0.5f;
|
||
pagerAppearance.strokeWidth = (std::max)(1.2f, fontSize / 13.0f);
|
||
pagerAppearance.cornerRadius = (std::min)(3.0f, tokens.itemRadius);
|
||
pagerAppearance.glyphColor = tokens.number;
|
||
pagerAppearance.disabledGlyphColor = WithAlpha(tokens.number, 0.3f);
|
||
pagerAppearance.hoverFill = tokens.hover;
|
||
pagerAppearance.pressedFill = tokens.selected.a > 0.001f ? tokens.selected : tokens.hover;
|
||
if (tokens.trianglePager)
|
||
{
|
||
// 微软拼音式：候选文字色的实心三角，按钮与候选行等高。横排时按钮更宽，前面隔一条分隔线，
|
||
// 与 CSS 的 .page-arrow 同一组 em 尺寸。
|
||
pagerAppearance.glyph = msimeui::PagerArrows::Glyph::Triangle;
|
||
// 高 0.56em、宽 0.47em，三个角各圆掉高度的四分之一，尖端是钝的。
|
||
pagerAppearance.glyphSize = fontSize * 0.56f;
|
||
pagerAppearance.strokeWidth = pagerAppearance.glyphSize * 0.25f;
|
||
pagerAppearance.cornerRadius = tokens.itemRadius;
|
||
pagerAppearance.gap = 0.0f;
|
||
pagerAppearance.glyphColor = palette.candidateText;
|
||
pagerAppearance.disabledGlyphColor = WithAlpha(palette.candidateText, 0.25f);
|
||
pagerAppearance.buttonHeight = std::round(appearance.itemHeight);
|
||
if (horizontalLayout)
|
||
{
|
||
pagerAppearance.buttonWidth = std::round(fontSize * 1.73f);
|
||
pagerAppearance.dividerWidth = 1.0f;
|
||
pagerAppearance.dividerGap = std::round(fontSize * 0.12f);
|
||
pagerAppearance.dividerColor = tokens.pagerDivider;
|
||
}
|
||
else
|
||
{
|
||
pagerAppearance.buttonWidth = std::round(fontSize * 1.2f);
|
||
pagerAppearance.buttonHeight = std::round(fontSize * 1.2f);
|
||
}
|
||
}
|
||
impl_->pager->SetAppearance(pagerAppearance);
|
||
if (horizontalLayout && tokens.trianglePager)
|
||
{
|
||
// 与最后一项隔 0.3em，按钮与行等高，不用再抬。
|
||
impl_->pager->SetMargin({std::round(fontSize * 0.3f), 0.0f, 0.0f, 0.0f});
|
||
}
|
||
else if (horizontalLayout)
|
||
{
|
||
// 横排：窄列与候选之间留一点空，箭头竖直居中在最后一行上。
|
||
const float lift = (std::max)(0.0f, (appearance.itemHeight - pagerAppearance.buttonHeight) * 0.5f);
|
||
impl_->pager->SetMargin({2.0f, 0.0f, 1.0f, lift});
|
||
}
|
||
else
|
||
{
|
||
// 竖排：矮行抵掉 body 的 2px 行距，贴着最后一个候选、靠左，“‹”的左端与序号左端对齐。
|
||
// 序号从候选行的 contentPadLeft + textPadLeft 处开始；箭头在按钮里居中，要减去它左侧的留白。
|
||
impl_->pager->SetHorizontalAlignment(msimeui::HorizontalAlignment::Leading);
|
||
const float labelLeft = appearance.contentPadLeft + appearance.textPadLeft;
|
||
const float glyphInset = (pagerAppearance.buttonWidth - pagerAppearance.GlyphWidth()) * 0.5f;
|
||
impl_->pager->SetMargin({labelLeft - glyphInset, -1.0f, 0.0f, 1.0f});
|
||
}
|
||
}
|
||
impl_->preedit->SetFontFamily(appearance.fontFamily);
|
||
impl_->preedit->SetFallbackFontFamilies(appearance.fallbackFontFamilies);
|
||
impl_->preedit->SetFontSize(preeditSize);
|
||
impl_->preedit->SetColor(palette.preeditText);
|
||
impl_->preedit->SetCaretColor(tokens.preeditCaret.a > 0.001f ? tokens.preeditCaret : tokens.accent);
|
||
impl_->preedit->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_LEADING);
|
||
impl_->preedit->SetTextLayoutPadding({5.0f, 0.0f, 5.0f, 0.0f});
|
||
// 预编辑背景与分隔线对应 CSS 的 .pinyin background / border-bottom：底色带与高亮同圆角，分隔线固定 1px；
|
||
// 有其一时预编辑行横向铺满，否则底色只包住文字。
|
||
impl_->preedit->SetBackground(tokens.preeditBackground, tokens.itemRadius);
|
||
impl_->preedit->SetBottomRule(tokens.preeditDivider, 1.0f);
|
||
impl_->preedit->SetHorizontalAlignment(tokens.preeditBackground.a > 0.001f || tokens.preeditDivider.a > 0.001f
|
||
? msimeui::HorizontalAlignment::Stretch
|
||
: msimeui::HorizontalAlignment::Leading);
|
||
|
||
// 装饰图与 WebView2 端的 .containerParent::before 同一几何：宽 width_dip、高 top_inset_dip 的盒子
|
||
// 底边贴着卡片顶边、不与卡片重叠，按 align 贴卡片左/中/右，图片在盒内等比居中（contain）。
|
||
decorationTopDip_ = 0.0f;
|
||
decorationWidthDip_ = 0.0f;
|
||
cardMinWidthDip_ = fitContent_ ? 0.0f : kCandidateMinWidthDip;
|
||
std::wstring decorationPath;
|
||
std::wstring backgroundPath;
|
||
const std::wstring packageRoot = package ? skinsRoot + L"\\" + string_to_wstring(package->id) + L"\\" : L"";
|
||
if (package)
|
||
{
|
||
decorationTopDip_ = static_cast<float>(package->decorationTopDip);
|
||
decorationWidthDip_ = static_cast<float>(package->decorationWidthDip);
|
||
if (!package->decorationImage.empty())
|
||
decorationPath = packageRoot + string_to_wstring(package->decorationImage);
|
||
if (!package->backgroundImage.empty())
|
||
backgroundPath = packageRoot + string_to_wstring(package->backgroundImage);
|
||
cardMinWidthDip_ =
|
||
(std::max)({cardMinWidthDip_, static_cast<float>(package->minWidthDip), decorationWidthDip_});
|
||
}
|
||
// 卡片上方留给阴影的 kShadowPadTop 与装饰盒重叠，装饰盒高过它时不再额外留白。
|
||
float framePadTop = kShadowPadTop;
|
||
if (decorationPath.empty() || decorationTopDip_ <= 0.0f)
|
||
{
|
||
impl_->decoration->SetHeight(0.0f);
|
||
impl_->decoration->ClearWidth();
|
||
impl_->decoration->SetSource(L"");
|
||
}
|
||
else
|
||
{
|
||
impl_->decoration->SetSource(decorationPath);
|
||
impl_->decoration->SetHeight(decorationTopDip_);
|
||
impl_->decoration->SetWidth(decorationWidthDip_);
|
||
impl_->decoration->SetHorizontalAlignment(DecorationAlignment(package->decorationAlign));
|
||
framePadTop = (std::max)(0.0f, kShadowPadTop - decorationTopDip_);
|
||
}
|
||
// v2 挂件挂在卡片外沿，窗口要按 outer_insets_dip 往四边多留出空白，否则立绘被窗口边界裁掉。
|
||
float framePadLeft = kShadowPadLeft;
|
||
float framePadRight = kShadowPadRight;
|
||
float framePadBottom = kShadowPadBottom;
|
||
if (package && package->outerInsetsDip)
|
||
{
|
||
const CandidateSkinCatalog::InsetsDip &outer = *package->outerInsetsDip;
|
||
framePadLeft += static_cast<float>(outer.left);
|
||
framePadRight += static_cast<float>(outer.right);
|
||
framePadTop += static_cast<float>(outer.top);
|
||
framePadBottom += static_cast<float>(outer.bottom);
|
||
}
|
||
if (impl_->frame)
|
||
{
|
||
impl_->frame->SetPadding({framePadLeft, framePadTop, framePadRight, framePadBottom});
|
||
}
|
||
|
||
// v2 自由挂件交给 overlay 层绘制；它测量为 0，不参与卡片布局。
|
||
if (impl_->skinOverlay)
|
||
{
|
||
std::vector<CandidateSkinOverlay::Item> items;
|
||
if (package)
|
||
{
|
||
for (const CandidateSkinCatalog::FreeDecoration &dec : package->freeDecorations)
|
||
{
|
||
CandidateSkinOverlay::Item item;
|
||
item.path = packageRoot + string_to_wstring(dec.image);
|
||
item.anchor = dec.anchor;
|
||
item.offsetXDip = static_cast<float>(dec.offsetXDip);
|
||
item.offsetYDip = static_cast<float>(dec.offsetYDip);
|
||
item.widthDip = static_cast<float>(dec.widthDip);
|
||
item.heightDip = static_cast<float>(dec.heightDip);
|
||
items.push_back(std::move(item));
|
||
}
|
||
}
|
||
impl_->skinOverlay->SetItems(std::move(items));
|
||
}
|
||
// v2 的 line_gap_dip 落到预编辑行与候选列表之间的间距上。
|
||
// TODO(v2 皮肤): 暂定 WebView2 独占。SetSpacing 作用于 body 的全部子元素，竖排时列表与翻页栏之间也会被拉开，
|
||
// WebView2 只加在 .row.pinyin 下方。
|
||
if (impl_->body)
|
||
{
|
||
impl_->body->SetSpacing(package && package->lineGapDip ? static_cast<float>(*package->lineGapDip) : 2.0f);
|
||
}
|
||
|
||
msimeui::Brush brush;
|
||
brush.fill = tokens.surface;
|
||
brush.stroke = tokens.border;
|
||
brush.strokeWidth = tokens.borderWidth;
|
||
brush.radiusX = tokens.radius;
|
||
brush.radiusY = tokens.radius;
|
||
if (impl_->card)
|
||
{
|
||
impl_->card->SetBrush(brush);
|
||
if (package && package->contentInsetsDip)
|
||
{
|
||
// v2 的 content_insets_dip 从面板外缘量起，D2D 侧直接落成卡片内边距（这里没有 CSS 的边框内缘概念）。
|
||
const CandidateSkinCatalog::InsetsDip &insets = *package->contentInsetsDip;
|
||
impl_->card->SetPadding(msimeui::Thickness{static_cast<float>(insets.left), static_cast<float>(insets.top),
|
||
static_cast<float>(insets.right),
|
||
static_cast<float>(insets.bottom)});
|
||
}
|
||
else
|
||
{
|
||
impl_->card->SetPadding(tokens.containerPad);
|
||
}
|
||
impl_->card->SetMinWidth(cardMinWidthDip_);
|
||
if (package && package->borderImage && !package->borderImage->source.empty())
|
||
{
|
||
// v2 九宫格：四边原样、其余拉伸。切片按 1/2/4 值展开成「上右下左」。
|
||
// TODO(v2 皮肤): 暂定 WebView2 独占。D2D 尚未处理 width_dip 与 fill = false，九宫格仍叠在卡片底色、
|
||
// 描边与阴影之上并被卡片圆角裁剪；WebView2 会把这些清成透明、圆角归零。
|
||
const CandidateSkinCatalog::BorderImage &bi = *package->borderImage;
|
||
const std::vector<double> &values = bi.stretchDip.empty() ? bi.sliceDip : bi.stretchDip;
|
||
const auto expand4 = [](const std::vector<double> &v, float out[4]) {
|
||
if (v.size() == 1)
|
||
out[0] = out[1] = out[2] = out[3] = static_cast<float>(v[0]);
|
||
else if (v.size() == 2)
|
||
{
|
||
out[0] = out[2] = static_cast<float>(v[0]);
|
||
out[1] = out[3] = static_cast<float>(v[1]);
|
||
}
|
||
else
|
||
{
|
||
for (size_t i = 0; i < 4; ++i)
|
||
out[i] = i < v.size() ? static_cast<float>(v[i]) : 0.0f;
|
||
}
|
||
};
|
||
float slice[4] = {0.0f, 0.0f, 0.0f, 0.0f};
|
||
expand4(values, slice);
|
||
impl_->card->SetBackgroundImageNineSlice(packageRoot + string_to_wstring(bi.source), slice[3], slice[0],
|
||
slice[1], slice[2], 1.0f);
|
||
}
|
||
else
|
||
{
|
||
impl_->card->SetBackgroundImage(backgroundPath, BackgroundStretch(package ? package->backgroundFit : ""),
|
||
package ? static_cast<float>(package->backgroundOpacity) : 1.0f);
|
||
}
|
||
}
|
||
}
|
||
|
||
std::uint64_t CandidatePresenter::FillItemsFromUi()
|
||
{
|
||
const Global::CandidatePageSnapshotPtr page = Global::LoadCandidatePageSnapshot();
|
||
const bool translationsEnabled = GetConfiguredCandidateTranslationsEnabled();
|
||
std::vector<msimeui::CandidateList::Item> items;
|
||
items.reserve(page->page_views.size());
|
||
for (size_t i = 0; i < page->page_views.size(); ++i)
|
||
{
|
||
const auto &view = page->page_views[i];
|
||
msimeui::CandidateList::Item item;
|
||
item.label = std::to_wstring(i + 1);
|
||
item.text = string_to_wstring(view.text + view.badge);
|
||
item.annotation = string_to_wstring(view.annotation);
|
||
if (translationsEnabled)
|
||
{
|
||
// 逐段转成 UTF-16 再拼起来，区间按拼出来的串计，与 WebView2 的 .cand-pos / .cand-sep 同一切法。
|
||
for (const auto &segment : FanyImeIpc::SegmentTranslationGloss(view.translation))
|
||
{
|
||
const std::wstring text = string_to_wstring(segment.text);
|
||
if (segment.kind != FanyImeIpc::TranslationSegmentKind::Text)
|
||
{
|
||
item.translationRuns.push_back({static_cast<UINT32>(item.translation.size()),
|
||
static_cast<UINT32>(text.size()),
|
||
segment.kind == FanyImeIpc::TranslationSegmentKind::Separator
|
||
? msimeui::CandidateList::TextRunRole::Delimiter
|
||
: msimeui::CandidateList::TextRunRole::Secondary});
|
||
}
|
||
item.translation += text;
|
||
}
|
||
}
|
||
items.push_back(std::move(item));
|
||
}
|
||
ignoreSelectionCallback_ = true;
|
||
impl_->list->SetItems(std::move(items));
|
||
impl_->list->SetSelectedIndex(static_cast<size_t>((std::max)(0, page->selected_index_in_page)));
|
||
ignoreSelectionCallback_ = false;
|
||
if (impl_->pager)
|
||
{
|
||
impl_->pager->SetEnabled(page->has_previous_page, page->has_next_page);
|
||
}
|
||
return page->generation;
|
||
}
|
||
|
||
void CandidatePresenter::CommitItem(size_t pageIndex)
|
||
{
|
||
if (!hwnd_)
|
||
{
|
||
return;
|
||
}
|
||
PostMessageW(hwnd_, WM_COMMIT_CANDIDATE, static_cast<WPARAM>(pageIndex + 1), 0);
|
||
}
|
||
|
||
namespace
|
||
{
|
||
constexpr float kContextMenuWidthDip = 108.0f;
|
||
constexpr float kContextSubmenuWidthDip = 96.0f;
|
||
|
||
void StyleContextPopup(msimeui::Popup &popup, const D2D1_COLOR_F &fill, const D2D1_COLOR_F &border, float width)
|
||
{
|
||
popup.SetMatchAnchorWidth(false);
|
||
popup.SetWidth(width);
|
||
popup.SetPadding({2.0f, 2.0f, 2.0f, 2.0f});
|
||
popup.SetBackgroundFill(fill);
|
||
popup.SetBorderColor(border);
|
||
popup.SetCornerRadius(6.0f);
|
||
popup.SetShadowEnabled(true);
|
||
popup.SetOffset(0.0f, 0.0f);
|
||
popup.SetConstrainToViewport(true);
|
||
}
|
||
} // namespace
|
||
|
||
void CandidatePresenter::ShowItemContextMenu(size_t pageIndex, POINT clientPoint)
|
||
{
|
||
if (!hwnd_ || !impl_ || !impl_->list || !impl_->window)
|
||
{
|
||
return;
|
||
}
|
||
|
||
CloseContextMenu(true);
|
||
impl_->contextMenuPageIndex = pageIndex;
|
||
|
||
// A mouse callback has no posted-message handoff at all, so it must not walk the worker's live page either.
|
||
const Global::CandidatePageSnapshotPtr page = Global::LoadCandidatePageSnapshot();
|
||
std::wstring word;
|
||
if (pageIndex < page->page_words.size())
|
||
{
|
||
word = page->page_words[pageIndex];
|
||
}
|
||
size_t codePoints = 0;
|
||
for (size_t i = 0; i < word.size(); ++i)
|
||
{
|
||
++codePoints;
|
||
if (i + 1 < word.size() && IS_HIGH_SURROGATE(word[i]) && IS_LOW_SURROGATE(word[i + 1]))
|
||
{
|
||
++i;
|
||
}
|
||
}
|
||
const bool showDelete = codePoints != 1;
|
||
const WPARAM oneBased = static_cast<WPARAM>(pageIndex + 1);
|
||
|
||
auto makeItem = [this](const std::wstring &text, bool hasSubmenu, std::function<void()> onClick) {
|
||
auto item = std::make_shared<msimeui::MenuFlyoutItem>(text, hasSubmenu);
|
||
item->SetColors(impl_->menuText, impl_->menuHover);
|
||
if (onClick)
|
||
{
|
||
item->SetOnClick(std::move(onClick));
|
||
}
|
||
return item;
|
||
};
|
||
|
||
auto stack = std::make_shared<msimeui::StackPanel>(0.0f);
|
||
auto pin = makeItem(L"置顶", false, [this, oneBased]() {
|
||
CloseContextMenu(true);
|
||
PostMessageW(hwnd_, WM_PIN_TO_TOP_CANDIDATE, oneBased, 0);
|
||
});
|
||
pin->SetOnHover([this](bool hovered) {
|
||
if (hovered)
|
||
{
|
||
CloseFixSubmenu();
|
||
}
|
||
});
|
||
impl_->fixPositionItem = makeItem(L"固定排位", true, {});
|
||
impl_->fixPositionItem->SetOnHover([this](bool hovered) {
|
||
if (hovered)
|
||
{
|
||
OpenFixSubmenu();
|
||
}
|
||
});
|
||
stack->AddChild(pin);
|
||
stack->AddChild(impl_->fixPositionItem);
|
||
if (showDelete)
|
||
{
|
||
auto del = makeItem(L"删除", false, [this, oneBased]() {
|
||
CloseContextMenu(true);
|
||
PostMessageW(hwnd_, WM_DELETE_CANDIDATE, oneBased, 0);
|
||
});
|
||
del->SetOnHover([this](bool hovered) {
|
||
if (hovered)
|
||
{
|
||
CloseFixSubmenu();
|
||
}
|
||
});
|
||
stack->AddChild(del);
|
||
}
|
||
|
||
auto subStack = std::make_shared<msimeui::StackPanel>(0.0f);
|
||
for (int position = 1; position <= 5; ++position)
|
||
{
|
||
const std::wstring label = L"第 " + std::to_wstring(position) + L" 位";
|
||
subStack->AddChild(makeItem(label, false, [this, oneBased, position]() {
|
||
CloseContextMenu(true);
|
||
PostMessageW(hwnd_, WM_FIX_CANDIDATE_POSITION, oneBased, position);
|
||
}));
|
||
}
|
||
auto separator = std::make_shared<msimeui::MenuSeparator>();
|
||
separator->SetColor(D2D1::ColorF(impl_->menuText.r, impl_->menuText.g, impl_->menuText.b, 0.125f));
|
||
subStack->AddChild(separator);
|
||
subStack->AddChild(makeItem(L"取消固定", false, [this, oneBased]() {
|
||
CloseContextMenu(true);
|
||
PostMessageW(hwnd_, WM_CLEAR_CANDIDATE_POSITION, oneBased, 0);
|
||
}));
|
||
|
||
impl_->contextMenu = std::make_shared<msimeui::Popup>(stack);
|
||
StyleContextPopup(*impl_->contextMenu, impl_->menuFill, impl_->menuBorder, kContextMenuWidthDip);
|
||
impl_->contextSubmenu = std::make_shared<msimeui::Popup>(subStack);
|
||
StyleContextPopup(*impl_->contextSubmenu, impl_->menuFill, impl_->menuBorder, kContextSubmenuWidthDip);
|
||
|
||
const msimeui::PointF anchor = impl_->window->ClientPixelsToDips(clientPoint);
|
||
impl_->contextMenu->SetAnchorRect({anchor.x, anchor.y, 1.0f, 1.0f});
|
||
ExpandHostForMenu(clientPoint);
|
||
|
||
if (msimeui::Scene *scene = impl_->window->GetScene())
|
||
{
|
||
scene->AddPopup(impl_->contextMenu, [this]() { CloseContextMenu(true); });
|
||
impl_->contextMenuOpen = true;
|
||
}
|
||
Present();
|
||
}
|
||
|
||
void CandidatePresenter::CloseContextMenu(bool restoreHost)
|
||
{
|
||
if (!impl_ || !impl_->window)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// ShowFromGlobalState and Hide call this on every keystroke, so the hover
|
||
// teardown and the repaint below only run when a menu is actually up.
|
||
const bool hadPopup = impl_->contextMenu || impl_->contextSubmenu;
|
||
if (hadPopup)
|
||
{
|
||
// Window caches the hovered and focused Visual as raw pointers. They
|
||
// point into the popup destroyed a few lines below, so they have to be
|
||
// dropped first or the next mouse message dispatches through a dangling
|
||
// pointer.
|
||
impl_->window->DispatchImportedMessage(WM_MOUSELEAVE, 0, 0);
|
||
impl_->window->FocusVisual(nullptr);
|
||
}
|
||
|
||
if (msimeui::Scene *scene = impl_->window->GetScene())
|
||
{
|
||
if (impl_->contextSubmenu)
|
||
{
|
||
scene->RemovePopup(impl_->contextSubmenu.get(), false);
|
||
}
|
||
if (impl_->contextMenu)
|
||
{
|
||
scene->RemovePopup(impl_->contextMenu.get(), false);
|
||
}
|
||
}
|
||
impl_->contextMenuOpen = false;
|
||
impl_->contextSubmenuOpen = false;
|
||
impl_->fixPositionItem.reset();
|
||
impl_->contextMenu.reset();
|
||
impl_->contextSubmenu.reset();
|
||
if (restoreHost)
|
||
{
|
||
RestoreHostAfterMenu();
|
||
}
|
||
else
|
||
{
|
||
impl_->hostExpandedForMenu = false;
|
||
}
|
||
if (hadPopup)
|
||
{
|
||
Present();
|
||
}
|
||
}
|
||
|
||
void CandidatePresenter::OpenFixSubmenu()
|
||
{
|
||
if (!impl_ || !impl_->window || !impl_->contextSubmenu || !impl_->fixPositionItem || impl_->contextSubmenuOpen)
|
||
{
|
||
return;
|
||
}
|
||
const msimeui::RectF anchor = impl_->fixPositionItem->GetBounds();
|
||
if (anchor.width < 1.0f || anchor.height < 1.0f)
|
||
{
|
||
return;
|
||
}
|
||
impl_->contextSubmenu->SetAnchorRect(anchor);
|
||
impl_->contextSubmenu->SetOffset(anchor.width - 2.0f, -anchor.height);
|
||
if (msimeui::Scene *scene = impl_->window->GetScene())
|
||
{
|
||
scene->AddPopup(impl_->contextSubmenu, [this]() { impl_->contextSubmenuOpen = false; });
|
||
impl_->contextSubmenuOpen = true;
|
||
}
|
||
}
|
||
|
||
void CandidatePresenter::CloseFixSubmenu()
|
||
{
|
||
if (!impl_ || !impl_->window || !impl_->contextSubmenu || !impl_->contextSubmenuOpen)
|
||
{
|
||
return;
|
||
}
|
||
// The submenu visual outlives this call (contextSubmenu keeps it alive for
|
||
// a later reopen), but it leaves the scene here, so the cached hover has to
|
||
// go with it. Focus stays where it is: the parent menu is still open.
|
||
impl_->window->DispatchImportedMessage(WM_MOUSELEAVE, 0, 0);
|
||
if (msimeui::Scene *scene = impl_->window->GetScene())
|
||
{
|
||
scene->RemovePopup(impl_->contextSubmenu.get(), false);
|
||
}
|
||
impl_->contextSubmenuOpen = false;
|
||
Present();
|
||
}
|
||
|
||
void CandidatePresenter::ExpandHostForMenu(POINT clientPoint)
|
||
{
|
||
if (!hwnd_ || !impl_ || !impl_->window)
|
||
{
|
||
return;
|
||
}
|
||
RECT windowRect{};
|
||
RECT clientRect{};
|
||
GetWindowRect(hwnd_, &windowRect);
|
||
GetClientRect(hwnd_, &clientRect);
|
||
if (!impl_->hostExpandedForMenu)
|
||
{
|
||
impl_->hostRectBeforeMenu = windowRect;
|
||
impl_->hostExpandedForMenu = true;
|
||
}
|
||
|
||
const float dpi = impl_->window->GetDpi();
|
||
const msimeui::PointF anchor = impl_->window->ClientPixelsToDips(clientPoint);
|
||
const msimeui::SizeF clientDip = impl_->window->ClientPixelsToDips(SIZE{clientRect.right, clientRect.bottom});
|
||
const float needWidth =
|
||
(std::max)(clientDip.width, anchor.x + kContextMenuWidthDip + kContextSubmenuWidthDip + 16.0f);
|
||
const float needHeight = (std::max)(clientDip.height, (std::max)(anchor.y + 168.0f, 176.0f));
|
||
const int widthPx = (std::max)(static_cast<int>(windowRect.right - windowRect.left),
|
||
static_cast<int>(std::ceil(needWidth * dpi / 96.0f)));
|
||
const int heightPx = (std::max)(static_cast<int>(windowRect.bottom - windowRect.top),
|
||
static_cast<int>(std::ceil(needHeight * dpi / 96.0f)));
|
||
if (widthPx == windowRect.right - windowRect.left && heightPx == windowRect.bottom - windowRect.top)
|
||
{
|
||
return;
|
||
}
|
||
SetWindowPos(hwnd_, HWND_TOPMOST, windowRect.left, windowRect.top, widthPx, heightPx,
|
||
SWP_NOACTIVATE | SWP_NOZORDER);
|
||
}
|
||
|
||
void CandidatePresenter::RestoreHostAfterMenu()
|
||
{
|
||
if (!hwnd_ || !impl_ || !impl_->hostExpandedForMenu)
|
||
{
|
||
return;
|
||
}
|
||
const RECT &rc = impl_->hostRectBeforeMenu;
|
||
SetWindowPos(hwnd_, nullptr, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top,
|
||
SWP_NOACTIVATE | SWP_NOZORDER);
|
||
impl_->hostExpandedForMenu = false;
|
||
}
|
||
|
||
void CandidatePresenter::PlaceAndShow(POINT caret, float widthDip, float heightDip, float cardLeftDip, float cardTopDip,
|
||
const ResolvedCandidateScale &resolved)
|
||
{
|
||
FLOAT scale = resolved.scale;
|
||
CandidateScaleSource scaleSource = resolved.source;
|
||
if (scale <= 0.0f)
|
||
{
|
||
const ResolvedCandidateScale now = ResolveCandidateScaleForCaret(caret);
|
||
scale = now.scale;
|
||
scaleSource = now.source;
|
||
}
|
||
if (scale <= 0.0f)
|
||
{
|
||
scale = 1.0f;
|
||
scaleSource = CandidateScaleSource::Monitor;
|
||
}
|
||
const HalfScreenDipLimits limits = ApplyScaleToHalfScreenLimits(caret, scale);
|
||
widthDip = static_cast<float>(ClampWidthDipToHalfScreen(widthDip, limits));
|
||
heightDip = static_cast<float>(ClampHeightDipToHalfScreen(heightDip, limits));
|
||
lastLayoutWidthDip_ = widthDip;
|
||
lastLayoutHeightDip_ = heightDip;
|
||
cardLeftDip = (std::max)(0.0f, cardLeftDip);
|
||
cardTopDip = (std::max)(0.0f, (std::min)(cardTopDip, heightDip));
|
||
float cardWidthDip = (std::max)(widthDip - cardLeftDip - kShadowPadRight, 1.0f);
|
||
float cardHeightDip = (std::max)(heightDip - cardTopDip - kShadowPadBottom, 1.0f);
|
||
if (impl_->card)
|
||
{
|
||
const msimeui::RectF card = impl_->card->GetBounds();
|
||
if (card.width > 1.0f)
|
||
{
|
||
cardWidthDip = card.width;
|
||
}
|
||
if (card.height > 1.0f)
|
||
{
|
||
cardHeightDip = card.height;
|
||
}
|
||
}
|
||
auto properPos = std::make_shared<std::pair<int, int>>();
|
||
// Position the opaque card, not the decoration or drop shadow around it.
|
||
AdjustCandidateWindowPosition(&caret, {cardWidthDip, cardHeightDip}, properPos, scale, cardWidthDip);
|
||
int widthPx = AlignHostPixels((std::max)(1, static_cast<int>(std::ceil(widthDip * scale))));
|
||
int heightPx = AlignHostPixels((std::max)(1, static_cast<int>(std::ceil(heightDip * scale))));
|
||
widthPx = (std::max)(widthPx, lastHostWidthPx_);
|
||
heightPx = (std::max)(heightPx, lastHostHeightPx_);
|
||
lastHostWidthPx_ = widthPx;
|
||
lastHostHeightPx_ = heightPx;
|
||
const int cardLeftPx = static_cast<int>(std::lround(cardLeftDip * scale));
|
||
const int cardTopPx = static_cast<int>(std::lround(cardTopDip * scale));
|
||
const int cardHeightPx = static_cast<int>(std::lround(cardHeightDip * scale));
|
||
int x = properPos->first - cardLeftPx;
|
||
int y = properPos->second - cardTopPx;
|
||
const MonitorCoordinates monitor = GetMonitorCoordinatesFromPoint(caret);
|
||
// Clamp the opaque card, not the host window — same rule the vertical branch
|
||
// below already follows. The host carries transparent shadow padding, is
|
||
// rounded up to a 64px bucket and only ever grows while typing, so clamping
|
||
// *its* right edge shoved the card left by all of that slack. AdjustCandidate-
|
||
// WindowPosition had already parked the card flush against the screen edge;
|
||
// deleting a character kept the stale (larger) host width, so the card's left
|
||
// edge froze and its right edge drifted further from the edge on every delete.
|
||
const int cardWidthPx = (std::max)(1, static_cast<int>(std::ceil(cardWidthDip * scale)));
|
||
if (x + cardLeftPx + cardWidthPx > monitor.right)
|
||
{
|
||
x = monitor.right - cardLeftPx - cardWidthPx - 2;
|
||
}
|
||
if (x + cardLeftPx < monitor.left)
|
||
{
|
||
x = monitor.left + 2 - cardLeftPx;
|
||
}
|
||
const int cardBottom = y + cardTopPx + cardHeightPx;
|
||
if (cardBottom > monitor.bottom)
|
||
{
|
||
y = monitor.bottom - cardTopPx - cardHeightPx - 2;
|
||
}
|
||
// Allow the mascot to clip above the work area so the card stays on the caret.
|
||
if (y + cardTopPx < monitor.top)
|
||
{
|
||
y = monitor.top + 2 - cardTopPx;
|
||
}
|
||
// Rendering must use the same scale the window is sized with: the ui
|
||
// override replaces GetDpiForWindow (144 inside RDP) so DIPs map exactly
|
||
// onto the pixels computed above. Must land before EnsureForComposition —
|
||
// a freshly created target reads it through DpiForHwnd() — and before the
|
||
// resize below, whose WM_SIZE already presents.
|
||
const FLOAT dpiOverride = scale * 96.0f;
|
||
impl_->window->SetDpiOverride(dpiOverride);
|
||
impl_->resources.SetDpiOverride(dpiOverride);
|
||
// The card is clamped to the work area, but the host around it carries the
|
||
// shadow padding and the 64px bucket slack, so near the right or bottom edge
|
||
// it reached onto the neighbouring monitor. DWM applies a window move and a
|
||
// swap-chain present independently and in no guaranteed order, so a frame
|
||
// can pair either card with either host origin; whatever it put past the
|
||
// card then flashed on the next screen. Cut the host at the work-area edge:
|
||
// nothing can be drawn outside the caret's monitor, whatever DWM pairs up.
|
||
// The card still fits (it was clamped above); only its shadow is trimmed.
|
||
const int hostWidthPx = (std::max)(1, (std::min)(widthPx, monitor.right - x));
|
||
const int hostHeightPx = (std::max)(1, (std::min)(heightPx, monitor.bottom - y));
|
||
// Submission order still decides which stale pairing is likelier. Moving a
|
||
// host left/up before the present, and right/down after it, keeps the
|
||
// stale frame on the side of the card that is already on screen.
|
||
RECT current{};
|
||
DWORD cloaked = 0;
|
||
const bool onScreen =
|
||
IsWindowVisible(hwnd_) && GetWindowRect(hwnd_, ¤t) && current.top != Global::INVALID_Y &&
|
||
SUCCEEDED(DwmGetWindowAttribute(hwnd_, DWMWA_CLOAKED, &cloaked, sizeof(cloaked))) && cloaked == 0;
|
||
const int firstX = onScreen && x > current.left ? current.left : x;
|
||
const int firstY = onScreen && y > current.top ? current.top : y;
|
||
// WM_SIZE from this resize would present the frame once more right before
|
||
// the explicit Present below; let it only resize the swap chain.
|
||
placingHost_ = true;
|
||
SetWindowPos(hwnd_, HWND_TOPMOST, firstX, firstY, hostWidthPx, hostHeightPx, SWP_NOACTIVATE | SWP_SHOWWINDOW);
|
||
placingHost_ = false;
|
||
impl_->resources.EnsureForComposition(hwnd_);
|
||
Present();
|
||
// Every setter above invalidated the window, which queued a WM_PAINT that
|
||
// would render the whole card (shadow blur included) a second time. The
|
||
// frame just presented is already current.
|
||
ValidateRect(hwnd_, nullptr);
|
||
if (firstX != x || firstY != y)
|
||
{
|
||
SetWindowPos(hwnd_, nullptr, x, y, 0, 0, SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE);
|
||
}
|
||
SetCandidateHostCloaked(false);
|
||
// Acceptance trace for the RDP candidate-scale fix: which scale authority
|
||
// won, and the system's own (potentially diverging) DPI values. Coordinates
|
||
// and DPI only — never user input, per the diagnostic logging red lines.
|
||
CAND_DIAG_LOGF(
|
||
L"candidate-d2d place source={} scale={:.3f} hwnd_dpi={} system_dpi={} remote={} caret=({},{}) "
|
||
L"size_px=({},{}) host=({},{}) first=({},{}) on_screen={} card_px=({},{} {}w) monitor=({},{})-({},{})",
|
||
scaleSource == CandidateScaleSource::RdpForeground ? L"rdp-foreground" : L"monitor", scale,
|
||
GetDpiForWindow(hwnd_), GetDpiForSystem(), GetSystemMetrics(SM_REMOTESESSION) ? 1 : 0, caret.x, caret.y,
|
||
hostWidthPx, hostHeightPx, x, y, firstX, firstY, onScreen, x + cardLeftPx, y + cardTopPx, cardWidthPx,
|
||
monitor.left, monitor.top, monitor.right, monitor.bottom);
|
||
}
|
||
|
||
void CandidatePresenter::ShowFromGlobalState()
|
||
{
|
||
ShowFromGlobalState(POINT{Global::Point[0], Global::Point[1]});
|
||
}
|
||
|
||
void CandidatePresenter::ShowFromGlobalState(POINT caret)
|
||
{
|
||
if (!bound_ || !hwnd_ || !impl_ || !impl_->root)
|
||
{
|
||
return;
|
||
}
|
||
// A composition can start before the host reports a usable text extent
|
||
// (first focus, or resuming after a long idle). The caret then arrives as
|
||
// (0, INVALID_Y), which placement would clamp into the monitor's work area.
|
||
// Hide even an already-visible host until a real anchor arrives. Preserve
|
||
// the show request so MoveCandidate / the settle timer can place it later.
|
||
if (caret.y == Global::INVALID_Y)
|
||
{
|
||
CloseContextMenu(false);
|
||
SetCandidateHostCloaked(true);
|
||
::is_global_wnd_cand_shown = true;
|
||
Global::SetCandidateWindowRenderedVisible(true);
|
||
CAND_DIAG_LOGF(L"candidate-d2d show deferred: no usable caret anchor ({},{})", caret.x, caret.y);
|
||
return;
|
||
}
|
||
CloseContextMenu(false);
|
||
ApplySkin();
|
||
std::wstring preedit;
|
||
size_t caretIndex = 0;
|
||
if (GetConfiguredCandidateWindowPreeditStyle() != "empty")
|
||
{
|
||
preedit = GetPreeditWithCaretMarker();
|
||
const size_t marker = preedit.find(L'\uE000');
|
||
if (marker != std::wstring::npos)
|
||
{
|
||
caretIndex = marker;
|
||
preedit.erase(marker, 1);
|
||
}
|
||
else
|
||
{
|
||
caretIndex = preedit.size();
|
||
}
|
||
}
|
||
impl_->preedit->SetText(preedit);
|
||
if (preedit.empty() && GetConfiguredCandidateWindowPreeditStyle() == "empty")
|
||
{
|
||
impl_->preedit->ClearCaret();
|
||
impl_->preedit->SetHeight(0.0f);
|
||
}
|
||
else
|
||
{
|
||
impl_->preedit->ClearHeight();
|
||
impl_->preedit->SetCaretIndex(caretIndex);
|
||
}
|
||
const std::uint64_t renderedGeneration = FillItemsFromUi();
|
||
impl_->list->SetHoverEnabled(hoverArmed_);
|
||
if (impl_->pager)
|
||
{
|
||
impl_->pager->SetHoverEnabled(hoverArmed_);
|
||
}
|
||
// Resolve the scale once per show and thread it through measure, clamping,
|
||
// window sizing and rendering DPI — a foreground window changing mid-show
|
||
// must not split measure (clamped at one scale) from placement (another).
|
||
const ResolvedCandidateScale scale = ResolveCandidateScaleForCaret(caret);
|
||
const HalfScreenDipLimits limits = ApplyScaleToHalfScreenLimits(caret, scale.scale);
|
||
const float maxW = limits.maxWidthDip > 1.0 ? static_cast<float>(limits.maxWidthDip) : 480.0f;
|
||
const float maxH = limits.maxHeightDip > 1.0 ? static_cast<float>(limits.maxHeightDip) : 640.0f;
|
||
float widthDip = 0.0f;
|
||
float heightDip = 0.0f;
|
||
auto layoutRoot = [&]() {
|
||
impl_->root->InvalidateMeasure();
|
||
const msimeui::SizeF measured = impl_->root->MeasureInLayout({maxW, maxH});
|
||
widthDip = (std::max)(measured.width, cardMinWidthDip_ + kShadowPadLeft + kShadowPadRight);
|
||
heightDip = (std::max)(measured.height, 36.0f);
|
||
impl_->root->InvalidateArrange();
|
||
impl_->root->ArrangeInLayout({0.0f, 0.0f, widthDip, heightDip});
|
||
};
|
||
// Late additions to the page (translations, cloud/AI/English merges) change
|
||
// the card's size between two frames of the same input, and the eye reads
|
||
// that as flicker even though every frame is complete. For one input
|
||
// (preedit + caret + page) the card therefore only grows; it shrinks back
|
||
// only when the natural size falls well below the kept one (a page that
|
||
// really got smaller). Another keystroke, caret move or page turn is a
|
||
// different page and starts from its natural size, as does Hide();
|
||
// carrying the old size over leaves blank rows at the bottom.
|
||
if (impl_->card)
|
||
{
|
||
impl_->card->SetMinWidth(cardMinWidthDip_);
|
||
impl_->card->ClearMinHeight();
|
||
}
|
||
layoutRoot();
|
||
if (impl_->card)
|
||
{
|
||
std::wstring stickyKey = GetPreeditWithCaretMarker();
|
||
stickyKey += L'#';
|
||
stickyKey += std::to_wstring(Global::candidate_ui.page_index);
|
||
if (stickyKey != stickyCardKey_)
|
||
{
|
||
stickyCardKey_ = std::move(stickyKey);
|
||
stickyCardWidthDip_ = 0.0f;
|
||
stickyCardHeightDip_ = 0.0f;
|
||
}
|
||
const msimeui::RectF natural = impl_->card->GetBounds();
|
||
const float maxCardWidthDip = (std::max)(cardMinWidthDip_, maxW - kShadowPadLeft - kShadowPadRight);
|
||
// fit_content 的卡片严格跟随文字宽度，只保留高度的只增不减。
|
||
stickyCardWidthDip_ = fitContent_
|
||
? natural.width
|
||
: (std::min)(StickyCardExtent(stickyCardWidthDip_, natural.width), maxCardWidthDip);
|
||
stickyCardHeightDip_ = StickyCardExtent(stickyCardHeightDip_, natural.height);
|
||
if (stickyCardWidthDip_ > natural.width + 0.5f || stickyCardHeightDip_ > natural.height + 0.5f)
|
||
{
|
||
impl_->card->SetMinWidth((std::max)(cardMinWidthDip_, stickyCardWidthDip_));
|
||
impl_->card->SetMinHeight(stickyCardHeightDip_);
|
||
layoutRoot();
|
||
}
|
||
}
|
||
hoverArmed_ = false;
|
||
if (!GetCursorPos(&hoverBaseline_))
|
||
{
|
||
hoverBaseline_ = {};
|
||
}
|
||
float cardLeftDip = 0.0f;
|
||
float cardTopDip = 0.0f;
|
||
if (impl_->card)
|
||
{
|
||
const msimeui::RectF card = impl_->card->GetBounds();
|
||
cardLeftDip = card.x;
|
||
cardTopDip = card.y;
|
||
}
|
||
PlaceAndShow(caret, widthDip, heightDip, cardLeftDip, cardTopDip, scale);
|
||
::is_global_wnd_cand_shown = true;
|
||
Global::SetCandidateWindowRenderedVisible(true);
|
||
// PlaceAndShow paints synchronously, so the page is on screen now. Echo the generation of the
|
||
// snapshot that was actually rendered (not the latest published one) so a pending digit/space
|
||
// selection can settle against the same page the user is looking at.
|
||
Global::PublishRenderedCandidatePageGeneration(renderedGeneration);
|
||
}
|
||
|
||
void CandidatePresenter::Hide()
|
||
{
|
||
if (!hwnd_)
|
||
{
|
||
return;
|
||
}
|
||
CloseContextMenu(false);
|
||
::is_global_wnd_cand_shown = false;
|
||
Global::SetCandidateWindowRenderedVisible(false);
|
||
hoverArmed_ = false;
|
||
wheelDeltaAccumulator_ = 0;
|
||
if (impl_ && impl_->list)
|
||
{
|
||
impl_->list->SetHoverEnabled(false);
|
||
}
|
||
if (impl_ && impl_->pager)
|
||
{
|
||
impl_->pager->SetHoverEnabled(false);
|
||
}
|
||
// Cloaking keeps the swap chain's last frame. The next show presents and
|
||
// then uncloaks, but DWM may compose the uncloaked host before it latches
|
||
// that present: one frame of the previous card at the new origin. After a
|
||
// wide card, a narrower one clamped to the right screen edge sits further
|
||
// right, so the stale card spilled onto the next monitor. Leave nothing
|
||
// behind to show.
|
||
PresentEmptyFrame();
|
||
SetCandidateHostCloaked(true);
|
||
lastHostWidthPx_ = 0;
|
||
lastHostHeightPx_ = 0;
|
||
stickyCardKey_.clear();
|
||
stickyCardWidthDip_ = 0.0f;
|
||
stickyCardHeightDip_ = 0.0f;
|
||
SetWindowPos(hwnd_, nullptr, 0, Global::INVALID_Y, 0, 0,
|
||
SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
|
||
}
|
||
|
||
void CandidatePresenter::Present()
|
||
{
|
||
if (!bound_ || !hwnd_ || !impl_ || !impl_->window)
|
||
{
|
||
return;
|
||
}
|
||
RECT rc{};
|
||
GetClientRect(hwnd_, &rc);
|
||
const UINT width = static_cast<UINT>((std::max)(1L, rc.right));
|
||
const UINT height = static_cast<UINT>((std::max)(1L, rc.bottom));
|
||
if (!impl_->resources.EnsureForComposition(hwnd_))
|
||
{
|
||
return;
|
||
}
|
||
impl_->resources.Resize(width, height);
|
||
ID2D1RenderTarget *target = impl_->resources.GetRenderTarget();
|
||
if (!target)
|
||
{
|
||
return;
|
||
}
|
||
target->BeginDraw();
|
||
target->Clear(D2D1::ColorF(0, 0.0f));
|
||
if (msimeui::Scene *scene = impl_->window->GetScene())
|
||
{
|
||
const float dpi = impl_->window->GetDpi();
|
||
float layoutW = msimeui::PixelsToDips(static_cast<float>(width), dpi);
|
||
float layoutH = msimeui::PixelsToDips(static_cast<float>(height), dpi);
|
||
// Host HWND is larger than the card (shadow padding, 64px buckets, and a
|
||
// grow-only size while typing). Stretching the scene to that HWND fills
|
||
// the rounded card with empty space. Keep layout at the measured DIP size.
|
||
if (!impl_->hostExpandedForMenu && lastLayoutWidthDip_ > 0.0f && lastLayoutHeightDip_ > 0.0f)
|
||
{
|
||
layoutW = lastLayoutWidthDip_;
|
||
layoutH = lastLayoutHeightDip_;
|
||
}
|
||
scene->EnsureLayout({layoutW, layoutH});
|
||
scene->Render(impl_->resources);
|
||
}
|
||
const HRESULT hr = target->EndDraw();
|
||
if (hr == D2DERR_RECREATE_TARGET)
|
||
{
|
||
impl_->resources.DiscardTarget();
|
||
return;
|
||
}
|
||
impl_->resources.Present();
|
||
}
|
||
|
||
void CandidatePresenter::PresentEmptyFrame()
|
||
{
|
||
if (!bound_ || !impl_)
|
||
{
|
||
return;
|
||
}
|
||
ID2D1RenderTarget *target = impl_->resources.GetRenderTarget();
|
||
if (!target)
|
||
{
|
||
return;
|
||
}
|
||
target->BeginDraw();
|
||
target->Clear(D2D1::ColorF(0, 0.0f));
|
||
if (target->EndDraw() == D2DERR_RECREATE_TARGET)
|
||
{
|
||
impl_->resources.DiscardTarget();
|
||
return;
|
||
}
|
||
impl_->resources.Present();
|
||
}
|
||
|
||
void CandidatePresenter::ArmHoverIfPointerMoved()
|
||
{
|
||
POINT now{};
|
||
if (!GetCursorPos(&now))
|
||
{
|
||
return;
|
||
}
|
||
const int dx = now.x - hoverBaseline_.x;
|
||
const int dy = now.y - hoverBaseline_.y;
|
||
if (dx * dx + dy * dy < 4)
|
||
{
|
||
return;
|
||
}
|
||
hoverArmed_ = true;
|
||
if (impl_ && impl_->list)
|
||
{
|
||
impl_->list->SetHoverEnabled(true);
|
||
}
|
||
if (impl_ && impl_->pager)
|
||
{
|
||
impl_->pager->SetHoverEnabled(true);
|
||
}
|
||
}
|
||
|
||
bool CandidatePresenter::HandleMessage(UINT message, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
if (!bound_ || !impl_ || !impl_->window)
|
||
{
|
||
return false;
|
||
}
|
||
switch (message)
|
||
{
|
||
case WM_ERASEBKGND:
|
||
return true;
|
||
case WM_PAINT: {
|
||
PAINTSTRUCT ps{};
|
||
BeginPaint(hwnd_, &ps);
|
||
Present();
|
||
EndPaint(hwnd_, &ps);
|
||
return true;
|
||
}
|
||
case WM_SIZE:
|
||
if (::is_global_wnd_cand_shown)
|
||
{
|
||
impl_->resources.Resize(static_cast<UINT>(LOWORD(lParam)), static_cast<UINT>(HIWORD(lParam)));
|
||
if (!placingHost_)
|
||
{
|
||
Present();
|
||
}
|
||
}
|
||
return true;
|
||
case WM_MOUSEMOVE:
|
||
ArmHoverIfPointerMoved();
|
||
if (!hoverArmed_ && !(impl_ && impl_->contextMenuOpen))
|
||
{
|
||
return true;
|
||
}
|
||
impl_->window->DispatchImportedMessage(message, wParam, lParam);
|
||
Present();
|
||
return true;
|
||
case WM_LBUTTONDOWN:
|
||
case WM_LBUTTONUP:
|
||
case WM_RBUTTONUP:
|
||
case WM_MOUSELEAVE:
|
||
impl_->window->DispatchImportedMessage(message, wParam, lParam);
|
||
Present();
|
||
return true;
|
||
case WM_MOUSEWHEEL: {
|
||
if (!GetConfiguredPagingMouseWheelEnabled())
|
||
{
|
||
// Leave the message to DefWindowProc, exactly as before the feature
|
||
// existed. WM_PAGE_CANDIDATE checks the same setting for both hosts;
|
||
// this early-out only keeps a disabled wheel from being swallowed.
|
||
wheelDeltaAccumulator_ = 0;
|
||
return false;
|
||
}
|
||
if (!::is_global_wnd_cand_shown)
|
||
{
|
||
// Hide() only parks the host off-screen, so a wheel message posted
|
||
// just before the page went away can still arrive here.
|
||
wheelDeltaAccumulator_ = 0;
|
||
return true;
|
||
}
|
||
if (impl_->contextMenuOpen)
|
||
{
|
||
// Scrolling dismisses the open context menu and consumes the event.
|
||
wheelDeltaAccumulator_ = 0;
|
||
CloseContextMenu(true);
|
||
return true;
|
||
}
|
||
const CandidateWheel::PagingSteps steps =
|
||
CandidateWheel::ConsumeWheelDelta(wheelDeltaAccumulator_, GET_WHEEL_DELTA_WPARAM(wParam), WHEEL_DELTA);
|
||
// Route through the host WndProc like every other candidate UI action
|
||
// instead of reaching into the IPC layer from the window layer.
|
||
if (steps.page_up > 0)
|
||
{
|
||
PostMessageW(hwnd_, WM_PAGE_CANDIDATE, CANDIDATE_PAGE_PREVIOUS, steps.page_up);
|
||
}
|
||
if (steps.page_down > 0)
|
||
{
|
||
PostMessageW(hwnd_, WM_PAGE_CANDIDATE, CANDIDATE_PAGE_NEXT, steps.page_down);
|
||
}
|
||
return true;
|
||
}
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
|
||
CandidatePresenter::~CandidatePresenter() = default;
|