badline 0.15.0 → 0.16.0

data/lib/badline/drives/model1551/tia.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1551
+      # The drive's 6523 TIA at $4000-$7FFF, its eight registers mirrored
+      # (zimmers.net's 1551 memory map, schematic 251860):
+      #
+      # - Port A carries the cable's eight data lines, pulled up.
+      # - Port B reads the GCR byte the gate array latched at BYTE READY
+      #   and drives the byte the head writes.
+      # - Port C drives STATUS0 and STATUS1 (PC0-1), DEV (PC2), which picks
+      #   where the computer's TIA answers, ACK (PC3) and the head's MODE
+      #   (PC4, low to write), and reads the device number jumper (PC5,
+      #   high for device 9), SYNC (PC6, low in a SYNC mark) and DAV (PC7).
+      #
+      # The DOS sets port C's directions to $1F. The cable's lines are
+      # pulled up, so an input nothing drives reads 1.
+      #
+      # Any access to the TIA clears BYTE LATCHED.
+      class TIA < Chips::TIA
+        DAV = 0x80
+        SYNC = 0x40
+        JUMPER = 0x20
+        MODE = 0x10
+
+        def initialize(mechanism, device:)
+          @mechanism = mechanism
+          @jumper = device == 9 ? JUMPER : 0
+          mechanism.tia = self
+          super()
+          @inputs[0] = 0xff
+          @inputs[1] = 0xff
+          @inputs[2] = 0xff
+        end
+
+        def reset!
+          super
+          mode_written
+        end
+
+        def peek(addr)
+          mechanism = @mechanism
+          mechanism.release_byte_latch
+          case addr & 0x07
+          when 1 then @inputs[1] = mechanism.latched_byte
+          when 2 then @inputs[2] = (@inputs[2] & DAV) | (mechanism.sync? ? 0 : SYNC) | @jumper | 0x1f
+          end
+          super
+        end
+
+        def poke(addr, value)
+          @mechanism.release_byte_latch
+          super
+          register = addr & 0x07
+          mode_written if [2, 5].include?(register)
+        end
+
+        # What port B drives onto the head's write shift register.
+        def port_b_output = output(1)
+
+        private
+
+        # MODE selects reading while high, as the 1541's CB2 does.
+        def mode_written
+          @mechanism.cb2_written(output(2).anybits?(MODE))
+        end
+      end
+    end
+  end
+end

