jsbeeb 1.16.0 → 1.17.0

package/src/fdc.js

@@ -1,6 +1,15 @@
 // Floppy disc assorted utils.
-import { Disc, DiscConfig, loadAdf, loadSsd, toSsdOrDsd } from "./disc.js";
-import { loadHfe, toHfe } from "./disc-hfe.js";
+import {
+    Disc,
+    DiscConfig,
+    DiscLayout,
+    loadAdf,
+    loadSsd,
+    sniffDfsLayout,
+    sniffSurfaceLayout,
+    toSsdOrDsd,
+} from "./disc.js";
+import { loadHfe, sniffHfeLayout, toHfe } from "./disc-hfe.js";
 import * as utils from "./utils.js";
 
 export function load(name) {
@@ -19,15 +28,29 @@ export class DiscType {
      * @param {function(Disc, Uint8Array, function?): Disc} options.loader - Function to load this disc type.
      * @param {function(Disc): Uint8Array} options.saver - Function to save this disc type.
      * @param {function(Uint8Array, string): void|null} [options.nameSetter] - Function to set the name/label in the disc image, or null if not supported.
+     * @param {function(Uint8Array): {is40Track: boolean, reason: string}} [options.layoutSniffer] - Function to tell a 40 track image from an 80 track one, for formats that carry the evidence.
+     * @param {boolean} [options.isFluxImage] - Whether the image is a picture of the surface rather than a list of the sectors on it.
      * @param {boolean} [options.isDoubleSided] - Whether the disc format is double-sided.
      * @param {boolean} [options.isDoubleDensity] - Whether the disc format is double density.
      * @param {number|undefined} [options.byteSize] - The size in bytes of this disc format, or undefined if variable.
      */
-    constructor({ extension, loader, saver, nameSetter, isDoubleSided, isDoubleDensity, byteSize } = {}) {
+    constructor({
+        extension,
+        loader,
+        saver,
+        nameSetter = null,
+        layoutSniffer,
+        isFluxImage,
+        isDoubleSided,
+        isDoubleDensity,
+        byteSize,
+    } = {}) {
         this._extension = extension;
         this._loader = loader;
         this._saver = saver;
         this._nameSetter = nameSetter;
+        this._layoutSniffer = layoutSniffer;
+        this._isFluxImage = isFluxImage;
         this._isDoubleSided = isDoubleSided;
         this._isDoubleDensity = isDoubleDensity;
         this._byteSize = byteSize;
@@ -97,6 +120,24 @@ export class DiscType {
         return this._nameSetter !== null;
     }
 
+    /**
+     * Whether the image holds a picture of the surface, so that where its tracks sit is a fact
+     * about the disc rather than a decision the loader made.
+     * @returns {boolean}
+     */
+    get isFluxImage() {
+        return !!this._isFluxImage;
+    }
+
+    /**
+     * What an image of this type says about its track layout.
+     * @param {Uint8Array} data - The disc image data
+     * @returns {?{is40Track: boolean, reason: string}} null for formats that cannot say
+     */
+    sniffLayout(data) {
+        return this._layoutSniffer ? this._layoutSniffer(data) : null;
+    }
+
     /**
      * Sets the disc name in the disc data using the format-specific setter
      * @param {Uint8Array} data - The disc data to modify
@@ -114,8 +155,9 @@ export class DiscType {
 // Standard sizes
 const SsdByteSize = 80 * 10 * 256; // 80 tracks, 10 sectors, 256 bytes/sector
 const DsdByteSize = SsdByteSize * 2; // Double-sided
-const AdfsLargeByteSize = 2 * 80 * 16 * 256; // Double-sided, 16 sectors/track
-const AdfsSmallByteSize = 80 * 16 * 256; // Single-sided, 16 sectors/track
+// ADFS comes in three sizes: S is 40 tracks on one side, M is 80 on one, L is 80 on both.
+const AdfsMediumByteSize = 80 * 16 * 256;
+const AdfsLargeByteSize = AdfsMediumByteSize * 2;
 
 /**
  * Set the name in a DFS disc image (SSD/DSD format)
@@ -133,6 +175,8 @@ const hfeDiscType = new DiscType({
     extension: ".hfe",
     loader: loadHfe,
     saver: toHfe,
+    layoutSniffer: sniffHfeLayout,
+    isFluxImage: true,
     isDoubleSided: true,
     isDoubleDensity: true,
 });
@@ -152,7 +196,7 @@ const adlDiscType = new DiscType({
     byteSize: AdfsLargeByteSize,
 });
 
-// ADFS (Small) discs are standard ADFS (non-double) density, single sided
+// ADFS M and S: single sided, and sized as the larger of the two.
 const adfDiscType = new DiscType({
     extension: ".adf",
     loader: (disc, data, _onChange) => {
@@ -164,7 +208,7 @@ const adfDiscType = new DiscType({
     },
     isDoubleSided: false,
     isDoubleDensity: true,
-    byteSize: AdfsSmallByteSize,
+    byteSize: AdfsMediumByteSize,
 });
 
 // DSD (Double-sided disc)
@@ -173,6 +217,7 @@ const dsdDiscType = new DiscType({
     loader: (disc, data, onChange) => loadSsd(disc, data, true, onChange),
     saver: toSsdOrDsd,
     nameSetter: setDfsDiscName,
+    layoutSniffer: (data) => sniffDfsLayout(data, true),
     isDoubleSided: true,
     isDoubleDensity: false,
     byteSize: DsdByteSize,
@@ -184,6 +229,7 @@ const ssdDiscType = new DiscType({
     loader: (disc, data, onChange) => loadSsd(disc, data, false, onChange),
     saver: toSsdOrDsd,
     nameSetter: setDfsDiscName,
+    layoutSniffer: (data) => sniffDfsLayout(data, false),
     isDoubleSided: false,
     isDoubleDensity: false,
     byteSize: SsdByteSize,
@@ -202,22 +248,48 @@ export function guessDiscTypeFromName(name) {
     return ssdDiscType;
 }
 
+/**
+ * @param {DiscType} discType
+ * @param {Uint8Array} data
+ * @param {string} name
+ * @param {string} layout - one of DiscLayout
+ * @returns {boolean} whether to lay the image out for a 40 track drive
+ */
+function is40TrackLayout(discType, data, name, layout) {
+    if (layout !== DiscLayout.auto) return layout === DiscLayout.expanded40;
+    const sniffed = discType.sniffLayout(data);
+    if (!sniffed) return false;
+    console.log(`${name} loaded as ${sniffed.is40Track ? "40" : "80"} track: ${sniffed.reason}`);
+    return sniffed.is40Track;
+}
+
 /**
  * Create a disc object of the appropriate type based on the file name
  * @param {Object} fdc - The FDC controller object
  * @param {string} name - The file name with extension
  * @param {string|Uint8Array} stringData - The disc image data as string or Uint8Array
  * @param {function(Uint8Array): void} onChange - Optional callback when disc content changes
+ * @param {string} [layout] - one of DiscLayout; by default the image is asked what it is
  * @returns {Disc} The loaded disc object
  */
-export function discFor(fdc, name, stringData, onChange) {
+export function discFor(fdc, name, stringData, onChange, layout = DiscLayout.auto) {
     const data = typeof stringData !== "string" ? stringData : utils.stringToUint8Array(stringData);
-    const disc = guessDiscTypeFromName(name).loader(new Disc(true, new DiscConfig(), name), data, onChange);
+    const discType = guessDiscTypeFromName(name);
+    const config = new DiscConfig();
+    config.expandTo80 = is40TrackLayout(discType, data, name, layout);
+    const disc = discType.loader(new Disc(true, config, name), data, onChange);
+    // A flux image of a 40 track disc read in an 80 track drive already holds it spread across the
+    // surface, so nothing needs moving and only the drive needs telling to step twice.
+    if (layout === DiscLayout.auto && discType.isFluxImage && !disc.is40Track) {
+        const sniffed = sniffSurfaceLayout(disc);
+        disc.is40Track = sniffed.is40Track;
+        console.log(`${name} surface reads as ${sniffed.is40Track ? "40" : "80"} track: ${sniffed.reason}`);
+    }
     disc.setOriginalImageCrc32(data instanceof Uint8Array ? data : new Uint8Array(data));
     return disc;
 }
 
-export function localDisc(fdc, name) {
+export function localDisc(fdc, name, layout = DiscLayout.auto) {
     const discName = "disc_" + name;
     let data;
     const dataString = window.localStorage[discName];
@@ -243,5 +315,5 @@ export function localDisc(fdc, name) {
             window.alert("Writing to localStorage failed: " + e);
         }
     };
-    return discFor(fdc, name, data, onChange);
+    return discFor(fdc, name, data, onChange, layout);
 }

package/src/google-drive.js

@@ -134,7 +134,7 @@ export class GoogleDriveLoader {
         return { fileId: meta.id, disc: this.makeDisc(fdc, data, meta) };
     }
 
-    makeDisc(fdc, data, meta) {
+    makeDisc(fdc, data, meta, layout) {
         let flusher = null;
         const name = meta.name;
         const id = meta.id;
@@ -148,12 +148,12 @@ export class GoogleDriveLoader {
         } else {
             console.log("Making read-only disc");
         }
-        return discFor(fdc, name, data, flusher);
+        return discFor(fdc, name, data, flusher, layout);
     }
 
-    async load(fdc, fileId) {
+    async load(fdc, fileId, layout) {
         const meta = (await this.driveClient.files.get({ fileId, fields: FILE_FIELDS })).result;
         const data = (await this.driveClient.files.get({ fileId, alt: "media" })).body;
-        return this.makeDisc(fdc, data, meta);
+        return this.makeDisc(fdc, data, meta, layout);
     }
 }

package/src/intel-fdc.js

@@ -1741,8 +1741,15 @@ export class IntelFdc {
      * @param {Number} drive
      * @param {Disc} disc
      */
-    loadDisc(drive, disc) {
+    /**
+     * @param {Number} drive
+     * @param {Disc} disc
+     * @param {Number} [tracksPerStep] where to leave the drive's 40/80 switch, which by default
+     *   follows the disc, since no drive can tell what pitch the disc in it was written at
+     */
+    loadDisc(drive, disc, tracksPerStep = disc?.is40Track ? 2 : 1) {
         this._drives[drive].setDisc(disc);
+        this._drives[drive].tracksPerStep = tracksPerStep;
     }
 
     get motorOn() {

package/src/jsbeeb.css

@@ -162,6 +162,54 @@ th {
   overflow: auto;
 }
 
+#hfe-list {
+  height: 380px;
+  overflow: auto;
+  list-style: none;
+  padding-left: 0;
+}
+
+#hfe-list li a {
+  display: grid;
+  grid-template-columns: minmax(0, 3fr) minmax(0, 2fr) minmax(0, 2fr);
+  gap: 0 1rem;
+  align-items: baseline;
+  padding: 3px 6px;
+  border-radius: 3px;
+  text-decoration: none;
+}
+
+#hfe-list li a:hover,
+#hfe-list li a:focus-visible {
+  background: rgba(255, 255, 255, 0.08);
+}
+
+#hfe-list .name {
+  font-weight: 600;
+}
+
+#hfe-list .publisher,
+#hfe-list .detail {
+  opacity: 0.65;
+  font-size: 0.9em;
+}
+
+#hfe-list .detail {
+  font-family: monospace;
+}
+
+.hfe-credit {
+  font-size: 0.9em;
+  opacity: 0.75;
+}
+
+@media (max-width: 40rem) {
+  #hfe-list li a {
+    grid-template-columns: minmax(0, 1fr);
+    padding-bottom: 6px;
+  }
+}
+
 div.filter {
   margin-top: 8px;
 }
@@ -576,3 +624,20 @@ div.smoothie-chart-tooltip {
   font-size: 10px;
   pointer-events: none;
 }
+
+.drive-tracks {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  white-space: nowrap;
+}
+
+.drive-tracks-label {
+  color: var(--bs-dropdown-link-color);
+}
+
+.drive-tracks .btn {
+  /* The stock small button is taller than the menu rows around it. */
+  padding: 0 6px;
+  line-height: 1.4;
+}

package/src/keyboard.js

@@ -43,6 +43,7 @@ export class Keyboard extends EventTarget {
         this.pauseEmu = false;
         this.stepEmuWhenPaused = false;
         this.keyLayout = keyLayout;
+        this.saidCapsLockIsTapped = false;
 
         // Modifier key states
         this.lastShiftLocation = 1;
@@ -315,21 +316,19 @@ export class Keyboard extends EventTarget {
         // Simulate a key release after a short delay
         setTimeout(() => this.keyInterface.keyUp(utils.keyCodes.CAPSLOCK), CAPS_LOCK_DELAY);
 
-        if (isMac && window.localStorage && !window.localStorage.getItem("warnedAboutRubbishMacs")) {
-            this.dispatchEvent(
-                new CustomEvent("showError", {
-                    detail: {
-                        context: "handling caps lock on Mac OS X",
-                        error: `Mac OS X does not generate key up events for caps lock presses.
-                jsbeeb can only simulate a 'tap' of the caps lock key. This means it doesn't work well for games
-                that use caps lock for left or fire, as we can't tell if it's being held down. If you need to play
-                such a game, please see the documentation about remapping keys.
-                Close this window to continue (you won't see this error again)`,
-                    },
-                }),
-            );
-            window.localStorage.setItem("warnedAboutRubbishMacs", "true");
-        }
+        if (this.saidCapsLockIsTapped) return;
+        this.saidCapsLockIsTapped = true;
+        this.dispatchEvent(
+            new CustomEvent("notice", {
+                detail: {
+                    message:
+                        "macOS sends no key up for caps lock, so jsbeeb can only tap it. " +
+                        "For a game that holds caps lock for left or fire, remap that key instead.",
+                    title: "Keyboard",
+                    quietKey: "warnedAboutRubbishMacs",
+                },
+            }),
+        );
     }
 
     /**

package/src/machine-session.js

@@ -410,7 +410,8 @@ export class MachineSession {
      */
     loadDisc(imagePath) {
         const data = new Uint8Array(readFileSync(imagePath));
-        this._machine.processor.fdc.loadDisc(0, fdc.discFor(this._machine.processor.fdc, imagePath, data));
+        const machineFdc = this._machine.processor.fdc;
+        machineFdc.loadDisc(0, fdc.discFor(machineFdc, imagePath, data));
     }
 
     /**