badline 0.10.1 → 0.11.1

data/lib/badline/drive1571/serial_port.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1571
+    # What VIA 1's ports read from outside the chip. Port B carries the
+    # serial bus inputs and the device number jumpers, as on the 1541
+    # (Drive::SerialLines). Port A reads the mechanism on two inputs:
+    #
+    #   PA0  track 0 sensor, low while the head sits on track 1
+    #   PA7  BYTE READY, latched low from a whole byte until the CPU next
+    #        reads or writes VIA 2
+    #
+    # The DOS steps the head out until PA0 reads low with the stepper on
+    # phase 0, and polls PA7 for each byte at 2 MHz, taking the byte from
+    # VIA 2's port A or putting the next one there after each. PA1 (fast serial
+    # direction), PA2 (side) and PA5 (1 or 2 MHz) are outputs, which
+    # Drive1571 follows (SerialVIA).
+    class SerialPort
+      include Drive::SerialLines
+
+      TRACK0 = 0x01
+      BYTE_READY = 0x80
+
+      def initialize(mechanism, device: 8, bus: IECBus.new)
+        @mechanism = mechanism
+        init_serial_lines(device, bus)
+      end
+
+      def read_a(_lines)
+        value = 0xff
+        value &= ~TRACK0 if @mechanism.half_track == Drive1541::Mechanism::MIN_HALF_TRACK
+        value &= ~BYTE_READY if @mechanism.byte_latched?
+        value
+      end
+    end
+  end
+end

data/lib/badline/drive1571/serial_via.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1571
+    # VIA 1, the one facing the serial bus. Its port A also selects the
+    # side, the clock rate and the fast serial direction, so the drive
+    # hears port A after every write and reset (Drive1571#port_a_written).
+    class SerialVIA < VIA
+      def initialize(start:, peripheral:, drive:)
+        @drive = drive
+        super(start:, peripheral:)
+      end
+
+      def reset!
+        super
+        @drive.port_a_written(port_a_output)
+      end
+
+      def poke(addr, value)
+        super
+        @drive.port_a_written(port_a_output)
+      end
+    end
+  end
+end

data/lib/badline/drive1571/wd1770.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1571
+    # The WD1770 floppy controller at $2000, which the DOS needs only for
+    # MFM disks. Its four registers hold what's written to them and it
+    # runs no commands: the status reads idle, with the motor off.
+    #
+    #   $2000  status (read), command (write)
+    #   $2001  track
+    #   $2002  sector
+    #   $2003  data
+    class WD1770
+      def initialize
+        @registers = [0, 0, 0, 0]
+      end
+
+      # Register +offset+, 0 to 3.
+      def peek(offset) = offset.zero? ? 0 : @registers[offset]
+
+      def poke(offset, value)
+        @registers[offset] = value
+      end
+
+      def save_state(out)
+        out.ints(@registers)
+      end
+
+      def load_state(input)
+        @registers = input.ints
+      end
+    end
+  end
+end

