                                                                         (for [[_ c] (:children component)] c))))]
                                                    requesting-child-id
                                                    (if (not (:focusable component))
-                                                     (get-in-cycle component :first)))]
-                                 (focus-child child-id)
+                                                     (get-in-cycle
+                                                       component
+                                                       ;; In case latest focus movent direction is tracked
+                                                       ;; in :throw-mode - use it to determine firt or last
+                                                       (if (= :prev (:throw-mode parent-focus-state))
+                                                         :last
+                                                         :first))))]
+                                 (focus-child-by-direction child-id (:throw-mode parent-focus-state))
                                  having-focus-state)
-                               old-focus-state)
+                               ;; No change in state but track focus movent direction
+                               (assoc old-focus-state :throw-mode (:throw-mode parent-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)
                                    (temporarily-taken-from-state this-focused-child)
                                    (focus-child next-child))
                                  {:mode :throws-focus
                                   :throw-mode :next
                                   :focused-child this-focused-child})

                          ;; Just rethrow out in :prev direction
                          :out-of-cycle-prev {:mode :throws-focus
                                              :throw-mode :prev
                                              :focused-child this-focused-child}

                          ;; Just rethrow out in :next direction
                          :out-of-cycle-next {:mode :throws-focus
                                              :throw-mode :next
                                              :focused-child this-focused-child})))

      :else ; Neither event type - ignore

      (let [child-id (nth reason 1)
            child-focus-state (get-property [:this child-id] :focus-state)
            child-mode (:mode child-focus-state)
            child-throw-mode (:throw-mode child-focus-state)]
        (case child-mode
          ;; Nothing to change in this case
          :none old-focus-state

          ;; If my child is the parent of focused component (or parent of parent ...)
          ;; then I'm :parent-of-focused as well
          :parent-of-focused (focus-child-by-direction child-id child-throw-mode)

          ;; My child has focus itself - same thing
          :has-focus (focus-child-by-direction child-id child-throw-mode)

          :requests-focus (case this-mode
                            ;; I'm the parent of focused component (no matter which exactly) and my child requests
                            ;; focus - then I note that this child becomes the new focus owner. My :mode stays the same
                            :parent-of-focused (focus-child-by-direction child-id (:throw-mode old-focus-state))

                            ;; If I have focus and my child requests it - I give focus to it
                            :has-focus (focus-child child-id)
