   variable inlets has been set."
   [this new-value]
   (let [inlet (.parentGetInlet this)]
-    (timbre/info "received float" new-value "on inlet" inlet)
     (if (zero? inlet)  ; Only variable inlets accept floats, ignore attempts to send to 0, but complain.
-      (timbre/error "cue control inlet does not respond to numbers")
-      (let [v (nth (cue-variables this) inlet)
+      (timbre/error "Cue control inlet does not respond to numbers.")
+      (let [v (nth (cue-variables this) (dec inlet))
             new-value (max new-value (:min v))  ; Restrict range of variable values as per cue specs.
             new-value (min new-value (:max v))]
         (if (keyword? (:key v))

;; TODO: Should we detect changes in the cue stored at our cell, and shut down?

(defn cue-variables
  "Return the cue's variables, in sorted order by key name (regardless
  of whether the key is a string or keyword)."
  [this]
  (sort-by (comp name :key) (get-in @(.state this) [:cue :variables])))

(defn cue-variable-names
  "Return the user-oriented names of the cue's variable, in key
  order."
  [this]
  (map :name (cue-variables this)))

(defn cue-variable-type-string
  "Returns the type strings telling Max what kind of outlets each cue

  and outlets supported by this object, and registers our interest in
  cue state with Afterglow."
  [this x y]
  (let [type-string (str "m" (cue-variable-type-string this))
        cue-name (get-in @(.state this) [:cue :name])
        first-inlet-assist (str "start, end, kill, bang: Control cue \"" cue-name "\"")]
    (.parentDeclareTypedIO this type-string type-string)
    (.parentSetInletAssist this (into-array String (concat [first-inlet-assist]
                                                           (cue-variable-inlet-assist this))))
    (.parentSetOutletAssist this (into-array String (concat ["Output changes in Cue state and associated id values"]
                                                            (cue-variable-outlet-assist this))))
    (.parentCreateInfoOutlet this false)
    (swap! (.state this) assoc :f (fn [new-state _ id]
                                    (.outlet this 0 (name new-state)
                                             (into-array Atom [(Atom/newAtom id) (Atom/newAtom cue-name)])))))
  (controllers/add-cue-fn! (:cue-grid *show*) x y (:f @(.state this))))

(defn- -start
  "Start the cue if it is not already running (if it is in the process
  of ending, start a new instance in its place)."
  [this]
  (let [{:keys [x y]} @(.state this)
        [_ active] (show/find-cue-grid-active-effect *show* x y)]
    (when-not (and active (not (:ending active)))
      (show/add-effect-from-cue-grid! x y))))

(defn- -end
