diff --git a/ui/README.md b/ui/README.md
index fceafb2d..4395494c 100644
--- a/ui/README.md
+++ b/ui/README.md
@@ -49,6 +49,7 @@
 - 新增一版真正参与布局调度的 `arrange subtree dirty`：`Visual::InvalidateArrange()` 现在会把源控件一路上传到 `Scene`，`Scene` 会记录需要重排的最小公共祖先；在无需重测时，会优先只重排那一支子树，而不是整棵根树
 - 进一步补上 `measure dirty` 的源追踪：`Scene` 现在会记录测量脏源，并在条件允许时优先按脏路径重测，再结合 `Visual` 的布局缓存尽量跳过无关分支
 - 新增最小主题系统 `Theme / ThemeManager`：窗口背景、按钮、复选框、进度条、滑块、滚动条、`TextBlock` 字体和 `TextBox` 的部分视觉令牌已开始迁移到统一主题入口，便于后续做换肤和样式集中管理
+- 新增第一版 `PopupHost / Popup` 弹出层系统：`Scene` 现可管理 overlay popup，支持高于主视觉树的渲染顺序、命中测试、滚轮路由、窗口重排后的重新定位，以及点击空白区域自动关闭；demo 已加入一个快速操作弹出层示例
 
 ## 构建
 
diff --git a/ui/demos/msimeui-demo/DemoScene.cpp b/ui/demos/msimeui-demo/DemoScene.cpp
index fb3f1fcc..80de146e 100644
--- a/ui/demos/msimeui-demo/DemoScene.cpp
+++ b/ui/demos/msimeui-demo/DemoScene.cpp
@@ -367,6 +367,42 @@ std::unique_ptr<Scene> CreateDemoScene()
     root->AddChild(tabsCard);
     root->AddChild(std::make_shared<Spacer>(24.0f));
 
+    auto popupCard = std::make_shared<Card>(surface, 20.0f);
+    auto popupStack = std::make_shared<StackPanel>(14.0f);
+    auto popupStatus = std::make_shared<TextBlock>(L"Popup status: closed", 14.0f, D2D1::ColorF(0x475569), true);
+    auto popupTrigger = std::make_shared<Button>(L"Open Quick Actions", 44.0f);
+    popupTrigger->SetWidth(200.0f);
+
+    auto popupContent = std::make_shared<StackPanel>(10.0f);
+    popupContent->AddChild(std::make_shared<TextBlock>(L"Quick Actions", 16.0f, D2D1::ColorF(0x1F2937), true));
+    popupContent->AddChild(std::make_shared<TextBlock>(
+        L"This popup is rendered as a scene-level overlay. It sits above the normal visual tree and closes on outside click.",
+        13.0f, D2D1::ColorF(0x64748B)));
+    auto popupActionA = std::make_shared<Button>(L"Mark Stable", 38.0f);
+    auto popupActionB = std::make_shared<Button>(L"Mark Experimental", 38.0f);
+    popupActionA->SetWidth(160.0f);
+    popupActionB->SetWidth(190.0f);
+    popupActionA->SetOnClick([popupStatus]() { popupStatus->SetText(L"Popup status: marked stable"); });
+    popupActionB->SetOnClick([popupStatus]() { popupStatus->SetText(L"Popup status: marked experimental"); });
+    popupContent->AddChild(popupActionA);
+    popupContent->AddChild(popupActionB);
+
+    auto popup = std::make_shared<Popup>(popupContent);
+    popup->SetMatchAnchorWidth(false);
+    popup->SetWidth(300.0f);
+
+    auto popupHost = std::make_shared<PopupHost>(popupTrigger, popup);
+
+    popupStack->AddChild(std::make_shared<TextBlock>(L"PopupHost / Popup", 20.0f, D2D1::ColorF(0x1F2937), true));
+    popupStack->AddChild(std::make_shared<TextBlock>(
+        L"A first overlay path is now available for menus, quick actions, tooltips, and future combo-box style interactions.",
+        14.0f, D2D1::ColorF(0x6B7280)));
+    popupStack->AddChild(popupStatus);
+    popupStack->AddChild(popupHost);
+    popupCard->AddChild(popupStack);
+    root->AddChild(popupCard);
+    root->AddChild(std::make_shared<Spacer>(24.0f));
+
     auto accordionCard = std::make_shared<Card>(surface, 20.0f);
     auto accordionStack = std::make_shared<StackPanel>(14.0f);
     auto accordion = std::make_shared<Accordion>(46.0f);
