                                                    (if (not (:focusable component))
                                                      (get-in-cycle component :first)))]
                                  (focus-child child-id)
-                                 {:mode :has-focus
-                                  :focused-child nil})
+                                 having-focus-state)
                                old-focus-state)
 
                              ;; Another component next to me has focus, therefore my state is clean

        {:mode :requests-focus
         :focused-child this-focused-child}
        (and (:closed-focus-root component) (#{:none :throws-focus :requests-focus} this-mode))
        {:mode :has-focus
         :focused-child nil}
        :else old-focus-state)

      (fgc/parent-reason? reason)
      (case parent-mode
        :has-focus clean-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,

                          ;; But if I'm not a closed root then there may be no next child,
                          ;; get-in-cycle returns nil in this case. Rethrow it out in this case
                          :next (if-let [next-child (get-in-cycle component :next this-focused-child)]
                                  (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})
