         :else old-focus-state)
 
       (fgc/parent-reason? reason)
-      (case (do (println "Parent event into " (:id component) " parent-mode " parent-mode " this-mode " this-mode) parent-mode)
+      (case parent-mode
         ;; If parent has focus temporarily, I take focus back (*2)
         ;; 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
-                     having-focus-state
+                     ;; 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))
                      clean-state)
         ;:has-focus clean-state
         :none 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

                                                                        (for [[_ c] (:children component)] c))))]
                                                   requesting-child-id
                                                   (if (not (:focusable component))
                                                     (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)
                               ;; 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)
