* Step: note selector jumps in banks

* Hold REC to arm multiple tracks
* Clear REC/MUTE/SOLO on all tracks with CLEAR
* Clip queued for recording will flash red

Fixes:
* No more collision warnings that TrackTracker complained about
* Adding new step would display wrong velocity in NOTES mode
* Step sequencer was mapped to wrong notes and not aligned with note pads

Author: unthingable

docs/README.md

@@ -66,6 +66,7 @@ Chorded buttons are sensitive to order. For example, **SHIFT+CONTROL** is not th
 
 * **PLAY**: Start/Stop playback
 * **REC**: Toggle recording
+* **REC (hold)**: Arm tracks via track buttons
 * **SHIFT+PLAY** Restart or pause/continue (see **Settings**)
 * **SHIFT+RECORD**: Toggle launcher overdub
 * **SHIFT+PAGE LEFT**: Toggle the metronome
@@ -212,7 +213,7 @@ Scene button color guide:
 ### Pad matrix
 
 * Press empty step (dark button) to create a step
-* Press an existing step to clear
+* Press an existing step to clear (and release quickly)
 * Press and hold step to select it for editing (long press will not delete it)
 * **SHIFT+NOTES** to toggle alternating note row colors
 
@@ -256,28 +257,30 @@ Velocity selector works with two different velocity values:
 * Default velocity: newly entered note steps will use this
 * Velocity of a specific note step: hold one or more note steps, then you can see/edit its velocity via the selector. If multiple steps are held, it's the last pressed step that takes precedence, and adjustments are made to all of them simultaneously.
 
-### Note selector (WIP)
+### Note selector
 
 Play notes and focus step editor.
 
-The 128 notes are divided in 8 pages of 16 (or fewer) notes each. The note selector is always showing one of those pages (think of the Chain scroller in Drum Maschine), which one depends on which page the bottommost visible note falls into.
+The lower right quadrant (numbered pads) correspond to 16 consecutive notes (in scale), starting with the bottom of the current note page (see below). The "bank" of white buttons are notes currently visible in the step grid.
 
 Pressing a pad:
 * Plays the note