data/lib/badline/drives/model1551.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "badline/chips/tia"
+require "badline/drives/model1541"
+require "badline/drives/model1551/cpu"
+require "badline/drives/model1551/port"
+require "badline/drives/model1551/tia"
+require "badline/drives/model1551/bus"
+require "badline/drives/model1551/cable"
+require "badline/drives/model1551/keyed_state"
+
+module Badline
+  module Drives
+    # The 1551 disk drive of the 264 series: a 6510T at 2 MHz running DOS
+    # 2.6 from 16 KB of ROM, with 2 KB of RAM, the 1541's GCR mechanism
+    # behind a gate array, and a 6523 TIA facing the computer over TCBM, a
+    # parallel cable to a second 6523 in the computer's expansion port
+    # (Commodore schematic 251860; zimmers.net's 1551 memory map).
+    #
+    # The 6510T's port drives the mechanism as the 1541's VIA 2 port B does
+    # and reads the write-protect sensor and the gate array's BYTE LATCHED
+    # (Port). The TIA's port B reads the GCR byte the gate array latched and
+    # drives the byte to write, and its port C selects reading or writing
+    # and reads SYNC (TIA).
+    #
+    # The drive comes with its interface for the computer's expansion port,
+    # a second 6523 (#host_tia), which the cable joins to the drive's
+    # (Cable). The computer puts it at $FEE0 for device 8 and at $FEC0 for
+    # device 9, as the drive's DEV line (PC2) says: high for device 8 and
+    # low for device 9. The DOS sets DEV from the jumper at reset, and again
+    # when a command renumbers the drive. The device number follows each
+    # change on the line (#device).
+    #
+    # A 555 timer pulls IRQ low for about 7 µs every 8.3 ms, its R1 120K,
+    # R2 100R and C1 0.1 µF, which runs the DOS's job loop. Nothing
+    # acknowledges it: the line lets go on its own.
+    #
+    # Drives::Engine::Core clocks it against the host and sleeps through
+    # the DOS's idle loop, which counts its passes in $61 (Engine::Idle's
+    # pass counter), until the 555 is due to pull IRQ, the count wraps or
+    # the computer moves the cable's lines.
+    class Model1551
+      include Engine::Core
+
+      CLOCK_HZ = 2_000_000
+
+      # The 555's cycle in drive cycles: high for 0.693 (R1 + R2) C and low,
+      # pulling IRQ, for 0.693 R2 C.
+      IRQ_PERIOD = 16_660
+      IRQ_LOW = 14
+
+      # The host cycles, at about 1 MHz, by which a 1551 switched on with the
+      # machine has run its DOS's reset, the RAM test and the ROM checksum,
+      # and answers TCBM: half a second, with a margin.
+      BOOT_CYCLES = 600_000
+
+      # Where the DOS's idle loop starts over, polling the TIA's port A for
+      # a command from the computer.
+      IDLE_LOOP = 0xeabd
+
+      # The byte the idle loop increments on each pass.
+      PASS_COUNTER = 0x61
+
+      def port
+        settle!
+        @port
+      end
+
+      def tia
+        settle!
+        @tia
+      end
+
+      # The TIA in the computer's expansion port, which the computer reads
+      # and writes without waking the drive.
+      attr_reader :host_tia
+
+      # The cable between the two TIAs.
+      def cable
+        settle!
+        @cable
+      end
+
+      def model_name = "1551"
+
+      # +rom+ covers $C000-$FFFF, and defaults to the DOS image in the ROM
+      # path. +device+ is 8 or 9, as the jumper on the TIA's PC5 sets it.
+      def initialize(rom: nil, host_clock_hz: CLOCK_HZ, device: 8, debug: false)
+        raise ArgumentError, "a 1551 is device 8 or 9, not #{device}" unless [8, 9].include?(device)
+
+        @device = device
+        @clock_hz = CLOCK_HZ
+        @mechanism = Model1541::Mechanism.new
+        @mechanism.clock_hz = CLOCK_HZ
+        @port = Port.new(@mechanism)
+        @tia = TIA.new(@mechanism, device:)
+        @host_tia = Chips::TIA.new
+        @bus = Bus.new(rom: rom || ROM.load("dos1551.rom", 0xc000), port: @port, tia: @tia)
+        @cpu = CPU.new(@bus, debug:)
+        @idle_loop = IDLE_LOOP
+        @host_clock_hz = host_clock_hz
+        @phase = 0
+        @cycles = 0
+        @irq_timer = IRQ_PERIOD
+        init_idle(debug)
+        @pass_counter = PASS_COUNTER
+        @dev_high = true
+        @on_renumber = nil
+        @cable = Cable.new(@host_tia, @tia, self)
+        @serial_port = @cable
+      end
+
+      # Calls the block with the old device number each time the DEV line
+      # moves the drive to the other one.
+      def on_renumber(&block)
+        @on_renumber = block
+      end
+
+      # The cable's DEV line, high or not. A change moves the drive to
+      # device 8 while it's high, and to device 9 while it's low.
+      def dev_line(high)
+        return if high == @dev_high
+
+        @dev_high = high
+        old = @device
+        @device = high ? 8 : 9
+        @on_renumber&.call(old) unless @device == old
+      end
+
+      # Puts in a Disk from the .d64 or .g64 image at +path+, write-protected
+      # with `read_only`.
+      def insert_image(path, read_only: false)
+        insert(Model1541::Disk.open(path, read_only:))
+      end
+
+      # The computer's RESET line reaches the interface's TIA and, through
+      # the cable, the CPU, its port and the drive's TIA. RAM keeps its
+      # contents, and the 555 runs on.
+      def reset!
+        settle!
+        @host_tia.reset!
+        @port.reset!
+        @tia.reset!
+        @cpu.reset!
+      end
+
+      private
+
+      # One drive cycle: the mechanism turns the disk ahead of the CPU, and
+      # the 555 pulls IRQ while its output is low.
+      def step
+        @mechanism.cycle!
+        timer = @irq_timer - 1
+        timer = IRQ_PERIOD if timer.zero?
+        @irq_timer = timer
+        @cpu.irq = timer <= IRQ_LOW
+        @cpu.cycle!
+        @cycles += 1
+      end
+
+      # A pass of the idle loop reads the TIA's port A, which holds still
+      # until the computer moves the cable's lines, and RAM. It repeats
+      # while the motor is off and the 555 leaves IRQ alone, for as long as
+      # the 555 leaves room (see Engine::Idle).
+      def busy_for_pass? = @mechanism.motor_on? || @irq_timer <= IRQ_LOW
+
+      def quiet_cycles
+        quiet = @irq_timer - IRQ_LOW - 1
+        quiet.negative? ? 0 : quiet
+      end
+
+      def idle_state
+        tia = @tia
+        [*@cpu.counting_state, @bus.data, *@mechanism.idle_state, *tia.ports, *tia.directions, *tia.inputs,
+         @port.ddr, @port.data]
+      end
+
+      def fast_forward_chips(cycles)
+        @irq_timer -= cycles
+      end
+
+      # Every 555 pulse runs the job loop, which reads the port and the TIA,
+      # so no orbit (Engine::Orbit) comes round, and the drive keeps no
+      # anchors.
+      def anchor = nil
+
+      def counter_state(_touched) = []
+
+      def skip_chip_orbits(_cycles, _touched) = nil
+    end
+  end
+end

