                                     ;; 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)
+                                    (temporarily-taken-from-state component (str "next, reason: " child-id) this-focused-child :next)
                                     (focus-child-by-direction next-child :next))
                                   {:mode :throws-focus
                                    :throw-mode :next

(def clean-state {:mode :none
                  :focused-child nil})

(def having-focus-state {:mode :has-focus
                         :focused-child nil})

(defn temporarily-taken-from-state [permanent-owner-child dir] {:mode :has-focus
                                                                :focused-child permanent-owner-child
                                                                :throw-mode dir})

(defn focus-child [child-id]
  (if (keyword? child-id)

        ;; 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
                     ;; Parent keeps latest throwing direction in :throw-mode in this case. Track it for further use
                     (assoc (having-focus-state component (str "from parent " parent-id " that kept temporary")) :throw-mode (:throw-mode parent-focus-state))
                     clean-state)
        :got-trigger (if (= this-mode :got-trigger)
                       clean-state
                       (if (:focusable component)
                         having-focus-state
                         (if-let [child-id (get-in-cycle component :first nil)]
                           (focus-child-by-direction child-id :next)
                           old-focus-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,
