         ;; Otherwise my parent has focus permanently and my state is clean
         :has-focus (if (= parent-focused-child (:id component)) ; This condition means that parent has focus temporarily
                      ;; Parent keeps latest throwing direction in :throw-mode in this case. Track it for further use
-                     (assoc having-focus-state :throw-mode (:throw-mode parent-focus-state))
+                     (assoc (having-focus-state component (str "from parent " parent-id " that kept temporary")) :throw-mode (:throw-mode parent-focus-state))
                      clean-state)
-        ;:has-focus clean-state
+        :got-trigger (if (= this-mode :got-trigger)
+                       clean-state
+                       (if (:focusable component)
+                         having-focus-state
+                         (if-let [child-id (get-in-cycle component :first nil)]
+                           (focus-child-by-direction child-id :next)
+                           old-focus-state)))
         :none clean-state
         :parent-of-focused (if (= parent-focused-child (:id component))
                              ;; If my parent is :parent-of-focused and I am :parent-of-focused,


                            ;; My child request focus and I throw focus - then I let this child get focus
                            :throws-focus (focus-child child-id))
          :throws-focus (case child-throw-mode
                          ;; My child throws focus in :prev direction. Give focus to previous child.
                          ;; But if I'm not a closed root then there may be no previous child,

                                              :throw-mode (if (:closed-focus-root component)
                                                            :next
                                                            :out-of-cycle-next)
                                              :focused-child this-focused-child})

          :got-trigger (cond
                         (:focusable component)
                         (having-focus-state component "trigger")
                         (or
                           (:closed-focus-root component)
                           (get-in-cycle component :first nil))
                         (temporarily-taken-from-state component "trigger"      ;TODO This worked nicely even with tester widged but broke slider
                           (if-let [first-to-give (get-in-cycle component :first nil)]
                              first-to-give
                              child-id)
                           nil)
                         :else
                         {:mode :got-trigger
                          :focused-child nil})))

      :else ; Neither event type - ignore
      old-focus-state)))