data/lib/badline/drives/model1571.rb

@@ -26,6 +26,7 @@ module Badline
     # (CIA#quiet?).
     class Model1571
       include Engine::Core
+      include Engine::SerialConnection
       include Engine::VIAs
       include Engine::FastSerial
 

data/lib/badline/drives/model1581.rb

@@ -39,6 +39,7 @@ module Badline
     # on either chip: the drive's CIA gets no TOD pulses (CIA's tod_hz).
     class Model1581
       include Engine::Core
+      include Engine::SerialConnection
       include Engine::FastSerial
 
       CLOCK_HZ = 2_000_000

data/lib/badline/drives.rb

@@ -4,5 +4,6 @@
 # 1571 stays out of the core: badline/c128 requires it.
 require "badline/drives/datasette"
 require "badline/drives/serial_bus"
+require "badline/drives/ieee_bus"
 require "badline/drives/model1541"
 require "badline/drives/model1581"

data/lib/badline/frontend/app.rb

@@ -112,7 +112,7 @@ module Badline
       end
 
       def handle_key(scancode, down)
-        if [Keys::TAB, Keys::F8, Keys::F9, Keys::F10].include?(scancode)
+        if [Keys::F8, Keys::F9, Keys::F10].include?(scancode) || (scancode == Keys::TAB && @controls.tab_toggles?)
           handle_toggle(scancode) if down
         elsif down && @snapshots.key(scancode)
           swap(@snapshots.computer)

data/lib/badline/frontend/boot.rb

@@ -17,7 +17,11 @@ module Badline
       end
 
       computer = nil
-      problem = media_problem { computer = boot(options) }
+      problem = if cartridge?(options)
+                  cartridge_problem { computer = boot(options) }
+                else
+                  media_problem { computer = boot(options) }
+                end
       unless problem.empty?
         warn "#{options.program}: #{options.media_path}: #{problem}"
         return 1
@@ -40,6 +44,21 @@ module Badline
       e.message
     end
 
+    # Runs the block that puts a cartridge in, as media_problem does, and
+    # also returns the message of the ArgumentError a machine raises over a
+    # cartridge with a chip in a bank or slot it doesn't map.
+    def self.cartridge_problem(&)
+      media_problem(&)
+    rescue ArgumentError => e
+      e.message
+    end
+
+    # Whether the media the options start is a .crt.
+    def self.cartridge?(options)
+      media = options.media_path
+      !media.nil? && Media::Extensions.kind(media) == :cartridge
+    end
+
     # The machine a .vsf snapshot holds, built as the saved one was, or a
     # new one built from the options with the media attached.
     def self.boot(options)

data/lib/badline/frontend/controls.rb

@@ -7,7 +7,9 @@ module Badline
     # - The keys: every host key goes to the machine's keyboard, or, as Tab
     #   switches, the arrow cluster and space drive one joystick and WASD
     #   and left shift the other. The arrows start on joystick 2, and
-    #   #swap_ports swaps them. The VIC-20's one joystick takes both.
+    #   #swap_ports swaps them. The VIC-20's one joystick takes both. The
+    #   PET has no joystick, and its keys go by the character they type
+    #   (PETKeyboard).
     # - A pot device the pause menu plugs into a C64 control port: a 1351
     #   mouse or a pair of paddles, which the host mouse drives. Motion
     #   turns the paddles or moves the mouse, and the host's left and right
@@ -30,6 +32,7 @@ module Badline
         @mouse = Input::Mouse1351.new
         @paddles = Input::Paddles.new
         @held = {}
+        @pet_keyboard = pet_keyboard(computer)
       end
 
       # Routes the input to another machine, the pot device going into its
