       (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)
-            _ (println "Child even into " (:id component) " child " child-id " mode " child-mode " thm " child-throw-mode)]
+            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 child-id)
+          :parent-of-focused (focus-child-by-direction child-id child-throw-mode)
 
           ;; My child has focus itself - same thing
-          :has-focus (focus-child child-id)
+          :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 child-id)
+                            :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)

        :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)
        ;; 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
                     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)
                                    ;; 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