diff --git a/ui/include/msimeui/Controls.h b/ui/include/msimeui/Controls.h
index 162354ee..efbcccbc 100644
--- a/ui/include/msimeui/Controls.h
+++ b/ui/include/msimeui/Controls.h
@@ -10,6 +10,12 @@ class CTextEditor;
 
 namespace msimeui
 {
+enum class PopupPlacement
+{
+    BelowLeading,
+    AboveLeading,
+};
+
 class TextBox : public Visual
 {
   public:
@@ -80,6 +86,65 @@ class Button : public Visual
     ClickHandler onClick_;
 };
 
+class Popup : public Visual
+{
+  public:
+    explicit Popup(std::shared_ptr<Visual> child);
+
+    void SetAnchorRect(const RectF &anchorRect);
+    void SetPlacement(PopupPlacement placement);
+    void SetOffset(float x, float y);
+    void SetMatchAnchorWidth(bool matchAnchorWidth);
+
+    SizeF Measure(const SizeF &availableSize) override;
+    void Arrange(const RectF &finalRect) override;
+    void Render(DeviceResources &deviceResources) override;
+    void Attach(Window *window) override;
+    Visual *FindVisualAt(const PointF &point) override;
+    Visual *FindFocusableAt(const PointF &point) override;
+    Visual *FindFirstFocusableDescendant() override;
+    bool HitTest(const PointF &point) const override;
+    void LayoutOverlay(const SizeF &viewportSize) override;
+
+  private:
+    std::shared_ptr<Visual> child_;
+    RectF anchorRect_ = {};
+    PopupPlacement placement_ = PopupPlacement::BelowLeading;
+    float offsetX_ = 0.0f;
+    float offsetY_ = 8.0f;
+    bool matchAnchorWidth_ = true;
+};
+
+class PopupHost : public Visual
+{
+  public:
+    PopupHost(std::shared_ptr<Visual> trigger, std::shared_ptr<Popup> popup);
+
+    SizeF Measure(const SizeF &availableSize) override;
+    void Arrange(const RectF &finalRect) override;
+    void Render(DeviceResources &deviceResources) override;
+    void Attach(Window *window) override;
+    Visual *FindVisualAt(const PointF &point) override;
+    Visual *FindFocusableAt(const PointF &point) override;
+    Visual *FindFirstFocusableDescendant() override;
+    bool HitTest(const PointF &point) const override;
+    bool OnMouseDown(const POINT &point, WPARAM keyState) override;
+    bool OnMouseUp(const POINT &point, WPARAM keyState) override;
+    HCURSOR GetCursor() const override;
+    bool KeepsPopupsOpenOnClick() const override;
+
+    void OpenPopup();
+    void ClosePopup();
+    void TogglePopup();
+    bool IsOpen() const;
+
+  private:
+    std::shared_ptr<Visual> trigger_;
+    std::shared_ptr<Popup> popup_;
+    bool pressed_ = false;
+    bool open_ = false;
+};
+
 class CheckBox : public Visual
 {
   public:
diff --git a/ui/include/msimeui/Layout.h b/ui/include/msimeui/Layout.h
index 94a494e0..22e82712 100644
--- a/ui/include/msimeui/Layout.h
+++ b/ui/include/msimeui/Layout.h
@@ -68,6 +68,8 @@ class Visual
     virtual bool OnChar(wchar_t ch, LPARAM lParam);
     virtual bool OnTimer(UINT_PTR timerId);
     virtual HCURSOR GetCursor() const;
+    virtual void LayoutOverlay(const SizeF &viewportSize);
+    virtual bool KeepsPopupsOpenOnClick() const;
     void InvalidateMeasure();
     void InvalidateArrange();
     void InvalidateVisual();
diff --git a/ui/include/msimeui/Scene.h b/ui/include/msimeui/Scene.h
index ffea05e3..5bf61dc7 100644
--- a/ui/include/msimeui/Scene.h
+++ b/ui/include/msimeui/Scene.h
@@ -2,17 +2,29 @@
 
 #include "Layout.h"
 
+#include <functional>
 #include <memory>
+#include <vector>
 
 namespace msimeui
 {
 class Scene
 {
   public:
+    struct PopupEntry
+    {
+        std::shared_ptr<Visual> visual;
+        std::function<void()> onClose;
+    };
+
     void SetRoot(std::shared_ptr<Visual> root);
     void Attach(Window *window);
     void EnsureLayout(const SizeF &size);
     void Layout(const SizeF &size);
+    void AddPopup(std::shared_ptr<Visual> popup, std::function<void()> onClose = {});
+    void RemovePopup(Visual *popup, bool notify = true);
+    void ClearPopups(bool notify = true);
+    bool DismissPopupsForClick(const PointF &point, Visual *target);
     void InvalidateMeasure();
     void InvalidateMeasure(Visual *source);
     void InvalidateArrange();
@@ -25,6 +37,7 @@ class Scene
 
   private:
     std::shared_ptr<Visual> root_;
+    std::vector<PopupEntry> popups_;
     Window *window_ = nullptr;
     Visual *measureDirtySource_ = nullptr;
     Visual *arrangeDirtyRoot_ = nullptr;
diff --git a/ui/include/msimeui/Window.h b/ui/include/msimeui/Window.h
index 6702f26b..5f329859 100644
--- a/ui/include/msimeui/Window.h
+++ b/ui/include/msimeui/Window.h
@@ -19,6 +19,7 @@ class Window
 
     HWND GetHandle() const;
     HINSTANCE GetInstance() const;
+    Scene *GetScene() const;
     DeviceResources &GetDeviceResources();
     float GetDpi() const;
     PointF ClientPixelsToDips(const POINT &point) const;
diff --git a/ui/src/Controls.cpp b/ui/src/Controls.cpp
index 61882a86..e306ef7c 100644
--- a/ui/src/Controls.cpp
+++ b/ui/src/Controls.cpp
@@ -45,6 +45,19 @@ RectF MakeInsetRect(const RectF &rect, float insetX, float insetY)
             std::max(rect.height - insetY * 2.0f, 0.0f)};
 }
 
+SizeF DeflateSizeLocal(const SizeF &size, const Thickness &thickness)
+{
+    return {std::max(size.width - thickness.left - thickness.right, 0.0f),
+            std::max(size.height - thickness.top - thickness.bottom, 0.0f)};
+}
+
+RectF DeflateRectLocal(const RectF &rect, const Thickness &thickness)
+{
+    return {rect.x + thickness.left, rect.y + thickness.top,
+            std::max(rect.width - thickness.left - thickness.right, 0.0f),
+            std::max(rect.height - thickness.top - thickness.bottom, 0.0f)};
+}
+
 bool PointInRect(const RectF &rect, const PointF &point)
 {
     return point.x >= rect.x && point.x <= (rect.x + rect.width) && point.y >= rect.y &&
@@ -199,6 +212,300 @@ void Button::SetOnClick(ClickHandler handler)
     onClick_ = std::move(handler);
 }
 
+Popup::Popup(std::shared_ptr<Visual> child) : child_(std::move(child))
+{
+    AdoptChild(child_);
+    SetPadding({12.0f, 12.0f, 12.0f, 12.0f});
+}
+
+void Popup::SetAnchorRect(const RectF &anchorRect)
+{
+    anchorRect_ = anchorRect;
+}
+
+void Popup::SetPlacement(PopupPlacement placement)
+{
+    placement_ = placement;
+}
+
+void Popup::SetOffset(float x, float y)
+{
+    offsetX_ = x;
+    offsetY_ = y;
+}
+
+void Popup::SetMatchAnchorWidth(bool matchAnchorWidth)
+{
+    matchAnchorWidth_ = matchAnchorWidth;
+}
+
+SizeF Popup::Measure(const SizeF &availableSize)
+{
+    const SizeF inner = DeflateSizeLocal(availableSize, padding_);
+    if (!child_)
+    {
+        return {padding_.left + padding_.right, padding_.top + padding_.bottom};
+    }
+
+    const SizeF childSize = child_->MeasureInLayout(inner);
+    return {childSize.width + padding_.left + padding_.right, childSize.height + padding_.top + padding_.bottom};
+}
+
+void Popup::Arrange(const RectF &finalRect)
+{
+    bounds_ = finalRect;
+    if (child_)
+    {
+        child_->ArrangeInLayout(DeflateRectLocal(bounds_, padding_));
+    }
+}
+
+void Popup::Render(DeviceResources &deviceResources)
+{
+    ID2D1HwndRenderTarget *target = deviceResources.GetRenderTarget();
+    if (!target)
+    {
+        return;
+    }
+
+    const Theme &theme = ThemeManager::GetCurrent();
+    FillRoundedRect(target, bounds_, 16.0f, theme.surface, theme.borderStrong, 1.0f);
+    if (child_)
+    {
+        child_->Render(deviceResources);
+    }
+}
+
+void Popup::Attach(Window *window)
+{
+    Visual::Attach(window);
+    if (child_)
+    {
+        child_->Attach(window);
+    }
+}
+
+Visual *Popup::FindVisualAt(const PointF &point)
+{
+    if (!HitTest(point))
+    {
+        return nullptr;
+    }
+
+    if (child_)
+    {
+        if (Visual *hit = child_->FindVisualAt(point))
+        {
+            return hit;
+        }
+    }
+
+    return this;
+}
+
+Visual *Popup::FindFocusableAt(const PointF &point)
+{
+    if (!HitTest(point))
+    {
+        return nullptr;
+    }
+
+    return child_ ? child_->FindFocusableAt(point) : nullptr;
+}
+
+Visual *Popup::FindFirstFocusableDescendant()
+{
+    return child_ ? child_->FindFirstFocusableDescendant() : nullptr;
+}
+
+bool Popup::HitTest(const PointF &point) const
+{
+    return PointInRect(bounds_, point);
+}
+
+void Popup::LayoutOverlay(const SizeF &viewportSize)
+{
+    const SizeF available = {std::max(viewportSize.width - 24.0f, 0.0f), std::max(viewportSize.height - 24.0f, 0.0f)};
+    const SizeF measured = MeasureInLayout(available);
+    const float width = matchAnchorWidth_ ? std::max(measured.width, anchorRect_.width) : measured.width;
+    const float height = measured.height;
+
+    float x = anchorRect_.x + offsetX_;
+    if (x + width > viewportSize.width - 8.0f)
+    {
+        x = std::max(viewportSize.width - width - 8.0f, 8.0f);
+    }
+
+    float y = placement_ == PopupPlacement::AboveLeading ? (anchorRect_.y - height - offsetY_)
+                                                         : (anchorRect_.y + anchorRect_.height + offsetY_);
+    if (placement_ == PopupPlacement::AboveLeading && y < 8.0f)
+    {
+        y = anchorRect_.y + anchorRect_.height + offsetY_;
+    }
+    if (placement_ == PopupPlacement::BelowLeading && y + height > viewportSize.height - 8.0f)
+    {
+        const float aboveY = anchorRect_.y - height - offsetY_;
+        if (aboveY >= 8.0f)
+        {
+            y = aboveY;
+        }
+    }
+
+    y = std::clamp(y, 8.0f, std::max(viewportSize.height - height - 8.0f, 8.0f));
+    ArrangeInLayout({x, y, width, height});
+}
+
+PopupHost::PopupHost(std::shared_ptr<Visual> trigger, std::shared_ptr<Popup> popup)
+    : trigger_(std::move(trigger)), popup_(std::move(popup))
+{
+    AdoptChild(trigger_);
+}
+
+SizeF PopupHost::Measure(const SizeF &availableSize)
+{
+    return trigger_ ? trigger_->MeasureInLayout(availableSize) : SizeF {};
+}
+
+void PopupHost::Arrange(const RectF &finalRect)
+{
+    bounds_ = finalRect;
+    if (trigger_)
+    {
+        trigger_->ArrangeInLayout(finalRect);
+    }
+    if (popup_)
+    {
+        popup_->SetAnchorRect(bounds_);
+    }
+}
+
+void PopupHost::Render(DeviceResources &deviceResources)
+{
+    if (trigger_)
+    {
+        trigger_->Render(deviceResources);
+    }
+}
+
+void PopupHost::Attach(Window *window)
+{
+    Visual::Attach(window);
+    if (trigger_)
+    {
+        trigger_->Attach(window);
+    }
+    if (popup_)
+    {
+        popup_->Attach(window);
+    }
+}
+
+Visual *PopupHost::FindVisualAt(const PointF &point)
+{
+    return HitTest(point) ? this : nullptr;
+}
+
+Visual *PopupHost::FindFocusableAt(const PointF &point)
+{
+    (void)point;
+    return nullptr;
+}
+
+Visual *PopupHost::FindFirstFocusableDescendant()
+{
+    return nullptr;
+}
+
+bool PopupHost::HitTest(const PointF &point) const
+{
+    return trigger_ ? trigger_->HitTest(point) : false;
+}
+
+bool PopupHost::OnMouseDown(const POINT &point, WPARAM keyState)
+{
+    (void)keyState;
+    if (!window_)
+    {
+        return false;
+    }
+
+    pressed_ = HitTest(window_->ClientPixelsToDips(point));
+    return pressed_;
+}
+
+bool PopupHost::OnMouseUp(const POINT &point, WPARAM keyState)
+{
+    (void)keyState;
+    if (!window_ || !pressed_)
+    {
+        return false;
+    }
+
+    const bool shouldToggle = HitTest(window_->ClientPixelsToDips(point));
+    pressed_ = false;
+    if (shouldToggle)
+    {
+        TogglePopup();
+    }
+    return true;
+}
+
+HCURSOR PopupHost::GetCursor() const
+{
+    return LoadCursor(nullptr, IDC_HAND);
+}
+
+bool PopupHost::KeepsPopupsOpenOnClick() const
+{
+    return true;
+}
+
+void PopupHost::OpenPopup()
+{
+    if (open_ || !window_ || !popup_)
+    {
+        return;
+    }
+
+    popup_->SetAnchorRect(bounds_);
+    if (Scene *scene = window_->GetScene())
+    {
+        scene->AddPopup(popup_, [this]() { open_ = false; });
+        open_ = true;
+    }
+}
+
+void PopupHost::ClosePopup()
+{
+    if (!open_ || !window_ || !popup_)
+    {
+        return;
+    }
+
+    if (Scene *scene = window_->GetScene())
+    {
+        scene->RemovePopup(popup_.get(), false);
+    }
+    open_ = false;
+}
+
+void PopupHost::TogglePopup()
+{
+    if (open_)
+    {
+        ClosePopup();
+    }
+    else
+    {
+        OpenPopup();
+    }
+}
+
+bool PopupHost::IsOpen() const
+{
+    return open_;
+}
+
 SizeF Button::Measure(const SizeF &availableSize)
 {
     const float textWidth = std::max(availableSize.width - kControlPaddingX * 2.0f, 1.0f);
diff --git a/ui/src/Layout.cpp b/ui/src/Layout.cpp
index da6375f8..9225ad03 100644
--- a/ui/src/Layout.cpp
+++ b/ui/src/Layout.cpp
@@ -192,6 +192,16 @@ HCURSOR Visual::GetCursor() const
     return LoadCursor(nullptr, IDC_ARROW);
 }
 
+void Visual::LayoutOverlay(const SizeF &viewportSize)
+{
+    (void)viewportSize;
+}
+
+bool Visual::KeepsPopupsOpenOnClick() const
+{
+    return false;
+}
+
 void Visual::InvalidateMeasure()
 {
     BubbleMeasureInvalidation(this);
diff --git a/ui/src/Scene.cpp b/ui/src/Scene.cpp
index a26fe543..949c5cf6 100644
--- a/ui/src/Scene.cpp
+++ b/ui/src/Scene.cpp
@@ -99,6 +99,13 @@ void Scene::Attach(Window *window)
     {
         root_->Attach(window);
     }
+    for (auto &popup : popups_)
+    {
+        if (popup.visual)
+        {
+            popup.visual->Attach(window);
+        }
+    }
 }
 
 void Scene::EnsureLayout(const SizeF &size)
@@ -156,6 +163,106 @@ void Scene::Layout(const SizeF &size)
     arrangeDirty_ = false;
     measureDirtySource_ = nullptr;
     arrangeDirtyRoot_ = nullptr;
+
+    for (auto &popup : popups_)
+    {
+        if (popup.visual)
+        {
+            popup.visual->LayoutOverlay(size);
+        }
+    }
+}
+
+void Scene::AddPopup(std::shared_ptr<Visual> popup, std::function<void()> onClose)
+{
+    if (!popup)
+    {
+        return;
+    }
+
+    for (const auto &entry : popups_)
+    {
+        if (entry.visual == popup)
+        {
+            return;
+        }
+    }
+
+    if (window_)
+    {
+        popup->Attach(window_);
+    }
+    popups_.push_back({std::move(popup), std::move(onClose)});
+    arrangeDirty_ = true;
+    InvalidateVisual();
+}
+
+void Scene::RemovePopup(Visual *popup, bool notify)
+{
+    if (!popup)
+    {
+        return;
+    }
+
+    auto it = std::find_if(popups_.begin(), popups_.end(), [popup](const PopupEntry &entry) { return entry.visual.get() == popup; });
+    if (it == popups_.end())
+    {
+        return;
+    }
+
+    std::function<void()> onClose = std::move(it->onClose);
+    popups_.erase(it);
+    if (notify && onClose)
+    {
+        onClose();
+    }
+    InvalidateVisual();
+}
+
+void Scene::ClearPopups(bool notify)
+{
+    if (popups_.empty())
+    {
+        return;
+    }
+
+    auto popups = std::move(popups_);
+    popups_.clear();
+    if (notify)
+    {
+        for (auto &entry : popups)
+        {
+            if (entry.onClose)
+            {
+                entry.onClose();
+            }
+        }
+    }
+    InvalidateVisual();
+}
+
+bool Scene::DismissPopupsForClick(const PointF &point, Visual *target)
+{
+    if (popups_.empty())
+    {
+        return false;
+    }
+
+    if (target && target->KeepsPopupsOpenOnClick())
+    {
+        return false;
+    }
+
+    for (auto it = popups_.rbegin(); it != popups_.rend(); ++it)
+    {
+        if (it->visual && it->visual->HitTest(point))
+        {
+            return false;
+        }
+    }
+
+    ClearPopups(true);
+    return true;
 }
 
 void Scene::InvalidateMeasure()
@@ -228,20 +335,54 @@ void Scene::Render(DeviceResources &deviceResources)
     {
         root_->Render(deviceResources);
     }
+    for (const auto &popup : popups_)
+    {
+        if (popup.visual)
+        {
+            popup.visual->Render(deviceResources);
+        }
+    }
 }
 
 Visual *Scene::FindVisualAt(const PointF &point)
 {
+    for (auto it = popups_.rbegin(); it != popups_.rend(); ++it)
+    {
+        if (it->visual)
+        {
+            if (Visual *hit = it->visual->FindVisualAt(point))
+            {
+                return hit;
+            }
+        }
+    }
     return root_ ? root_->FindVisualAt(point) : nullptr;
 }
 
 Visual *Scene::FindFocusableAt(const PointF &point)
 {
+    for (auto it = popups_.rbegin(); it != popups_.rend(); ++it)
+    {
+        if (it->visual)
+        {
+            if (Visual *focusable = it->visual->FindFocusableAt(point))
+            {
+                return focusable;
+            }
+        }
+    }
     return root_ ? root_->FindFocusableAt(point) : nullptr;
 }
 
 bool Scene::OnMouseWheel(const POINT &point, short delta, WPARAM keyState)
 {
+    for (auto it = popups_.rbegin(); it != popups_.rend(); ++it)
+    {
+        if (it->visual && it->visual->OnMouseWheel(point, delta, keyState))
+        {
+            return true;
+        }
+    }
     return root_ ? root_->OnMouseWheel(point, delta, keyState) : false;
 }
 } // namespace msimeui
diff --git a/ui/src/Window.cpp b/ui/src/Window.cpp
index c39f5d70..86487d79 100644
--- a/ui/src/Window.cpp
+++ b/ui/src/Window.cpp
@@ -78,6 +78,11 @@ HINSTANCE Window::GetInstance() const
     return instance_;
 }
 
+Scene *Window::GetScene() const
+{
+    return scene_.get();
+}
+
 DeviceResources &Window::GetDeviceResources()
 {
     return deviceResources_;
@@ -229,6 +234,9 @@ LRESULT Window::HandleMessage(UINT message, WPARAM wParam, LPARAM lParam)
             const PointF dipPoint = ClientPixelsToDips(point);
             Visual *target = scene_->FindVisualAt(dipPoint);
             Visual *focusTarget = scene_->FindFocusableAt(dipPoint);
+            scene_->DismissPopupsForClick(dipPoint, target);
+            target = scene_->FindVisualAt(dipPoint);
+            focusTarget = scene_->FindFocusableAt(dipPoint);
             Visual *dispatchTarget = focusTarget ? focusTarget : target;
             {
                 std::ostringstream log;