@@ -37,6 +40,7 @@ module Badline
       def computer=(computer)
         release_all
         @computer = computer
+        @pet_keyboard = pet_keyboard(computer)
         attach_pot_device
       end
 
@@ -48,10 +52,16 @@ module Badline
         release_all
       end
 
+      # Switches between the keyboard and the joysticks, on a machine with
+      # joysticks.
       def toggle_keys
-        self.joystick_mode = !@joystick
+        self.joystick_mode = !@joystick if tab_toggles?
       end
 
+      # Whether Tab switches the keys to the joysticks, or on the PET, which
+      # has none, is a key of its own.
+      def tab_toggles? = @computer.family != :pet
+
       # Plugs in one of POTS, in place of the one before.
       def plug(pot)
         @pot = pot
@@ -106,6 +116,8 @@ module Badline
       # A host key lets go of the key it pressed, though the C128 has
       # switched between C64 and C128 mode since and maps it elsewhere.
       def machine_key(scancode, down)
+        return @pet_keyboard.key(scancode, down) if @computer.family == :pet
+
         @held[scancode] = host_key(scancode) if down || !@held.key?(scancode)
         key = @held[scancode]
         @held.delete(scancode) unless down
@@ -147,7 +159,7 @@ module Badline
       # A fresh pot device on its port, and none on the other. A machine
       # without the ports takes none.
       def attach_pot_device
-        ports = @computer.control_ports
+        ports = @computer.family == :pet ? nil : @computer.control_ports
         if ports.nil?
           @pot = :none
           return
@@ -199,7 +211,15 @@ module Badline
         down ? joystick.press(direction) : joystick.release(direction)
       end
 
+      # The PET's keyboard for a PET, and for any other machine one it never
+      # uses.
+      def pet_keyboard(computer)
+        PETKeyboard.new(computer.keyboard, computer.family == :pet ? computer.model.keyboard : :graphics)
+      end
+
       def release_all
+        return @pet_keyboard.release_all if @computer.family == :pet
+
         Keys::ARROWS.each_key { |scancode| @computer.keyboard.release(host_key(scancode)) }
         Keys::WASD.each_key { |scancode| @computer.keyboard.release(host_key(scancode)) }
         Keys::ARROWS.each_value do |direction|

data/lib/badline/frontend/gamepads.rb

@@ -7,14 +7,15 @@ module Badline
     # second one joystick 1. PadPort holds the mapping.
     #
     # The controllers are polled every frame, and rescanned whenever SDL
-    # reports one added or removed.
+    # reports one added or removed. The PET has no joysticks, and the
+    # controllers steer two that nothing reads.
     class Gamepads
       PORTS = [2, 1].freeze
 
       def initialize(computer, verbose)
         @verbose = verbose
         @controllers = []
-        @ports = [PadPort.new(computer.joystick2), PadPort.new(computer.joystick1)]
+        @ports = [PadPort.new(joystick(computer, 2)), PadPort.new(joystick(computer, 1))]
         @buttons = Array.new(PadPort::BUTTON_COUNT, 0)
         @available = SDL.SDL_InitSubSystem(SDL::INIT_GAMECONTROLLER).zero?
         puts "No game controllers: #{SDL.SDL_GetError}" if @verbose && !@available
@@ -24,7 +25,7 @@ module Badline
       # what they hold on the next poll.
       def computer=(computer)
         @ports.each(&:release)
-        @ports = [PadPort.new(computer.joystick2), PadPort.new(computer.joystick1)]
+        @ports = [PadPort.new(joystick(computer, 2)), PadPort.new(joystick(computer, 1))]
       end
 
       def rescan
@@ -51,6 +52,12 @@ module Badline
 
       private
 
+      def joystick(computer, port)
+        return Input::Joystick.new if computer.family == :pet
+
+        port == 1 ? computer.joystick1 : computer.joystick2
+      end
+
       def open_controller(index)
         controller = SDL.SDL_GameControllerOpen(index)
         # SDL returns NULL when the controller won't open, which Spinel's FFI

data/lib/badline/frontend/keys.rb

@@ -65,6 +65,59 @@ module Badline
         79 => :crsr_right, 80 => :crsr_left, 81 => :crsr_down, 82 => :crsr_up, 229 => :lshift, 75 => :none
       }.freeze
 