-* Scrolls the step editor to that note (so that it's at the top row)
+* Scrolls the step editor to that note "bank" (hold SELECT to ignore banking and scroll to that note directly, or use encoder)
 
-The note selector button corresponding to the bottommost visible note is bright white. If more notes are visible in the step view, their buttons will be dim white. Note that because the step grid is laid out top-down vertically (high notes on top, low on bottom, matching the clip view in the app) and the note buttons are left-right and down-up (as labeled on the Jam), this can feel backwards.
+The note selector button corresponding to the bottommost visible note is bright white. If more notes are visible in the step view, their buttons will be dim white.
 
-Currently playing notes will flash, letting you see activity outside of the visible step grid.
+Currently playing non-white notes will flash, letting you see activity outside of the visible step grid.
 
 #### Note pages
 
-**Press and hold NOTE** to see the page selector (SCENE buttons), higher notes are on the right like on a piano (if your brain isn't hurting yet, this is opposite of how scenes work with clips). Unlike Note selector that is fixed to a page, page selector will indicate if current note window straddles two pages, pages with visible content will be in dim white. Pressing a button always scrolls bottom note row to the bottom of that page. If the grid is aligned exactly to the beginning of a page, its page button will be bright white.
+**Press and hold NOTE** to see the page selector (SCENE buttons), higher notes are on the right like on a piano. Unlike Note selector that is fixed to a page, page selector will indicate if current note window straddles two pages, pages with visible content will be in dim white. Pressing a button always scrolls bottom note row to the bottom of that page. If the grid is aligned exactly to the beginning of a page, its page button will be bright white.
 
-Seeing how the Drum Machine lays out its banks, in chromatic scale the first page is 4 notes while the rest are 16. This is a compromise where the page layout matches Drum Machines (but you cannot access the last page with Scene buttons because there are only 8 — can still scroll though). In non-chromatic mode all pages are 16 notes.
+Seeing how the Drum Machine lays out its banks, in chromatic scale the first page is 4 notes while the rest are 16. This is a compromise where the page layout matches Drum Machine's (but you cannot access the last page with Scene buttons because there are only 8 — can still scroll though). In non-chromatic mode all pages are 16 notes.
 
 Use note/page selectors together with knob scrolling for maximum nagivation.
 
+Note: note page selector always displays pages for the full 8x8 grid, regardless of whether NOTES mode is active.
+
 ## Channel and Scale
 
 Hold **PERFORM** to access channel and scale selectors.
@@ -353,7 +356,7 @@ You can quickly drop into a mode, do something and drop back out with no additio
 Some specific modes use an inverted variant of this behavior (long press leaves mode on).
 
 Some modes that are like this:
-* SOLO, MUTE, TEMPO
+* SOLO, MUTE, TEMPO, RECORD
 * User control pages
 * Control slice selectors
 * etc. — if you think it should be auto-gating it probably is, and if not then let me know.
@@ -398,6 +401,14 @@ is entered, SuperScene will not be able to launch or stop it directly.
 If a group track containing SuperScene clips in its inner tracks was folded, 
 SuperScene will launch the _entire_ last (bottom-most) scene of that group track that has a playing clip.
 
+**NOTE**: SuperScenes are experimental and are built using undocumented implementation details of Bitwig API to derive unique track IDs. There is a chance things will randomly stop working with a new release.
+
+### ID collision warnings
+
+Due to experimental nature of the underlying track ID mechanism, MonsterJam monitors track IDs for uniqueness. If a duplicate ID is detected, a notification will pop up with the names of tracks.
+
+If this happens, try duplicating the offending track and deleting the original, and definitely let me know.
+
 ## Device Selector
 
 Note: there is currently a bug in the API that will cause Device Selector display to freak out when adding new devices. In the meantime, scroll the track bank back and forth to clear.
@@ -501,6 +512,22 @@ After changing preferences it may be necessary to reinitialize the extension (tu
 
 # Changelog
 
+## 8.0b12
+(changelog since b9)
+### Features
+* Step: note selector jumps in banks
+* Hold REC to arm multiple tracks
+* Clear REC/MUTE/SOLO on all tracks with CLEAR
+* Clip queued for recording will flash red
+### Fixes
+* No more collision warnings that TrackTracker complained about
+* Adding new step would display wrong velocity in NOTES mode
+* Step sequencer was mapped to wrong notes and not aligned with note pads
+
+### Known issues
+* NOTES mode in sequencer does not reactivate automatically
+* After using TUNE, previous strip mode will not reactivate
+
 ## 8.0
 
 ### New features

pom.xml

@@ -6,7 +6,7 @@
     <artifactId>monsterjam</artifactId>
     <packaging>jar</packaging>
     <name>MonsterJam</name>
-    <version>8.0-b9</version>
+    <version>8.0-b12</version>
 
     <repositories>
         <repository>

src/main/scala/com/github/unthingable/MonsterJamControllerDefinition.scala

@@ -16,7 +16,7 @@ class MonsterJamExtensionDefinition() extends ControllerExtensionDefinition {
 
   override def getAuthor = "unthingable"
 
-  override def getVersion = "8.0-b9"
+  override def getVersion = "8.0-b12"
 
   override def getId: UUID = MonsterJamExtensionDefinition.DRIVER_ID
 

src/main/scala/com/github/unthingable/MonsterJamExtension.scala

@@ -43,20 +43,26 @@ case class MonsterJamExt(
   binder: Binder = new Binder(),
   events: EventBus[Event] = new EventBus(),
 ) {
-  type Schedulable = (Int, () => Boolean, () => Unit)
-
   lazy val xmlMap = loadMap(host)
+  
+  type Schedulable = (Int, () => Boolean, () => Unit) | (Int, () => Unit)
 
-  final def run(tasks: Schedulable*): Unit = {
+  final def sequence(tasks: List[Schedulable]): Unit = {
     tasks match {
       case Nil => ()
+      case (wait, action) :: tt =>
+        host.scheduleTask(() => 
+          action() 
+          sequence(tt*), wait)
       case (wait, condition, action) :: tt =>
         host.scheduleTask(() => if (condition()) {
           action()
-          run(tt: _*)
+          sequence(tt*)
         }, wait)
     }
   }
+  
+  final inline def sequence(tasks: Schedulable*): Unit = sequence(tasks.toList)
 
   // for when you need a quick action
   def a(f: => Unit): HardwareActionBindable = host.createAction(() => f, () => "")

src/main/scala/com/github/unthingable/Util.scala

@@ -2,7 +2,9 @@ package com.github.unthingable
 
 import com.bitwig.extension.api.Color
 import com.bitwig.extension.controller.api.{
+  Bank,
   CursorRemoteControlsPage,
+  ObjectProxy,
   Preferences,
   SettableBooleanValue,
   SettableEnumValue,
@@ -30,6 +32,7 @@ import java.io.ObjectOutputStream
 import scala.util.Try
 import java.nio.charset.StandardCharsets
 import scala.annotation.targetName
+import scala.collection.IndexedSeqView
 
 transparent trait Util {
   implicit class SeqOps[A, S[B] <: Iterable[B]](seq: S[A]) {
@@ -43,6 +46,13 @@ transparent trait Util {
     Color.fromRGBA(color.getRed, color.getGreen, color.getBlue, color.getAlpha)
 
   case class Timed[A](value: A, instant: Instant)
+
+  extension [A <: ObjectProxy](bank: Bank[A])
+    def view: IndexedSeqView[A] =
+      (0 until bank.itemCount().get()).view.map(bank.getItemAt)
+    
+    def fullView: IndexedSeqView[A] =
+      (0 until bank.getCapacityOfBank()).view.map(bank.getItemAt)
 }
 object Util extends Util {
   val EIGHT: Vector[Int] = (0 to 7).toVector
@@ -98,7 +108,7 @@ object Util extends Util {
       ois.close()
       obj.asInstanceOf[A]
     }.toEither
-  
+
   def comparator[A, B](a: A, b: A)(f: A => B): Boolean =
     f(a) == f(b)
 }

src/main/scala/com/github/unthingable/jam/Jam.scala

@@ -122,7 +122,7 @@ class Jam(implicit val ext: MonsterJamExt)
     sceneCycle   -> top,
     bottom       -> Coexist(globalQuant, shiftTransport, shiftMatrix, shiftPages),
     bottom       -> Exclusive(GlobalMode.Clear, GlobalMode.Duplicate, GlobalMode.Select),
-    trackGroup   -> Exclusive(solo, mute),
+    trackGroup   -> Exclusive(solo, mute, record),
     bottom       -> Coexist(clipMatrix, pageMatrix, stepSequencer),
     bottom       -> stripGroup,
     bottom       -> Coexist(auxGate, deviceSelector, macroLayer),

src/main/scala/com/github/unthingable/jam/TrackTracker.scala

@@ -33,15 +33,14 @@ trait TrackTracker {
 /** Track ephemeral IDs as hashcodes of Track objects under proxies.
  * Unlike SmartTracker which was stable, UnsafeTracker does not preserve IDs between host restarts.
  */
-class UnsafeTracker(val bank: TrackBank)(using ext: MonsterJamExt) extends TrackTracker {
+class UnsafeTracker(val bank: TrackBank)(using ext: MonsterJamExt) extends TrackTracker, Util {
 
-  private val bankRange = 0 until bank.getCapacityOfBank()
   private type MRef = Ref[Option[Method]]
   private var idM: MRef = Ref(None)
   private var targetM: MRef = Ref(None)
 
-  bankRange
-    .map(bank.getItemAt)
+  bank
+    .fullView
     .zipWithIndex
     .foreach { case (t, idx) =>
       t.position().markInterested()
@@ -50,9 +49,18 @@ class UnsafeTracker(val bank: TrackBank)(using ext: MonsterJamExt) extends Track
 
   bank.itemCount().addValueObserver(_ =>
     // check for collisions
-    val hashes = bankRange.map(bank.getItemAt).flatMap(idForBankTrack)
+    val hashes = bank.view.flatMap(idForBankTrack).toVector
     if (hashes.distinct.size != hashes.size) // && ext.preferences.smartTracker.get())
       ext.host.showPopupNotification("Track ID hash collision detected, superscenes might not work")
+      val dups = hashes.zipWithIndex.map((id, idx) => 
+        val track = bank.getItemAt(idx)
+        Util.println(s"$idx $id ${track.name().get}")
+        (id, track)
+      ).groupBy(_._1)
+      .values.filter(_.length > 1)
+      // .tapEach(v => Util.println(v.toString()))
+      val names = dups.flatten.map(_._2.name().get()).toVector.distinct.mkString(",")
+      ext.host.showPopupNotification(s"Track ID hash collision: $names")      
   )
 
   val ids = mutable.ArraySeq.from(0 until bank.getCapacityOfBank())
@@ -68,7 +76,7 @@ class UnsafeTracker(val bank: TrackBank)(using ext: MonsterJamExt) extends Track
     else None
 
   override inline def getItemAt(id: TrackId): Option[Track] =
-    LazyList.from(bankRange).map(bank.getItemAt).find(t => trackId(t).contains(id))
+    bank.view.find(t => trackId(t).contains(id))
 
   // cache method references
   private def getOr(mref: MRef, method: => Option[Method]): Option[Method] =
@@ -88,7 +96,8 @@ class UnsafeTracker(val bank: TrackBank)(using ext: MonsterJamExt) extends Track
       idMethod: Method <- getOr(idM, 
         tObj.getClass().getMethods()
         .filter(_.getReturnType().equals(classOf[UUID]))
-        .headOption) // let's hope there is just one
+        // .tapEach(m => Util.println(s"$st $m"))
+        .lastOption) // we can only hope it's the right one, no way to know for sure
     } yield idMethod.invoke(tObj).asInstanceOf[UUID]
 
     val id = uid.map(_.hashCode())
@@ -97,9 +106,9 @@ class UnsafeTracker(val bank: TrackBank)(using ext: MonsterJamExt) extends Track
     id.map(TrackId.apply)
 
   inline def idList: Seq[Option[TrackId]] = 
-    LazyList.from(bankRange).map(idx => idForBankTrack(bank.getItemAt(idx)))
+    bank.view.map(idForBankTrack).toVector
 
   inline def idMap: Seq[(TrackId, Int)] = 
-    idList.zipWithIndex.map{case (a, b) => a.map((_, b))}.flatten
+    idList.zipWithIndex.map{(a, b) => a.map((_, b))}.flatten
 }
 

src/main/scala/com/github/unthingable/jam/layer/ClipMatrix.scala

@@ -42,6 +42,8 @@ trait ClipMatrix { this: Jam =>
         clip.color().markInterested()
         clip.hasContent.markInterested()
         clip.isPlaying.markInterested()
+        clip.isRecording().markInterested()
+        clip.isRecordingQueued().markInterested()
         clip.isSelected.markInterested()
         clip.isPlaybackQueued.markInterested()
         clip.isStopQueued.markInterested()
@@ -144,13 +146,15 @@ trait ClipMatrix { this: Jam =>
         JamColorState(
           if (clip.hasContent.get())
             JamColorState.toColorIndex(clip.color().get())
+          else if clip.isRecordingQueued().get() then
+            JamColorBase.RED
           else
             JamColorBase.OFF,
           brightness =
             if (clip.isPlaying.get())
               if (track.isQueuedForStop.get()) if (j.Mod.blink) 3 else -1
               else 3
-            else if (clip.isPlaybackQueued.get()) if (j.Mod.blink) 0 else 3
+            else if (clip.isPlaybackQueued.get() || clip.isRecordingQueued().get()) if (j.Mod.blink) 0 else 3
             else 0
         )
   }

src/main/scala/com/github/unthingable/jam/layer/StepSequencer.scala

@@ -81,7 +81,7 @@ trait StepSequencer extends BindingDSL { this: Jam =>
     clip.addNoteStepObserver(ns => steps(ns.channel())(ns.x()).update(ns.y(), ns))
 
     devices.itemCount().addValueObserver(v => Util.println(v.toString))
-    clip.getPlayStop.addValueObserver(v => Util.println(s"beats $v"))
+    // clip.getPlayStop.addValueObserver(v => Util.println(s"beats $v"))
     // clip.playingStep().addValueObserver(v => Util.println(s"playing step $v"))
 
     // follow track selection

src/main/scala/com/github/unthingable/jam/layer/TransportL.scala

@@ -1,7 +1,7 @@
 package com.github.unthingable.jam.layer
 
 import com.bitwig.extension.api.Color
-import com.bitwig.extension.controller.api.{Channel, HardwareActionBindable, SettableBooleanValue}
+import com.bitwig.extension.controller.api.{Channel, HardwareActionBindable, SettableBooleanValue, Track}
 import com.github.unthingable.framework.mode.{GateMode, ModeButtonLayer, SimpleModeLayer}
 import com.github.unthingable.framework.binding.HB.action
 import com.github.unthingable.framework.binding.{
@@ -18,8 +18,9 @@ import com.github.unthingable.jam.Jam
 import com.github.unthingable.framework.binding.BindingDSL
 import java.time.Instant
 import com.github.unthingable.JamSettings
+import com.github.unthingable.Util
 
-trait TransportL extends BindingDSL { this: Jam =>
+trait TransportL extends BindingDSL, Util { this: Jam =>
   lazy val position = SimpleModeLayer(
     "position",
     Vector(
@@ -110,7 +111,7 @@ trait TransportL extends BindingDSL { this: Jam =>
         BB(tracked = false)
       ),
       SupBooleanB(j.noteRepeat.light.isOn, ext.transport.isFillModeActive),
-      EB(j.record.st.press, "record pressed", () => ext.transport.record()),
+      EB(j.record.st.press, "record pressed", () => ext.transport.record(), BB(exclusive = false)),
       SupBooleanB(j.record.light.isOn, ext.transport.isArrangerRecordEnabled),
       EB(
         j.auto.st.press,
@@ -196,8 +197,10 @@ trait TransportL extends BindingDSL { this: Jam =>
     name: String,
     modeButton: JamOnOffButton,
     group: Seq[JamRgbButton],
-    prop: Channel => SettableBooleanValue,
-    color: Int // Jam's color index
+    prop: Track => SettableBooleanValue,
+    color: Int, // Jam's color index
+    gateMode: GateMode = GateMode.Auto,
+    silent: Boolean = false
   ): ModeButtonLayer = ModeButtonLayer(
     name,
     modeButton,
@@ -223,11 +226,17 @@ trait TransportL extends BindingDSL { this: Jam =>
           JamColorState.empty
         )
       )
-    }
+    } ++ Vector(
+      EB(j.clear.st.press, "", () => superBank.view.map(prop).foreach(_.set(false)))
+    ),
+    gateMode = gateMode,
+    silent = silent
   )
 
   lazy val solo =
     buttonGroupChannelMode("solo", j.solo, j.groupButtons, _.solo(), JamColorBase.YELLOW)
   lazy val mute =
     buttonGroupChannelMode("mute", j.mute, j.groupButtons, _.mute(), JamColorBase.ORANGE)
+  lazy val record =
+    buttonGroupChannelMode("record", j.record, j.groupButtons, _.arm(), JamColorBase.RED, GateMode.Gate, true)
 }