                                   (if (= prev-child this-focused-child)
                                     ;; My child throws focus, but there is no other component to take it.
                                     ;; So I take it temporarily and child will take back within the next step. (*2)
-                                    (temporarily-taken-from-state this-focused-child)
-                                    (focus-child prev-child))
+                                    ;; Latest movement direction is tracked to be used within the next step
+                                    (temporarily-taken-from-state this-focused-child :prev)
+                                    (focus-child-by-direction prev-child :prev))
                                   {:mode :throws-focus
                                    :throw-mode :prev
                                    :focused-child this-focused-child})

                                                                        (for [[_ c] (:children component)] c))))]
                                                   requesting-child-id
                                                   (if (not (:focusable component))
                                                     (get-in-cycle component :first)))]
                                 (focus-child child-id)
                                 having-focus-state)
                               old-focus-state)

                             ;; Another component next to me has focus, therefore my state is clean
                             clean-state)

                                  (if (= next-child this-focused-child)
                                    ;; My child throws focus, but there is no other component to take it.
                                    ;; So I take it temporarily and child will take back within the next step. (*2)
                                    ;; Latest movement direction is tracked to be used within the next step
                                    (temporarily-taken-from-state this-focused-child :next)
                                    (focus-child-by-direction next-child :next))
                                  {:mode :throws-focus
                                   :throw-mode :next
                                   :focused-child this-focused-child})

                          ;; Rethrow up to nearest closed cycle root
                          :out-of-cycle-prev {:mode :throws-focus
                                              :throw-mode (if (:closed-focus-root component)
                                                            :prev
                                                            :out-of-cycle-prev)
                                              :focused-child this-focused-child}

                          ;; Rethrow up to nearest closed cycle root
                          :out-of-cycle-next {:mode :throws-focus
                                              :throw-mode (if (:closed-focus-root component)
                                                            :next
                                                            :out-of-cycle-next)
                                              :focused-child this-focused-child})))

      :else ; Neither event type - ignore