data/lib/badline/drive1571.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "badline/drive1571/cpu"
+require "badline/drive1571/wd1770"
+require "badline/drive1571/serial_port"
+require "badline/drive1571/serial_via"
+require "badline/drive1571/bus"
+
+module Badline
+  # The 1571 disk drive, the C128D's built-in one: the 1541's 6502, two
+  # VIAs and GCR mechanism, with a second head, a 6526 CIA for fast
+  # serial, a WD1770 for MFM disks and DOS 3.0 in 32 KB of ROM. Drive::Core
+  # clocks it against the host and sleeps through the DOS's idle loop.
+  #
+  # VIA 1's port A picks the clock, 1 or 2 MHz on PA5, and the head on
+  # PA2, and reads the track 0 sensor and BYTE READY (SerialPort). The
+  # DOS resets at 2 MHz and drops to 1 MHz as a 1541 would run, which is
+  # how it stays until a C128 asks for fast serial. The disk turns at the
+  # same speed either way (Drive1541::Mechanism#clock_hz=).
+  #
+  # The CIA sits at $4000, on the IRQ line with both VIAs. Only its serial
+  # port is wired: through buffers PA1 turns round, its CNT drives SRQ and
+  # its SP DATA, or it hears them. The drive pushes its pins into the bus
+  # as they move, and hears the host's as the host pushes them, pin by
+  # pin, so each byte goes through both shift registers bit by bit. The
+  # CIA takes no part in a pass of the idle loop: the drive sleeps only
+  # while the CIA is quiet (CIA#quiet?), and any access to it, or the
+  # host moving its fast serial pins, wakes the drive.
+  class Drive1571
+    include Drive::Core
+
+    CLOCK_HZ = 1_000_000
+    FAST_CLOCK_HZ = 2_000_000
+
+    # Where the DOS 3.0 idle loop starts over, as DOS 2.6's does.
+    IDLE_LOOP = 0xebff
+
+    # VIA 1's port A outputs.
+    FAST_SERIAL_OUT = 0x02
+    SIDE = 0x04
+    FAST = 0x20
+
+    # Whether PA1 turns the fast serial buffers outwards, the drive's CIA
+    # driving DATA and SRQ.
+    attr_reader :fast_serial_out
+
+    def cia
+      settle!
+      @cia
+    end
+
+    def fdc
+      settle!
+      @fdc
+    end
+
+    def model_name = "1571"
+
+    # +rom+ covers $8000-$FFFF, and defaults to the DOS image in the ROM
+    # path. +device+ is the number the jumpers on VIA 1's PB5 and PB6 set,
+    # 8 to 11.
+    def initialize(rom: nil, host_clock_hz: CLOCK_HZ, device: 8, debug: false)
+      @device = device
+      @clock_hz = CLOCK_HZ
+      @fast_serial_out = false
+      @fast_output = 0
+      @mechanism = Drive1541::Mechanism.new(slip: 2)
+      @serial_port = SerialPort.new(@mechanism, device:)
+      @via1 = SerialVIA.new(start: 0x1800, peripheral: @serial_port, drive: self)
+      @via2 = Drive1541::DiskVIA.new(start: 0x1c00, mechanism: @mechanism)
+      @cia = CIA.new(start: 0x4000)
+      @fdc = WD1770.new
+      @bus = Bus.new(rom: rom || ROM.load("dos1571.rom", 0x8000), via1: @via1, via2: @via2, cia: @cia, fdc: @fdc)
+      @cpu = CPU.new(@bus, debug:)
+      @idle_loop = IDLE_LOOP
+      @host_clock_hz = host_clock_hz
+      @phase = 0
+      @cycles = 0
+      @serial_bus = nil
+      init_idle(debug)
+      # CA1 powers up at the level of a released ATN, without an edge.
+      @via1.ca1 = false
+      @via1.reset!
+      connect(IECBus.new)
+    end
+
+    # The serial bus's RESET line reaches the CPU, both VIAs and the CIA.
+    # RAM keeps its contents.
+    def reset!
+      settle!
+      @via1.reset!
+      @via2.reset!
+      @cia.reset!
+      @cpu.reset!
+    end
+
+    # VIA 1 drives port A to +lines+: the side, the clock rate and the fast
+    # serial direction follow it.
+    def port_a_written(lines)
+      @mechanism.side = lines.anybits?(SIDE) ? 1 : 0
+      fast_serial_out = lines.anybits?(FAST_SERIAL_OUT)
+      turn_fast_serial(fast_serial_out) if fast_serial_out != @fast_serial_out
+      clock_hz = lines.anybits?(FAST) ? FAST_CLOCK_HZ : CLOCK_HZ
+      return if clock_hz == @clock_hz
+
+      @clock_hz = clock_hz
+      @mechanism.clock_hz = clock_hz
+    end
+
+    # Whether the drive runs at 2 MHz.
+    def fast? = @clock_hz == FAST_CLOCK_HZ
+
+    # VIA 1's port B, with the fast serial pins pulling DATA and SRQ
+    # (IECBus::DRIVE_FAST_DATA and DRIVE_FAST_SRQ) above it.
+    def serial_output = @via1.port_b_output | @fast_output
+
+    # The host moved its fast serial pins: the CIA hears SRQ on CNT and
+    # DATA on SP while PA1 turns the buffers inwards.
+    def fast_lines_moved
+      settle!
+      hear_fast_serial unless @fast_serial_out
+    end
+
+    # The drive's whole state, as the 1541's (Drive1541#save_state), with
+    # the CIA and the WD1770's registers. The clock rate, the side and the
+    # fast serial direction follow from VIA 1's port A.
+    def save_state(out)
+      settle!
+      out.marker("DRIVE1571")
+      out.int(@phase).int(@cycles).boolean(@mechanism.so_pending)
+      @serial_port.save_state(out)
+      @via1.save_state(out)
+      @via2.save_state(out)
+      @cia.save_state(out)
+      @fdc.save_state(out)
+      @bus.save_state(out)
+      @cpu.save_state(out)
+      @mechanism.save_state(out)
+    end
+
+    def load_state(input)
+      settle!
+      input.marker("DRIVE1571")
+      @phase = input.int
+      @cycles = input.int
+      @mechanism.so_pending = input.boolean?
+      @serial_port.load_state(input)
+      @via1.load_state(input)
+      @via2.load_state(input)
+      @cia.load_state(input)
+      @fdc.load_state(input)
+      @bus.load_state(input)
+      @cpu.load_state(input)
+      @mechanism.load_state(input)
+      @fast_serial_out = @via1.port_a_output.anybits?(FAST_SERIAL_OUT)
+      port_a_written(@via1.port_a_output)
+      push_fast_output(@fast_serial_out ? fast_pins : 0)
+      forget_orbits
+    end
+
+    private
+
+    # One drive cycle, as the 1541's (Drive1541#step), with the CIA
+    # clocked beside the VIAs and pulling IRQ with them.
+    def step
+      so = @mechanism.take_so
+      @mechanism.cycle!
+      @via1.ca1 = @serial_port.atn_low?
+      @via1.cycle!
+      @via2.cycle!
+      @cia.cycle!
+      drive_fast_serial if @fast_serial_out
+      @cpu.irq = @via1.irq? || @via2.irq? || @cia.interrupted?
+      @cpu.so! if so
+      @cpu.cycle!
+      @cycles += 1
+    end
+
+    # The VIAs' quiet cycles while the CIA is quiet, and none otherwise.
+    def quiet_cycles
+      @cia.quiet? ? [@via1.quiet_cycles, @via2.quiet_cycles].min : 0
+    end
+
+    def fast_forward_chips(cycles)
+      @cia.fast_forward(cycles)
+    end
+
+    # PA1 turned the buffers round: outwards the CIA's pins drive the
+    # lines, and inwards they let go and hear them.
+    def turn_fast_serial(out)
+      @fast_serial_out = out
+      return unless @serial_bus
+
+      push_fast_output(out ? fast_pins : 0)
+      hear_fast_serial unless out
+    end
+
+    def drive_fast_serial
+      low = fast_pins
+      push_fast_output(low) if low != @fast_output
+    end
+
+    # The lines the CIA's CNT and SP pull while its serial port drives
+    # them.
+    def fast_pins
+      serial = @cia.serial
+      return 0 unless serial.output?
+
+      low = serial.cnt ? 0 : IECBus::DRIVE_FAST_SRQ
+      serial.sp_out ? low : low | IECBus::DRIVE_FAST_DATA
+    end
+
+    def push_fast_output(low)
+      @fast_output = low
+      @serial_bus&.drives_fast_moved!
+    end
+
+    def hear_fast_serial
+      low = @serial_bus.low_lines
+      serial = @cia.serial
+      serial.cnt_in = low.nobits?(IECBus::SRQ)
+      serial.sp_in = low.nobits?(IECBus::DATA)
+    end
+  end
+end