+      # The characters the keys other than the letters type on a US
+      # layout, unshifted and then shifted, and the keypad's.
+      US_CHARACTERS = {
+        30 => "1!", 31 => "2@", 32 => "3#", 33 => "4$", 34 => "5%", 35 => "6^", 36 => "7&", 37 => "8*", 38 => "9(",
+        39 => "0)", 45 => "-_", 46 => "=+", 47 => "[{", 48 => "]}", 49 => "\\|", 51 => ";:", 52 => "'\"", 53 => "`~",
+        54 => ",<", 55 => ".>", 56 => "/?", 84 => "//", 85 => "**", 86 => "--", 87 => "++", 89 => "11", 90 => "22",
+        91 => "33", 92 => "44", 93 => "55", 94 => "66", 95 => "77", 96 => "88", 97 => "99", 98 => "00", 99 => "..",
+        103 => "=="
+      }.freeze
+
+      # The PET's keys for the characters a host key types, on either
+      # keyboard without SHIFT: each has a key of its own on the graphics
+      # keyboard, where SHIFT turns it into a graphics character. ↑ and ←
+      # are on ^, and on _ and `.
+      PET_GRAPHICS_CHARACTERS = {
+        "!" => :!, "\"" => :'"', "#" => :"#", "$" => :"$", "%" => :%, "&" => :&, "'" => :"'", "(" => :"(",
+        ")" => :")", "\\" => :"\\", "^" => :up, "_" => :left, "`" => :left, "/" => :/, ":" => :":", "*" => :*,
+        ";" => :";", "?" => :"?", "," => :",", "+" => :+, "@" => :"@", "[" => :"[", "]" => :"]", "<" => :<,
+        ">" => :>, "-" => :-, "=" => :"=", "." => :".", "1" => :"1", "2" => :"2", "3" => :"3", "4" => :"4",
+        "5" => :"5", "6" => :"6", "7" => :"7", "8" => :"8", "9" => :"9", "0" => :"0"
+      }.freeze
+
+      # The business keyboard's: the characters it types without SHIFT,
+      # then those it types with it.
+      PET_BUSINESS_CHARACTERS = {
+        "1" => :"1", "2" => :"2", "3" => :"3", "4" => :"4", "5" => :"5", "6" => :"6", "7" => :"7", "8" => :"8",
+        "9" => :"9", "0" => :"0", "-" => :-, ":" => :":", ";" => :";", "," => :",", "." => :".", "/" => :/,
+        "@" => :"@", "[" => :"[", "]" => :"]", "\\" => :"\\", "^" => :up, "_" => :left, "`" => :left
+      }.freeze
+
+      PET_BUSINESS_SHIFTED = {
+        "!" => :"1", "\"" => :"2", "#" => :"3", "$" => :"4", "%" => :"5", "&" => :"6", "'" => :"7", "(" => :"8",
+        ")" => :"9", "=" => :-, "*" => :":", "+" => :";", "<" => :",", ">" => :".", "?" => :/
+      }.freeze
+
+      # The PET's keys that don't type a character, which keep the host's
+      # SHIFT: RETURN, INST/DEL on Backspace, CLR/HOME on Home, RUN/STOP on
+      # Page Down, and RVS on Control. Esc is RUN/STOP on the graphics
+      # keyboard. The business keyboard's ESC, TAB, REPEAT and keypad are
+      # on Esc, Tab, Page Up and the keypad.
+      PET_KEYS = {
+        40 => :return, 88 => :return, 42 => :delete, 44 => :space, 74 => :clr_home, 78 => :run_stop, 224 => :rvs,
+        228 => :rvs
+      }.freeze
+
+      PET_BUSINESS_KEYS = {
+        41 => :escape, 43 => :tab, 75 => :repeat, 89 => :kp1, 90 => :kp2, 91 => :kp3, 92 => :kp4, 93 => :kp5,
+        94 => :kp6, 95 => :kp7, 96 => :kp8, 97 => :kp9, 98 => :kp0, 99 => :kp_period
+      }.freeze
+
+      # The cursor keys, CRSR ⇔ and CRSR ⇕, each with SHIFT for left or up.
+      PET_CURSORS = { RIGHT => :cursor_h, LEFT => :cursor_h, DOWN => :cursor_v, UP => :cursor_v }.freeze
+
       ARROWS = { 44 => :fire, 228 => :fire, 79 => :right, 80 => :left, 81 => :down, 82 => :up }.freeze
       WASD = { 225 => :fire, 7 => :right, 4 => :left, 22 => :down, 26 => :up }.freeze
 
