Say when the entry has two signals on the air

N1MM blocks the transmitter when a multi-operator entry is about to break
its own class. This program does not touch the transmitter: a logger that
decides for itself when the operator may not send loses a contact every
time it is wrong, and it is wrong whenever it has stale information about
the other stations — which, on a network, is whenever a laptop has just
been unplugged.

So the entry window says so instead. While this station is transmitting
and the entry is over what it is allowed, a red box goes across the top of
the window naming the station and the band. It is above the frequency and
under the menu, so nothing it covers is anything the operator needs while
he is sending, and it is big enough to read from the other side of the
room.

`TransmitRules` is what it asks:

| Entry | Allowed |
|---|---|
| one transmitter | one signal |
| two transmitters | two signals, on different bands |
| anything else | one signal per band |

Two on one band is wrong in every multi-operator class, so it is checked
whatever the category says. A station that has not said which band it is on
counts as somewhere else: a guess there puts the box in front of an
operator doing nothing wrong.

This is also the first thing that sends `XMIT`. The message was written and
nothing called it, so the transmit column of everybody's network status
window stayed empty and no station knew when another was sending. The entry
window now says when its key goes down and what it is sending.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PdAYHcdRktqKry7nk414TU

src/Nonemm.App/Windows/EntryWindow.Macros.cs