data/lib/badline/frontend/app.rb

@@ -5,6 +5,10 @@ module Badline
     # Opens the window, then runs the machine a frame at a time: poll
     # events, clock the frame's cycles, queue the sound's samples, upload the
     # changed lines, present and wait. Pacer decides the cycles and the wait.
+    #
+    # The window shows the machine's video chip, sized to the screen shown.
+    # On the C128 it follows the machine between the VIC-IIe's 40 columns
+    # and the VDC's 80, and F8 switches them until the machine next does.
     class App
       DROPFILE = 0x1000
 
@@ -18,10 +22,10 @@ module Badline
         @pacer = Pacer.new(paced: options.paced?, vsync: options.vsync?, verbose: @verbose, timing:)
         @timeline = timeline
         @snapshots = Snapshots.new(computer, options)
-        @screen = Screen.new(computer.video, timing.crop)
+        @screens = Screens.new(computer)
         @led = DriveLed.for(computer)
         @controls = Controls.new(computer)
-        @window = MachineWindow.new(@screen, timing.pixel_width, vsync: @pacer.vsync?)
+        @window = MachineWindow.new(@screens.screen, vsync: @pacer.vsync?)
         @pacer.fit(@window.refresh_rate) if @pacer.vsync?
         @sound = Sound.new(computer.sound_source, timing.clock_hz, options.sound?, @verbose)
         @gamepads = Gamepads.new(computer, @verbose)