@@ -89,6 +142,41 @@ module Badline
       # The 264's key for the scancode: one of PLUS4_OTHERS or the C64's.
       def self.plus4_key(scancode) = PLUS4_OTHERS[scancode] || c64_key(scancode)
 
+      # The PET key for the scancode on the +keyboard+, :graphics or
+      # :business, with the host's SHIFT down if +shift+, and how the
+      # PET's SHIFT goes with it: :on or :off for a key that types the host
+      # key's character or moves the cursor its way only so, and :host to
+      # follow the host's. A letter is the PET's letter, and any other key
+      # the PET key that types the same character, or :none.
+      def self.pet_key(scancode, shift, keyboard)
+        return [LETTERS[scancode - 4], :host] if scancode.between?(4, 29)
+
+        cursor = PET_CURSORS[scancode]
+        return [cursor, [LEFT, UP].include?(scancode) ? :on : :off] unless cursor.nil?
+
+        business = keyboard == :business
+        key = business ? PET_BUSINESS_KEYS[scancode] : nil
+        key = PET_KEYS[scancode] if key.nil?
+        key = :run_stop if key.nil? && scancode == ESCAPE
+        return [key, :host] unless key.nil?
+
+        pet_character(scancode, shift, business)
+      end
+
+      # The PET key that types the character the scancode types on a US
+      # layout, and the SHIFT it takes.
+      def self.pet_character(scancode, shift, business)
+        characters = US_CHARACTERS[scancode]
+        return %i[none host] if characters.nil?
+
+        character = characters[shift ? 1 : 0]
+        unshifted = business ? PET_BUSINESS_CHARACTERS[character] : PET_GRAPHICS_CHARACTERS[character]
+        return [unshifted, :off] unless unshifted.nil?
+
+        shifted = business ? PET_BUSINESS_SHIFTED[character] : nil
+        shifted.nil? ? %i[none host] : [shifted, :on]
+      end
+
       # The character the key types on a US layout: a letter, a capital
       # with `shift`, or a digit, and "" for any other key.
       def self.character(scancode, shift)

data/lib/badline/frontend/media_slots.rb

@@ -35,6 +35,7 @@ module Badline
         # either cartridge's slots.
         def cartridge?(computer)
           return !computer.cartridge_slots.empty? if computer.family == :plus4
+          return false if computer.family == :pet
 
           !computer.address_bus.cartridge.nil?
         end

data/lib/badline/frontend/menu/menu_dialogs.rb

@@ -37,7 +37,12 @@ module Badline
       # :program, or :snapshot, which starts in the saves folder.
       def browse(kind)
         @browsing = kind
-        extensions = kind == :cartridge ? @media.cartridge_extensions : EXTENSIONS.fetch(kind)
+        extensions = case kind
+                     when :cartridge then @media.cartridge_extensions
+                     when :disk then @media.disk_extensions
+                     when :program then programs
+                     else EXTENSIONS.fetch(kind)
+                     end
         @browser.open(kind == :snapshot ? Badline.data_folder("saves") : @browse_from, extensions)
       end
 
@@ -56,15 +61,15 @@ module Badline
       def ask_remove = @confirmation.ask(:remove, @media.cartridge_name)
 
       # Puts a dropped disk or tape in its device, or asks before a
-      # cartridge or a program starts, and says whether it asks. Other
-      # files are left alone.
+      # cartridge, a Plus/4's raw ROM image among them, or a program
+      # starts, and says whether it asks. Other files are left alone.
       def drop(path)
         extension = File.extname(path).downcase
-        return @media.insert(:disk, path) && false if EXTENSIONS[:disk].include?(extension)
+        return @media.insert(:disk, path) && false if @media.disk_extensions.include?(extension)
         return @media.insert(:tape, path) && false if EXTENSIONS[:tape].include?(extension)
-        return false unless EXTENSIONS[:program].include?(extension)
+        return false unless programs.include?(extension)
 
-        @confirmation.ask(extension == ".crt" ? :cartridge : :start, path)
+        @confirmation.ask(@media.cartridge_extensions.include?(extension) ? :cartridge : :start, path)
         true
       end
 
@@ -98,6 +103,10 @@ module Badline
 
       private
 
+      # What Quick open and a drop start: every medium, and the cartridges
+      # the machine takes.
+      def programs = (EXTENSIONS[:program] + @media.cartridge_extensions).uniq
+
       # Puts the disk or tape picked in, or asks before a cartridge or
       # Quick open power cycles the machine, and leaves the browser, as Esc
       # does.