working on todo.md features

src/plot_host.hpp

@@ -41,6 +41,12 @@ namespace udpscope {
 /// count is fixed at construction, so there is one path for "a row's traces changed"
 /// and "the row count changed", and it costs no GL state -- the area keeps its
 /// context and is simply handed the new figure.
+/// The signal a channel name belongs to, with a group's layer suffix taken back off: `sine (A)`,
+/// `sine (B)` and `sine #2` are all the signal `sine`. A comparison's model holds one channel per
+/// (signal, layer), so this is what lets the signal list show each signal once, draw every layer of it
+/// in the signal's own colour, and stop a second group from re-suffixing a name a first one left.
+std::string layer_base_name(const std::string& name);
+
 class RowSet {
  public:
   /// The ceiling on rows, not the count: rows are added and removed one at a time
@@ -49,7 +55,12 @@ class RowSet {
   /// allocated somewhere, and because the figure keeps a floor height per row -- past
   /// about this many a row is chrome and no plot.
   static constexpr int kMaxRows = 8;
-  static constexpr int kSlotsPerRow = 4;
+  /// Traces one row can hold. Eight rather than the four a hand-arranged scope usually wants, because
+  /// the *default* layout is four signals in one row and an accumulation needs a slot per extra event:
+  /// with four, "accumulate these two events" over the layout the app starts with had nowhere to put
+  /// the second copy and silently did nothing. The free slots cost nothing -- a `Plot` creates its
+  /// traces up front either way -- and the user's own traces stay where they are.
+  static constexpr int kSlotsPerRow = 8;
   /// Readout marks per row per orientation: enough for a handful of level and time
   /// measurements to be shown at once, and a fixed number because a `Plot` fixes its cursor
   /// set at construction.
@@ -135,6 +146,13 @@ class RowSet {
   };
 
   int row_count() const noexcept { return rows_; }
+
+  /// The alpha every trace is drawn with. The *group* views use it: accumulating events wants their
+  /// traces translucent so that agreement between them reads as brightness, which is the whole point
+  /// of a persistence display. It is mixed into the palette colour where the trace is created, so it
+  /// belongs with `assign()` -- set it before the assignments that follow it, or they keep the alpha
+  /// the previous view left behind.
+  void set_trace_alpha(float alpha) noexcept { trace_alpha_ = alpha; }
   /// Shows `rows` rows. A changed count rebuilds the figure, since a `Figure`'s row
   /// count is fixed at construction.
   void set_row_count(int rows);
@@ -478,6 +496,7 @@ class RowSet {
   /// The one x link group every visible row belongs to. Groups are numbered from 1.
   plot::u32 x_group_ = 0;
   int rows_ = 1;
+  float trace_alpha_ = 1.0f;
   double window_s_ = 2.0;
   double trigger_marker_x_ = 0.0;
   bool trigger_marker_on_ = false;