@@ -38,7 +42,7 @@ module Badline
         @pacer.start(@started)
         @menu.open? ? paused_frame : frame while @running
         @snapshots.finish
-        @computer.drive1541&.flush
+        @computer.true_drive&.flush
         @gamepads.close
         @sound.close
         @window.close
@@ -68,6 +72,7 @@ module Badline
         @frame_report.add(stamps) if @verbose
         @frames += 1
         @timeline.run(@computer, @frames)
+        show_vdc(@timeline.display_at(@frames) == "vdc") if @timeline.display?(@frames)
         @snapshots.tick(@frames)
         @running = false if @frames == @frame_limit || @timeline.quit?(@frames)
         @pacer.check(Pacer::EARLY_CHECK, stamps.last - @started, stamps.last) if @frames == Pacer::EARLY_CHECK
@@ -109,7 +114,7 @@ module Badline
       end
 
       def handle_key(scancode, down)
-        if [Keys::TAB, Keys::F9, Keys::F10].include?(scancode)
+        if [Keys::TAB, Keys::F8, Keys::F9, Keys::F10].include?(scancode)
           handle_toggle(scancode) if down
         elsif down && @snapshots.key(scancode)
           swap(@snapshots.computer)
@@ -123,24 +128,21 @@ module Badline
       # it.
       def swap(computer)
         @computer = computer
-        timing = computer.timing
-        @screen = Screen.new(computer.video, timing.crop)
-        @window.fit(@screen, timing.pixel_width)
-        @menu.center(@window.width, @window.height)
+        @screens.computer = computer
+        fit_window
         @led = DriveLed.for(computer)
         @controls.computer = computer
         @gamepads.computer = computer
-        @sound.switch(computer.sound_source, timing.clock_hz)
+        @sound.switch(computer.sound_source, computer.timing.clock_hz)
         @snapshots.computer = computer
       end
 
       def handle_toggle(scancode)
-        if scancode == Keys::TAB
-          @controls.toggle_keys
-        elsif scancode == Keys::F9
-          return open_menu
-        else
-          @sound.toggle_mute
+        case scancode
+        when Keys::TAB then @controls.toggle_keys
+        when Keys::F8 then show_vdc(!@screens.vdc_shown?)
+        when Keys::F9 then return open_menu
+        else @sound.toggle_mute
         end
         update_title
       end
@@ -189,11 +191,19 @@ module Badline
         menu_events
       end
 
-      def update_title
-        tags = []
-        tags << @controls.tag unless @controls.tag.empty?
-        tags << "MUTED" if @sound.muted?
-        @window.title(tags)
+      def update_title = @window.title(@controls.tag, @sound.muted?)
+
+      # Shows the C128's VDC in the window, or with false its VIC-IIe.
+      def show_vdc(shown)
+        @screens.show_vdc(shown)
+        fit_window
+      end
+
+      # Builds the screen for the chip shown and fits the window to it.
+      def fit_window
+        @screens.build
+        @window.fit(@screens.screen)
+        @menu.center(@window.width, @window.height)
       end
 
       def emulate
@@ -201,8 +211,11 @@ module Badline
       end
 
       def upload
-        @screen.update
-        @window.upload(@screen)
+        @screens.follow
+        fit_window if @screens.stale?
+        screen = @screens.screen
+        screen.update
+        @window.upload(screen)
       end
 
       def draw

data/lib/badline/frontend/boot.rb

@@ -49,7 +49,7 @@ module Badline
     # or --sid the SID. The VIC-20 raises Unsupported for a .sid
     # tune.
     def self.start(options, media, writable)