@@ -185,6 +185,8 @@ public sealed partial class EntryWindow
     {
         try
         {
+            // what the other operators read in their network status window
+            sendingWhat = text.Length > 40 ? text[..40] : text;
             sending = true;
             Refresh();
             await keyer.SendAsync(text);

src/Nonemm.App/Windows/EntryWindow.axaml

@@ -127,6 +127,15 @@
       </MenuItem>
     </Menu>
 
+    <!-- Two signals where the entry may have one. N1MM blocks the
+         transmitter; this says so instead, loudly enough to be read from
+         across the room, and leaves the operator to stop -->
+    <Border DockPanel.Dock="Top" Name="TransmitWarning" IsVisible="False"
+            Background="#C0392B" Padding="10,8">
+      <TextBlock Name="TransmitWarningText" FontSize="22" FontWeight="Bold"
+                 Foreground="White" TextWrapping="Wrap" Text="" />
+    </Border>
+
     <!-- N1MM's status strip: what just happened on the left, then the band
          change timer, the contacts and multipliers, and the score -->
     <Border DockPanel.Dock="Bottom" Padding="6,3" BorderThickness="0,1,0,0"

src/Nonemm.App/Windows/EntryWindow.axaml.cs

@@ -29,7 +29,27 @@ public sealed partial class EntryWindow : Window
 
     private static readonly IBrush Dark = new SolidColorBrush(Color.FromArgb(0x33, 0x80, 0x80, 0x80));
 
-    private bool sending;
+    /// True while this station has its key down. Every station of the entry is
+    /// told, because two signals where the entry may have one is a contact the
+    /// sponsor takes back off both of them.
+    private bool sending
+    {
+        get;
+        set
+        {
+            if (field == value)
+            {
+                return;
+            }
+            field = value;
+            _ = session.Link?.SendTransmittingAsync(value, sendingWhat, session.IsRun2);
+            ShowTransmitWarning();
+        }
+    }
+
+    /// What is going out, which is what the other operators read in the
+    /// network status window.
+    private string sendingWhat = "";
     private TextBlock? callMark;
     private TextBox? nameBox;
     private TextBox? commentBox;
@@ -1000,6 +1020,37 @@ public sealed partial class EntryWindow : Window
     {
         ClockText.Text = DateTime.UtcNow.ToString("HH:mm:ss") + "Z";
         ShowBandTimer();
+        // another station keying up is not something this window is told about,
+        // so the box is worked out again every second as well
+        ShowTransmitWarning();
+    }
+
+    /// The red box: this station is transmitting and the entry is over the
+    /// signals it is allowed, or two of its stations are on one band. N1MM
+    /// blocks the transmitter for this; this program says so and leaves the
+    /// operator to stop, because a logger that decides for itself when an
+    /// operator may not send loses a contact every time it is wrong.
+    private void ShowTransmitWarning()
+    {
+        string? why = TransmitViolation();
+        TransmitWarning.IsVisible = why is not null;
+        TransmitWarningText.Text = why is null ? "" : $"STOP — {why}";
+    }
+
+    private string? TransmitViolation()
+    {
+        if (!sending || Logging is null || session.Link is not { } link)
+        {
+            return null;
+        }
+        List<Transmitter> others = link.Stations
+            .Where(s => !s.IsMine && s.IsTransmitting)
+            .Select(s => new Transmitter(s.ComputerName, s.Band, s.Mode?.Category))
+            .ToList();
+        return TransmitRules.Violation(
+            Logging.Log.Entry,
+            new Transmitter(link.ComputerName, Bands.ForFrequency(Logging.Frequency), Logging.Mode.Category),
+            others);
     }
 
     /// The countdown N1MM puts in its info window: how long the station still

src/Nonemm.Contests/TransmitRules.cs

@@ -0,0 +1,96 @@
+using Nonemm.Core;
+
+namespace Nonemm.Contests;
+
+/// One station of the entry with its key down, as the others see it.
+public sealed record Transmitter(string ComputerName, Band? Band, ModeCategory? Mode);
+
+/// How many signals a multi-operator entry may have on the air at once, and on
+/// which bands.
+///
+/// N1MM blocks the transmitter when the entry is about to break these. This
+/// program does not touch the transmitter — a logger that decides for itself
+/// when the operator may not send is a logger that loses a contact when it is
+/// wrong — so it says what is happening and leaves it to the operator.
+///
+/// | Entry | What is allowed |
+/// |---|---|
+/// | one transmitter | one signal on the air |
+/// | two transmitters | two signals, on different bands |
+/// | anything else | as many as the sponsor allows, one per band |
+///
+/// Two signals on one band is wrong in every multi-operator class, which is why
+/// it is checked whatever the category says. An entry that is neither one nor
+/// two transmitters — multi-unlimited, and a single operator with two radios —
+/// is only held to that.
+public static class TransmitRules
+{
+    /// What is wrong with this station transmitting now, or null when nothing
+    /// is. `others` is every other station of the entry that has its key down.
+    public static string? Violation(
+        ContestEntry entry,
+        Transmitter me,
+        IReadOnlyList<Transmitter> others)
+    {
+        if (others.Count == 0)
+        {
+            return null;
+        }
+        if (others.FirstOrDefault(o => SameBand(o, me) && o.Mode == me.Mode) is { } sameMode)
+        {
+            return $"{sameMode.ComputerName} is transmitting on {Where(me)} as well";
+        }
+        if (others.FirstOrDefault(o => SameBand(o, me)) is { } sameBand)
+        {
+            return $"{sameBand.ComputerName} is transmitting on {me.Band?.Name} as well";
+        }
+        int allowed = Transmitters(entry);
+        if (allowed > 0 && others.Count + 1 > allowed)
+        {
+            string signals = $"{others.Count + 1} signals";
+            string on = string.Join(", ", others.Select(Where).Prepend(Where(me)));
+            return allowed == 1
+                ? $"{signals} on the air — a one-transmitter entry may have one: {on}"
+                : $"{signals} on the air — a two-transmitter entry may have two: {on}";
+        }
+        return null;
+    }
+
+    /// How many signals the entry may have at once, or zero when the category
+    /// does not say. N1MM reads the number off the operator category on
+    /// Cabrillo 2.0 and off the transmitter category after it, and so does
+    /// this.
+    private static int Transmitters(ContestEntry entry)
+    {
+        if (!entry.OperatorCategory.StartsWith("MULTI", StringComparison.OrdinalIgnoreCase))
+        {
+            return 0;
+        }
+        if (Is(entry, "MULTI-ONE", "ONE"))
+        {
+            return 1;
+        }
+        return Is(entry, "MULTI-TWO", "TWO") ? 2 : 0;
+    }
+
+    private static bool Is(ContestEntry entry, string operatorCategory, string transmitterCategory) =>
+        entry.OperatorCategory.Equals(operatorCategory, StringComparison.OrdinalIgnoreCase)
+        || entry.TransmitterCategory.Equals(transmitterCategory, StringComparison.OrdinalIgnoreCase);
+
+    /// Two stations are on the same band only when both say which band they are
+    /// on. A station that has not said counts as somewhere else: a guess here
+    /// puts a red box in front of an operator who is doing nothing wrong.
+    private static bool SameBand(Transmitter one, Transmitter other) =>
+        one.Band is not null && other.Band is not null && one.Band == other.Band;
+
+    private static string Where(Transmitter station) =>
+        $"{station.Band?.Name ?? "somewhere"} {Named(station.Mode)}".TrimEnd();
+
+    private static string Named(ModeCategory? mode) => mode switch
+    {
+        ModeCategory.Cw => "CW",
+        ModeCategory.Phone => "phone",
+        ModeCategory.Digital => "digital",
+        _ => "",
+    };
+}