Fix keyboard focus handling

Author: kunitoki

docs/images/yup_component_profiler.png

@@ -37,6 +37,10 @@ Component::Component (StringRef componentID)
 
 Component::~Component()
 {
+#if YUP_ENABLE_COMPONENT_PAINT_PROFILING
+    setPaintProfilingEnabled (false);
+#endif
+
     if (options.onDesktop)
         removeFromDesktop();
 
@@ -902,6 +906,21 @@ void Component::setWantsKeyboardFocus (bool wantsFocus)
     options.wantsKeyboardFocus = wantsFocus;
 }
 
+bool Component::getWantsKeyboardFocus() const
+{
+    return options.wantsKeyboardFocus;
+}
+
+void Component::setClickingGrabFocus (bool shouldGrabFocus)
+{
+    options.clickingDoesNotGrabFocus = ! shouldGrabFocus;
+}
+
+bool Component::getClickingGrabFocus() const
+{
+    return ! options.clickingDoesNotGrabFocus;
+}
+
 void Component::takeKeyboardFocus()
 {
     if (! options.wantsKeyboardFocus)
@@ -937,6 +956,20 @@ void Component::focusLost() {}
 
 //==============================================================================
 
+void Component::handleKeyboardFocusFromClick()
+{
+    for (auto* component = this; component != nullptr; component = component->parentComponent)
+    {
+        if (component->options.wantsKeyboardFocus && ! component->options.clickingDoesNotGrabFocus)
+        {
+            component->takeKeyboardFocus();
+            return;
+        }
+    }
+}
+
+//==============================================================================
+
 NamedValueSet& Component::getProperties()
 {
     return properties;
@@ -1123,6 +1156,141 @@ bool Component::hasOpaqueChildCoveringArea (const Rectangle<float>& area)
     return false;
 }
 
+#if YUP_ENABLE_COMPONENT_PAINT_PROFILING
+
+//==============================================================================
+
+void Component::setPaintProfilingEnabled (bool shouldBeEnabled, PaintProfileOptions options)
+{
+    if (shouldBeEnabled)
+    {
+        if (paintProfileStats == nullptr
+            || paintProfileStats->getCapacity() != options.sampleCapacity)
+        {
+            paintProfileStats = std::make_unique<PaintProfileStats> (options);
+        }
+        PaintProfiler::getInstance().registerComponent (*this, *paintProfileStats);
+    }
+    else
+    {
+        PaintProfiler::getInstance().deregisterComponent (*this);
+        paintProfileStats.reset();
+    }
+}
+
+bool Component::isPaintProfilingEnabled() const
+{
+    return paintProfileStats != nullptr;
+}
+
+void Component::resetPaintProfiling()
+{
+    if (paintProfileStats != nullptr)
+        paintProfileStats->reset();
+}
+
+PaintProfileStats* Component::getPaintProfileStats()
+{
+    return paintProfileStats.get();
+}
+
+const PaintProfileStats* Component::getPaintProfileStats() const
+{
+    return paintProfileStats.get();
+}
+
+String Component::getPaintProfileName() const
+{
+    if (componentTitle.isNotEmpty())
+        return componentTitle;
+
+    if (componentID.isNotEmpty())
+        return componentID;
+
+    return "Component";
+}
+
+//==============================================================================
+
+struct PaintProfileScopeEntry
+{
+    double childrenMicros = 0.0;
+};
+
+thread_local std::vector<PaintProfileScopeEntry> paintProfileScopeStack;
+static std::atomic<uint64> globalPaintIndexCounter { 0 };
+
+class PaintProfileScope
+{
+public:
+    PaintProfileScope (Component& component,
+                       const Rectangle<float>& repaintArea,
+                       bool renderContinuous,
+                       uint64 frameIndex)
+        : component (component)
+        , sample()
+        , totalStartMicros (ticksToMicros (Time::getHighResolutionTicks()))
+        , selfStartMicros (0.0)
+    {
+        sample.frameIndex = frameIndex;
+        sample.paintIndex = globalPaintIndexCounter.fetch_add (1, std::memory_order_relaxed);
+        sample.repaintArea = repaintArea;
+        sample.componentBounds = component.getBoundsRelativeToTopLevelComponent().to<float>();
+        sample.renderContinuous = renderContinuous;
+
+        paintProfileScopeStack.push_back ({});
+    }
+
+    ~PaintProfileScope()
+    {
+        const double totalEndMicros = ticksToMicros (Time::getHighResolutionTicks());
+        sample.totalMicros = totalEndMicros - totalStartMicros;
+        sample.childrenMicros = paintProfileScopeStack.back().childrenMicros;
+        paintProfileScopeStack.pop_back();
+
+        sample.frameworkMicros = std::max (0.0,
+                                           sample.totalMicros
+                                               - sample.selfMicros
+                                               - sample.childrenMicros);
+
+        if (auto* stats = component.getPaintProfileStats())
+            stats->recordSample (sample);
+
+        if (! paintProfileScopeStack.empty())
+            paintProfileScopeStack.back().childrenMicros += sample.totalMicros;
+    }
+
+    void beginSelf()
+    {
+        selfStartMicros = ticksToMicros (Time::getHighResolutionTicks());
+    }
+
+    void endSelf()
+    {
+        sample.selfMicros += ticksToMicros (Time::getHighResolutionTicks()) - selfStartMicros;
+    }
+
+    void markSelfPaintSkipped()
+    {
+        sample.selfPaintSkipped = true;
+    }
+
+private:
+    static double ticksToMicros (int64 ticks)
+    {
+        return Time::highResolutionTicksToSeconds (ticks) * 1.0e6;
+    }
+
+    Component& component;
+    PaintProfileSample sample;
+    double totalStartMicros;
+    double selfStartMicros;
+
+    YUP_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (PaintProfileScope)
+};
+
+#endif // YUP_ENABLE_COMPONENT_PAINT_PROFILING
+
 //==============================================================================
 
 void Component::internalRefreshDisplay (double lastFrameTimeSeconds)
@@ -1173,6 +1341,51 @@ void Component::internalPaint (Graphics& g, const Rectangle<float>& repaintArea,
 
     options.isRepainting = true;
 
+#if YUP_ENABLE_COMPONENT_PAINT_PROFILING
+    const bool profilingActive = PaintProfiler::getInstance().isEnabled()
+                              && paintProfileStats != nullptr;
+
+    if (profilingActive)
+    {
+        const auto frameIndex = PaintProfiler::getInstance().getCurrentFrameIndex();
+        PaintProfileScope profileScope (*this, repaintArea, renderContinuous, frameIndex);
+
+        {
+            const auto globalState = g.saveState();
+
+            g.setOpacity (opacity);
+            g.setDrawingArea (bounds);
+            if (! options.unclippedRendering)
+                g.setClipPath (boundsToRedraw);
+
+            g.setTransform (transform);
+
+            bool canSkipPaint = false;
+            if (! options.unclippedRendering && ! isTransformed())
+                canSkipPaint = hasOpaqueChildCoveringArea (boundsToRedraw);
+
+            if (! canSkipPaint)
+            {
+                const auto paintState = g.saveState();
+                profileScope.beginSelf();
+                paint (g);
+                profileScope.endSelf();
+            }
+            else
+            {
+                profileScope.markSelfPaintSkipped();
+            }
+
+            for (auto child : children)
+                child->internalPaint (g, boundsToRedraw, renderContinuous);
+
+            profileScope.beginSelf();
+            paintOverChildren (g);
+            profileScope.endSelf();
+        }
+    }
+    else
+#endif
     {
         const auto globalState = g.saveState();
 
@@ -1202,7 +1415,7 @@ void Component::internalPaint (Graphics& g, const Rectangle<float>& repaintArea,
 
     options.isRepainting = false;
 
-#if YUP_ENABLE_COMPONENT_REPAINT_DEBUGGING
+#if YUP_ENABLE_COMPONENT_PAINT_DEBUGGING
     g.setFillColor (debugColor);
     g.setOpacity (0.2f);
     g.fillAll();
@@ -1264,6 +1477,11 @@ void Component::internalMouseDown (const MouseEvent& event)
 
     auto bailOutChecker = BailOutChecker (this);
 
+    handleKeyboardFocusFromClick();
+
+    if (bailOutChecker.shouldBailOut())
+        return;
+
     mouseDown (event);
 
     if (bailOutChecker.shouldBailOut())

modules/yup_gui/component/yup_Component.cpp

@@ -746,6 +746,32 @@ class YUP_API Component : public MouseListener
      */
     void setWantsKeyboardFocus (bool wantsFocus);
 
+    /**
+        Check whether this component wants keyboard focus.
+
+        @return True if this component wants keyboard focus, false otherwise.
+     */
+    bool getWantsKeyboardFocus() const;
+
+    /**
+        Set whether clicking this component can make it grab keyboard focus.
+
+        When a component is clicked, focus handling walks from the clicked
+        component up through its parents until it finds a component that both
+        wants keyboard focus and has this flag enabled. This is enabled by
+        default.
+
+        @param shouldGrabFocus True if mouse clicks can grab keyboard focus.
+     */
+    void setClickingGrabFocus (bool shouldGrabFocus);
+
+    /**
+        Check whether clicking this component can make it grab keyboard focus.
+
+        @return True if mouse clicks can grab keyboard focus.
+     */
+    bool getClickingGrabFocus() const;
+
     /**
         Take the focus.
      */
@@ -1152,6 +1178,45 @@ class YUP_API Component : public MouseListener
      */
     std::optional<var> findStyleProperty (const Identifier& propertyId) const;
 
+#if YUP_ENABLE_COMPONENT_PAINT_PROFILING
+    //==============================================================================
+    /** Enables or disables paint profiling for this component.
+
+        When enabling, a PaintProfileStats instance is created (if not already present)
+        and the component is registered with PaintProfiler. Existing samples are
+        preserved when re-enabling with the same capacity.
+
+        When disabling, the component is deregistered from PaintProfiler and the
+        stats object is destroyed.
+
+        @param shouldBeEnabled  Pass true to enable, false to disable.
+        @param options          Controls the ring buffer capacity and recording behaviour.
+    */
+    void setPaintProfilingEnabled (bool shouldBeEnabled,
+                                   PaintProfileOptions options = {});
+
+    /** Returns true if paint profiling is currently enabled for this component. */
+    bool isPaintProfilingEnabled() const;
+
+    /** Clears all paint profile samples recorded for this component. */
+    void resetPaintProfiling();
+
+    /** Returns a pointer to this component's PaintProfileStats, or nullptr if
+        profiling is not enabled. */
+    PaintProfileStats* getPaintProfileStats();
+
+    /** Returns a const pointer to this component's PaintProfileStats, or nullptr
+        if profiling is not enabled. */
+    const PaintProfileStats* getPaintProfileStats() const;
+
+    /** Returns the display name used for this component in profiling snapshots.
+
+        Prefers (in order): a non-empty component title, a non-empty component ID,
+        the demangled type name if available, then falls back to "Component".
+    */
+    String getPaintProfileName() const;
+#endif
+
     //==============================================================================
     /** A bail out checker for the component. */
     class BailOutChecker
@@ -1233,6 +1298,8 @@ class YUP_API Component : public MouseListener
     void internalAttachedToNative();
     void internalDetachedFromNative();
 
+    void handleKeyboardFocusFromClick();
+
     void updateMouseCursor();
 
     bool hasOpaqueChildCoveringArea (const Rectangle<float>& area);
@@ -1266,6 +1333,7 @@ class YUP_API Component : public MouseListener
         bool isTransparent : 1;
         bool unclippedRendering : 1;
         bool wantsKeyboardFocus : 1;
+        bool clickingDoesNotGrabFocus : 1;
         bool isRepainting : 1;
         bool blockSelfMouseEvents : 1;
         bool blockChildrenMouseEvents : 1;
@@ -1277,11 +1345,15 @@ class YUP_API Component : public MouseListener
         Options options;
     };
 
-#if YUP_ENABLE_COMPONENT_REPAINT_DEBUGGING
+#if YUP_ENABLE_COMPONENT_PAINT_DEBUGGING
     Color debugColor = Color::opaqueRandom();
     int counter = 2;
 #endif
 
+#if YUP_ENABLE_COMPONENT_PAINT_PROFILING
+    std::unique_ptr<PaintProfileStats> paintProfileStats;
+#endif
+
     YUP_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Component)
 };