-      computer = options.family == :vic20 ? vic20(options, media) : c64(options, media)
+      computer = build(options, media)
       Media::TrueDrive.plug(computer) if options.true_drive?
       unless media.nil?
         puts Media.attach(computer, media, autostart: options.autostart?, subtune: options.subtune,
@@ -58,11 +58,41 @@ module Badline
       computer
     end
 
+    def self.build(options, media)
+      case options.family
+      when :vic20 then vic20(options, media)
+      when :c128 then c128(options, media)
+      else c64(options, media)
+      end
+    end
+
     def self.c64(options, media)
       sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
       Machine.build(:c64, model: options.model, sid_model:, reu: options.reu)
     end
 
+    # A C128 in C128 mode. With --c64, or media only C64 mode runs, a .sid
+    # tune or a program that loads at the C64's BASIC start, C= is held
+    # through the reset, so the C128 KERNAL starts C64 mode.
+    def self.c128(options, media)
+      sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
+      machine = C128.new(model: options.model, sid_model:, mode: :c128)
+      machine.hold_commodore_key if options.c64_mode? || c64_media?(media)
+      machine
+    end
+
+    def self.c64_media?(media)
+      return false if media.nil? || !File.file?(media)
+
+      extension = File.extname(media).downcase
+      return true if extension == ".sid"
+      return false unless %w[.prg .p00].include?(extension)
+
+      bytes = File.binread(media).bytes
+      bytes = Storage::P00.data(bytes) if Storage::P00.wraps?(bytes)
+      bytes.length >= 2 && [Media::BASIC_START, Media::BASIC_START - 1].include?(bytes[0] | (bytes[1] << 8))
+    end
+
     # A VIC-20 with the RAM --ram names, or else the RAM `media` needs
     # (Media::Vic20Media.ram_for), which it says. Raises Unsupported for
     # media a VIC-20 doesn't take.

data/lib/badline/frontend/controls.rb

@@ -73,6 +73,8 @@ module Badline
       def key(scancode, down)
         if joystick_mode? && Keys.joystick?(scancode)
           joystick_key(scancode, down)
+        elsif @computer.family == :c128
+          c128_key(Keys.c128_key(scancode, @computer.mode), down)
         else
           c64_key(Keys.c64_key(scancode), down)
         end
@@ -111,6 +113,15 @@ module Badline
         end
       end
 
+      # CAPS LOCK and 40/80 DISPLAY aren't in the C128's matrix either.
+      def c128_key(key, down)
+        case key
+        when :caps_lock then down ? @computer.press_caps_lock : @computer.release_caps_lock
+        when :forty_eighty then down ? @computer.press_display_key : @computer.release_display_key
+        else c64_key(key, down)
+        end
+      end
+
       def paddles? = POTS.index(@pot) >= 3
 
       # A fresh pot device on its port, and none on the other. A machine

data/lib/badline/frontend/drive_led.rb

@@ -14,7 +14,7 @@ module Badline
 
       # The LED of the machine's true drive, or nil without one.
       def self.for(computer)
-        drive = computer.drive1541
+        drive = computer.true_drive
         drive ? new(drive) : nil
       end
 

data/lib/badline/frontend/keys.rb

@@ -3,7 +3,8 @@
 module Badline
   module Frontend
     # SDL scancodes follow key positions on a US layout. They map onto the C64
-    # keys and, in joystick mode, the joystick directions.
+    # keys, the C128's own keys and, in joystick mode, the joystick
+    # directions.
     module Keys
       TAB = 43
 
@@ -20,6 +21,24 @@ module Badline
         224 => :control, 225 => :lshift, 226 => :cbm, 229 => :rshift
       }.freeze
 
+      # The C128's keys that have a host key of their own: the keypad, HELP
+      # on Insert or Help, ALT on the right Alt, NO SCROLL on Scroll Lock,
+      # and CAPS LOCK and 40/80 DISPLAY, which sit outside the matrix, on
+      # Caps Lock and F6 or Pause. In C128 mode Esc is ESC, and RUN/STOP
+      # moves to Page Down. TAB and the separate cursor keys stay with the
+      # C64's keys (the joystick toggle and the cursor combinations), and in
+      # C64 mode Esc stays RUN/STOP.
+      C128_OTHERS = {
+        89 => :keypad1, 90 => :keypad2, 91 => :keypad3, 92 => :keypad4, 93 => :keypad5, 94 => :keypad6,
+        95 => :keypad7, 96 => :keypad8, 97 => :keypad9, 98 => :keypad0, 99 => :keypad_period,
+        86 => :keypad_minus, 87 => :keypad_plus, 88 => :keypad_enter,
+        73 => :help, 117 => :help, 230 => :alt, 71 => :no_scroll, 57 => :caps_lock,
+        63 => :forty_eighty, 72 => :forty_eighty, 78 => :run_stop
+      }.freeze
+
+      ESCAPE = 41
+
+      F8 = 65
       F9 = 66
       F10 = 67
       F11 = 68
@@ -38,6 +57,14 @@ module Badline
         end
       end
 
+      # The C128's key for the scancode in the C128's +mode+, :c128 or
+      # :c64: one of C128_OTHERS, ESC, or the C64's.
+      def self.c128_key(scancode, mode)
+        return :esc if scancode == ESCAPE && mode == :c128
+
+        C128_OTHERS[scancode] || c64_key(scancode)
+      end
+
       def self.arrows(scancode) = ARROWS[scancode] || :none
 
       def self.wasd(scancode) = WASD[scancode] || :none

data/lib/badline/frontend/machine_window.rb

@@ -3,10 +3,10 @@
 module Badline
   module Frontend
     # The emulator's SDL window, its renderer and the streaming texture a
-    # Screen's pixels go into. The renderer's logical size is the screen's,
-    # with each of its pixels `pixel_width` square pixels wide, so the
-    # picture keeps the machine's aspect while the menu and the drive LED
-    # draw in square pixels over it. The window opens at SCALE times that.
+    # Screen's pixels go into. The renderer's logical size is the screen's
+    # in square pixels (Screen#window_width), so the picture keeps the
+    # machine's aspect while the menu and the drive LED draw in square
+    # pixels over it. The window opens at SCALE times that.
     class MachineWindow
       SCALE = 2
       TITLE = "Badline"
@@ -18,12 +18,12 @@ module Badline
 
       # Opens the window for `screen`, presenting in step with the display
       # when `vsync`.
-      def initialize(screen, pixel_width, vsync:)
+      def initialize(screen, vsync:)
         abort "SDL_Init: #{SDL.SDL_GetError}" unless SDL.SDL_Init(SDL::INIT_VIDEO | SDL::INIT_EVENTS).zero?
 
         SDL.SDL_SetHint("SDL_RENDER_SCALE_QUALITY", "0")
         SDL.SDL_SetHint("SDL_MOUSE_RELATIVE_SCALING", "0")
-        measure(screen, pixel_width)
+        measure(screen)
         @window = SDL.SDL_CreateWindow(
           TITLE, SDL::WINDOWPOS_CENTERED, SDL::WINDOWPOS_CENTERED, @width * SCALE, @height * SCALE,
           SDL::WINDOW_RESIZABLE
@@ -42,9 +42,9 @@ module Badline
 
       # Fits the texture, the logical size and the window to another
       # machine's screen, unless it measures the same.
-      def fit(screen, pixel_width)
+      def fit(screen)
         before = [@width, @height, @texture_width]
-        measure(screen, pixel_width)
+        measure(screen)
         return if before == [@width, @height, @texture_width]
 
         SDL.SDL_DestroyTexture(@texture)
@@ -56,9 +56,12 @@ module Badline
         SDL.SDL_UpdateTexture(@texture, nil, screen.pixels, screen.row_bytes)
       end
 
-      # Titles the window, TITLE followed by `tags` in brackets.
-      def title(tags)
-        SDL.SDL_SetWindowTitle(@window, ([TITLE] + tags.map { |tag| "[#{tag}]" }).join(" "))
+      # Titles the window, TITLE followed by the controls' `tag`, unless it's
+      # empty, and MUTED when `muted`, each in brackets.
+      def title(tag, muted)
+        tags = tag.empty? ? [] : [tag]
+        tags << "MUTED" if muted
+        SDL.SDL_SetWindowTitle(@window, ([TITLE] + tags.map { |name| "[#{name}]" }).join(" "))
       end
 
       def close
@@ -70,9 +73,9 @@ module Badline
 
       private
 
-      def measure(screen, pixel_width)
+      def measure(screen)
         @texture_width = screen.width
-        @width = screen.width * pixel_width
+        @width = screen.window_width
         @height = screen.height
       end
 

data/lib/badline/frontend/menu_media.rb

@@ -28,7 +28,7 @@ module Badline
       # The expanded path of the disk in device 8, however it went in, or
       # an empty one.
       def disk_path
-        drive = @computer.drive1541
+        drive = @computer.true_drive
         unless drive.nil?
           disk = drive.disk
           return disk.nil? ? "" : disk.path.to_s
@@ -39,7 +39,7 @@ module Badline
       end
 
       def inserted?
-        drive = @computer.drive1541
+        drive = @computer.true_drive
         drive.nil? ? @computer.mounted? : !drive.disk.nil?
       end
 
@@ -73,7 +73,7 @@ module Badline
       end
 
       def eject_disk
-        drive = @computer.drive1541
+        drive = @computer.true_drive
         drive.nil? ? @computer.unmount : drive.insert(nil)
       end