badline 0.15.1 → 0.16.1

data/lib/badline/options.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "badline/pet/rom_sets"
 require "badline/options/option"
 require "badline/options/event"
 require "badline/options/table"
@@ -12,10 +13,12 @@ module Badline
   # Either opens the window for any media, or with --headless or
   # --audio-out plays or renders a .sid tune without one. `sid`, given
   # first, plays .sid tunes and directories of them in the terminal.
-  # `c64`, `vic20`, `c128` or `plus4`, given first, names the machine
-  # family, and without one the family is the C64, or the C128 for a program
-  # that loads where C128 BASIC starts. The native build adds --no-sound and
-  # --version, and badline-ruby adds --disable-jit.
+  # `c64`, `vic20`, `c128`, `plus4` or `pet`, given first, names the
+  # machine family, and without one the family is the C64, the C128 for a
+  # program that loads where C128 BASIC starts, or the PET for an 8050's
+  # or 8250's disk or a PET tape.
+  # The native build adds --no-sound and --version, and badline-ruby adds
+  # --disable-jit.
   #
   # TABLE lists the options, and both the parser and the help read it. It
   # parses by hand, inside the subset of Ruby Spinel compiles. Values come
@@ -51,6 +54,9 @@ module Badline
     # The Plus/4's RAM sizes as --ram names them, in K.
     PLUS4_RAM = { "16k" => 16, "32k" => 32, "64k" => 64 }.freeze
 
+    # The PET's, below $8000.
+    PET_RAM = { "4k" => 4, "8k" => 8, "16k" => 16, "32k" => 32 }.freeze
+
     # Where --sid-card-address puts the Plus/4's SID card.
     SID_CARD_ADDRESSES = { "fd40" => 0xfd40, "fe80" => 0xfe80 }.freeze
 
@@ -70,16 +76,24 @@ module Badline
     attr_reader :program, :media_path, :tune_paths, :subtune, :sid_model, :reu, :frames, :screenshot, :save_snapshot,
                 :audio_out, :seconds, :songlengths, :filter_chunk, :timeline
 
-    # The machine family to build (Badline::Machine), :c64, :vic20, :c128
-    # or :plus4.
+    # The machine family to build (Badline::Machine), :c64, :vic20, :c128,
+    # :plus4 or :pet.
     attr_reader :family
 
+    # The ROMs --basic, --editor and --characters fit a PET with, keys of
+    # PET::ROMSets::BASICS, PET::ROMSets::EDITORS and
+    # PET::ROMSets::CHARACTERS, or nil for its own.
+    attr_reader :basic, :editor, :characters
+
+    # The 8296's board jumpers --jumpers names (PET::Bus::Expansion::JUMPERS).
+    attr_reader :jumpers
+
     # The VIC-20's RAM expansion --ram names, a key of
     # Vic20::Bus::RAM_CONFIGURATIONS, or nil without --ram.
     attr_reader :ram
 
-    # The Plus/4's RAM in K --ram names, one of PLUS4_RAM's, or nil without
-    # --ram.
+    # The Plus/4's or the PET's RAM in K --ram names, one of PLUS4_RAM's or
+    # PET_RAM's, or nil without --ram.
     attr_reader :ram_kb
 
     # The Plus/4's cartridge ROM images --c1lo, --c1hi, --c2lo and --c2hi
@@ -121,6 +135,8 @@ module Badline
       @reu = nil
       @ram = nil
       @ram_kb = nil
+      @ram_name = nil
+      initialize_pet
       @cartridges = {}
       @autostart = true
       @writable = false
@@ -229,6 +245,10 @@ module Badline
     # power-on.
     def c64_mode? = @c64_mode
 
+    # The frame rate of a CRTC PET's editor: 60 with --60hz or a 60 Hz
+    # --editor, else 50.
+    def refresh_hz = @refresh_hz || 50
+
     def help? = @help
 
     def version? = @version
@@ -244,7 +264,7 @@ module Badline
     # A .sid on its own plays in the SID player, as `sid` would, unless an
     # option of the emulator's window asks for the machine.
     def play_lone_tune
-      return if @sid_command || %i[vic20 plus4].include?(@family) || headless? || !@window_only.empty?
+      return if @sid_command || %i[vic20 plus4 pet].include?(@family) || headless? || !@window_only.empty?
       return if @media_path.nil?
 
       @sid_command = File.extname(@media_path).casecmp?(".sid")
@@ -303,7 +323,8 @@ module Badline
       when "--ram-expansion" then @ram_expansion = plus4_ram_expansion(value)
       when "--model" then @models << value
       when "--reu" then @reu = reu_size(value)
-      when "--ram" then ram_option(value)
+      when "--ram" then @ram_name = value
+      when "--basic", "--editor", "--characters", "--jumpers" then pet_option(name, value)
       when "--drive-type" then @drive_type = drive_type_for(value)
       when "--c1lo", "--c1hi", "--c2lo", "--c2hi" then @cartridges[CARTRIDGE_SLOTS.fetch(name)] = value
       when "--frames" then @frames = number(flag, value)
@@ -318,12 +339,21 @@ module Badline
       end
     end
 
-    # --ram names the VIC-20's RAM expansion, or the Plus/4's RAM.
-    def ram_option(value)
-      if @family == :plus4
-        @ram_kb = plus4_ram(value)
-      else
-        @ram = ram_configuration(value)
+    # The PET's frame rate, ROMs and board jumpers, its own until named.
+    def initialize_pet
+      @refresh_hz = nil
+      @basic = nil
+      @editor = nil
+      @characters = nil
+      @jumpers = []
+    end
+
+    def pet_option(name, value)
+      case name
+      when "--basic" then @basic = value
+      when "--editor" then @editor = value
+      when "--characters" then @characters = value
+      else @jumpers = value.split(",")
       end
     end
 
@@ -339,6 +369,7 @@ module Badline
       when "--vice" then @vice = true
       when "--ntsc" then @models << "ntsc"
       when "--c64" then @c64_mode = true
+      when "--60hz" then @refresh_hz = 60
       when "--unpaced" then @paced = false
       when "--disable-jit" then @jit = false
       when "--help" then @help = true

data/lib/badline/pet/bus/expansion.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    class Bus
+      # The 64K board of the 8096 and the 8296: four 16K banks, which a
+      # write-only control register at $FFF0 lays over $8000-$FFFF, two at
+      # a time:
+      #
+      #   bit 7  the board on; when clear, the rest ignored
+      #   bit 6  I/O shows through at $E800-$EFFF
+      #   bit 5  the screen shows through at $8000-$8FFF
+      #   bit 3  bank 3 at $C000-$FFFF, else bank 1
+      #   bit 2  bank 2 at $8000-$BFFF, else bank 0
+      #   bit 1  writes to $C000-$FFFF go nowhere
+      #   bit 0  writes to $8000-$BFFF go nowhere
+      #
+      # A write to $FFF0 lands where $FFF0 was before it, too. The RES line
+      # clears the register, so the 8096 starts as an 8032.
+      #
+      # The 8296 decodes its memory in a PLA, after the logic equations
+      # André Fachat read out of it (8296desc.txt on zimmers.net), with 32K
+      # of RAM from $8000 (Bus#screen) besides the board:
+      #
+      # - With bit 7 clear, every write from $8000 up but to $E8xx goes to
+      #   that RAM, under the ROMs too. Reads find the screen at $8000,
+      #   the empty sockets at $9000 and $A000, BASIC, the editor at
+      #   $E000-$E7FF and again at $E900-$EFFF, and the KERNAL, unless the
+      #   lines /RAMSEL9, /RAMSELA and /RAMON put RAM there (#ram_lines).
+      #   RAMSEL9 puts it at $9000, RAMSELA at $A000, RAMON at
+      #   $8000-$DFFF, RAMON with either of the others at $E000-$EFFF but
+      #   $E8xx, and RAMON with RAMSELA at $F000 as well.
+      # - With bit 7 set, I/O showing through brings back the editor at
+      #   $E900-$EFFF, which an 8096 leaves empty.
+      #
+      # Jumpers tie the lines: JU2 RAMSEL9 low and JU1 RAMSELA low
+      # (:ram9, :rama), or JU4, JU3 and JU5 RAMSEL9, RAMSELA and RAMON to
+      # the user port's PA1, PA0 and PA2 (:userport), each active low.
+      # With none fitted, as on xpet's 8296, the lines stay high.
+      class Expansion
+        # A 16K bank of the board, seen from +start+.
+        class Window
+          attr_accessor :read_only
+
+          def initialize(cells, offset, start)
+            @cells = cells
+            @offset = offset - start
+            @read_only = false
+          end
+
+          def peek(addr) = @cells[addr + @offset]
+
+          def poke(addr, value)
+            @cells[addr + @offset] = value unless @read_only
+          end
+        end
+
+        # Page $FF's writes, which pass to what the page holds and set the
+        # control register at $FFF0.
+        class ControlPort
+          attr_accessor :under
+
+          def initialize(expansion, under)
+            @expansion = expansion
+            @under = under
+          end
+
+          def poke(addr, value)
+            @under.poke(addr, value)
+            @expansion.control = value if addr == 0xfff0
+          end
+        end
+
+        # The user port lines that RAMSELA, RAMSEL9 and RAMON follow.
+        USER_PORT_LINES = 0x07
+
+        attr_reader :cells, :control
+
+        # The user port's PA0-PA2 as the board last saw them.
+        attr_reader :lines
+
+        # +jumpers+ are the 8296's (ROMSets::JUMPERS) when +board8296+ is.
+        def initialize(bus, board8296: false, jumpers: [])
+          @bus = bus
+          @cells = Array.new(0x10000, 0)
+          @banks = [0x8000, 0xc000, 0x8000, 0xc000].each_with_index.map do |start, bank|
+            Window.new(@cells, bank * 0x4000, start)
+          end
+          @port = ControlPort.new(self, @banks[1])
+          @control = 0
+          @board8296 = board8296
+          @ram9 = jumpers.include?("ram9")
+          @rama = jumpers.include?("rama")
+          @user_port = jumpers.include?("userport")
+          @lines = USER_PORT_LINES
+        end
+
+        def board8296? = @board8296
+
+        # Whether the board follows the user port's lines.
+        def user_port? = @user_port
+
+        def control=(value)
+          @control = value
+          @bus.map_pages
+        end
+
+        # Follows the user port's lines, +port_a+ as the VIA drives them.
+        def lines=(port_a)
+          lines = port_a & USER_PORT_LINES
+          return if lines == @lines
+
+          @lines = lines
+          @bus.map_pages
+        end
+
+        def reset!
+          self.control = 0
+        end
+
+        def power_on!
+          @cells.fill(0)
+        end
+
+        # Whether the CPU reads the KERNAL at $F000-$FFFF.
+        def kernal_mapped?
+          return false if @control.anybits?(0x80)
+
+          !(@board8296 && ram_on? && ram_a?)
+        end
+
+        # Lays the banks the register picks over the pages, and the
+        # control register over page $FF's writes.
+        def map(reads, writes)
+          if @control.anybits?(0x80)
+            map_banks(reads, writes)
+          elsif @board8296
+            map_ram8296(reads, writes)
+          end
+          @port.under = writes[0xff]
+          writes[0xff] = @port
+        end
+
+        private
+
+        def ram_on? = @user_port && @lines.nobits?(0x04)
+
+        def ram9? = @ram9 || (@user_port && @lines.nobits?(0x02))
+
+        def ram_a? = @rama || (@user_port && @lines.nobits?(0x01))
+
+        def map_banks(reads, writes)
+          low = @banks[@control.anybits?(0x04) ? 2 : 0]
+          high = @banks[@control.anybits?(0x08) ? 3 : 1]
+          low.read_only = @control.anybits?(0x01)
+          high.read_only = @control.anybits?(0x02)
+          first = @control.anybits?(0x20) ? 0x90 : 0x80
+          reads.fill(low, first, 0xc0 - first)
+          writes.fill(low, first, 0xc0 - first)
+          [[0xc0, 0x28], [0xe8, 0x08], [0xf0, 0x10]].each do |page, count|
+            next if page == 0xe8 && @control.anybits?(0x40)
+
+            reads.fill(high, page, count)
+            writes.fill(high, page, count)
+          end
+          map_editor_through(reads, writes) if @board8296
+        end
+
+        # I/O showing through on the 8296 leaves $E900-$EFFF to the editor,
+        # and its writes to nothing.
+        def map_editor_through(reads, writes)
+          return unless @control.anybits?(0x40)
+
+          reads.fill(@bus.editor_rom, 0xe9, 0x07)
+          writes.fill(@bus.open_bus, 0xe9, 0x07)
+        end
+
+        def map_ram8296(reads, writes)
+          ram = @bus.screen
+          writes.fill(ram, 0x90, 0x58)
+          writes.fill(ram, 0xe9, 0x17)
+          reads.fill(@bus.editor_rom, 0xe9, 0x07)
+          ram_on = ram_on?
+          ram9 = ram9?
+          ram_a = ram_a?
+          reads.fill(ram, 0x90, 0x10) if ram9 || ram_on
+          reads.fill(ram, 0xa0, 0x10) if ram_a || ram_on
+          return unless ram_on
+
+          reads.fill(ram, 0xb0, 0x30)
+          return unless ram9 || ram_a
+
+          reads.fill(ram, 0xe0, 0x08)
+          reads.fill(ram, 0xe9, 0x07)
+          reads.fill(ram, 0xf0, 0x10) if ram_a
+        end
+      end
+    end
+  end
+end

data/lib/badline/pet/bus.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require "badline/pet/bus/expansion"
+
+module Badline
+  class PET
+    # The CPU's bus:
+    #
+    # $0000-$7FFF - RAM, 4K, 8K, 16K or 32K of it from $0000, then nothing
+    # $8000-$8FFF - screen RAM, repeated (Model), then nothing
+    # $9000-$AFFF - two empty ROM sockets
+    # $B000-$DFFF - BASIC 4, or BASIC 1 or 2 from $C000
+    # $E000-$E7FF - the screen editor ROM
+    # $E800-$E8FF - I/O (IO)
+    # $E900-$EFFF - nothing
+    # $F000-$FFFF - the KERNAL ROM
+    #
+    # The data lines hold the last byte they carried, so a read from an
+    # empty spot finds it, mostly the high byte of the address just
+    # fetched, as PET/unconnected shows on a real 3016. Writes to ROM and
+    # to empty spots go nowhere. An 8096 banks its 64K board over
+    # $8000-$FFFF (Expansion), and an 8296 its board and the RAM under its
+    # ROMs.
+    class Bus
+      include Addressable
+
+      # The last byte the CPU moved, which an empty spot reads back.
+      class OpenBus
+        def initialize(bus)
+          @bus = bus
+        end
+
+        def peek(_addr) = @bus.data
+        def poke(_addr, _value); end
+      end
+
+      # Screen RAM, repeated over the pages it answers in. On the 8296 it is
+      # all 32K of RAM from $8000, which the board lays under the ROMs.
+      class ScreenRAM
+        attr_reader :cells
+
+        def initialize(size)
+          @cells = Array.new(size, 0)
+          @mask = size - 1
+        end
+
+        def peek(addr) = @cells[addr & @mask]
+
+        def poke(addr, value)
+          @cells[addr & @mask] = value
+        end
+      end
+
+      # $E800-$E8FF. Each chip answers on one address line, with its
+      # registers repeated: A4 selects PIA 1, A5 PIA 2, A6 the VIA and A7
+      # the CRTC, where there is one. Where more than one chip answers a
+      # read, each pulls the lines it drives low, so the CPU reads the AND
+      # of them, and a write reaches them all. Where none answers, as in
+      # $E800-$E80F, the CPU reads the last byte on the bus.
+      class IO
+        def initialize(bus, pia1:, pia2:, via:, crtc:, crtc_fitted:)
+          @bus = bus
+          @pia1 = pia1
+          @pia2 = pia2
+          @via = via
+          @crtc = crtc
+          @lines = crtc_fitted ? 0xf0 : 0x70
+        end
+
+        def peek(addr)
+          return @bus.data if addr.nobits?(@lines)
+
+          value = 0xff
+          value &= @pia1.peek(addr) if addr.anybits?(0x10)
+          value &= @pia2.peek(addr) if addr.anybits?(0x20)
+          value &= @via.peek(addr) if addr.anybits?(0x40)
+          value &= @crtc.peek(addr) if addr.anybits?(@lines & 0x80)
+          value
+        end
+
+        def poke(addr, value)
+          @pia1.poke(addr, value) if addr.anybits?(0x10)
+          @pia2.poke(addr, value) if addr.anybits?(0x20)
+          @via.poke(addr, value) if addr.anybits?(0x40)
+          @crtc.poke(addr, value) if addr.anybits?(@lines & 0x80)
+          @bus.io_written
+        end
+      end
+
+      # VICE's debug cartridge register at $8BFF, which a write calls the
+      # handler with, the exit code the VICE testprogs report. It answers
+      # on every model, ahead of the 2001's screen RAM there and the
+      # 8096's banks, and every other write to its page passes to what
+      # the page holds.
+      class DebugRegister
+        ADDRESS = 0x8bff
+
+        attr_accessor :under
+
+        def initialize(&handler)
+          @handler = handler
+          @under = nil
+        end
+
+        def poke(addr, value)
+          return @handler.call(value) if addr == ADDRESS
+
+          @under.poke(addr, value)
+        end
+      end
+
+      attr_reader :ram, :screen, :expansion, :editor_rom, :open_bus
+
+      # The last byte the CPU read or wrote.
+      attr_reader :data
+
+      # +model+ is a Model::Profile, +ram_kb+ the RAM below $8000 and
+      # +editor+ the editor ROM's file. The CRTC answers only on a board
+      # the model fits one on. +jumpers+ are the 8296's (ROMSets::JUMPERS).
+      def initialize(model:, ram_kb:, editor:, pia1:, pia2:, via:, crtc:, jumpers: [])
+        addressable_at(0, length: 2**16)
+        @ram = Memory.new([], length: ram_kb * 1024, start: 0)
+        @screen = ScreenRAM.new(model.screen_bytes)
+        @screen_pages = model.screen_pages
+        basic = ROM.read(model.basic)
+        @basic_rom = ROM.new(basic, length: basic.length, start: 0xe000 - basic.length)
+        @editor_rom = model.cbm8296? ? editor_socket(editor) : ROM.load(editor, 0xe000)
+        @kernal_rom = ROM.load(model.kernal, 0xf000)
+        @io = IO.new(self, pia1:, pia2:, via:, crtc:, crtc_fitted: model.crtc?)
+        @open_bus = OpenBus.new(self)
+        @data = 0
+        @read_pages = Array.new(256, @open_bus)
+        @write_pages = Array.new(256, @open_bus)
+        @expansion = model.expansion ? Expansion.new(self, board8296: model.cbm8296?, jumpers:) : nil
+        @via = via
+        @user_port = !@expansion.nil? && @expansion.user_port?
+        @debug_register = nil
+        @io_write_handler = nil
+        map_pages
+      end
+
+      # Calls the block after each write to the I/O chips, which may have
+      # moved the lines their ports drive.
+      def on_io_write(&handler)
+        @io_write_handler = handler
+      end
+
+      def io_written
+        @io_write_handler&.call
+        @expansion.lines = @via.port_a_output if @user_port
+      end
+
+      # The RES line reaches the board's control register, and the user
+      # port's lines float high with the VIA's.
+      def reset!
+        return if @expansion.nil?
+
+        @expansion.reset!
+        @expansion.lines = @via.port_a_output if @user_port
+      end
+
+      def power_on!
+        @ram.clear!
+        @screen.cells.fill(0)
+        @expansion&.power_on!
+      end
+
+      def peek(addr)
+        @data = @read_pages[addr >> 8].peek(addr)
+      end
+
+      def poke(addr, value)
+        @data = value
+        @write_pages[addr >> 8].poke(addr, value)
+      end
+
+      # Whether the CPU reads the KERNAL ROM at $F000-$FFFF, which an 8096's
+      # board covers while its control register turns it on, and an 8296's
+      # RAM too.
+      def kernal_mapped? = @expansion.nil? || @expansion.kernal_mapped?
+
+      # Calls the block with each byte written to $8BFF (DebugRegister).
+      def install_debug_register(&)
+        @debug_register = DebugRegister.new(&)
+        map_pages
+      end
+
+      # Lays the pages out again, for the board's control register.
+      def map_pages
+        map(@open_bus, 0x00, 0x100)
+        map(@ram, 0x00, @ram.length >> 8)
+        map(@screen, 0x80, @screen_pages)
+        @read_pages.fill(@basic_rom, @basic_rom.start >> 8, @basic_rom.length >> 8)
+        @read_pages.fill(@editor_rom, 0xe0, 0x08)
+        map(@io, 0xe8, 0x01)
+        @read_pages.fill(@kernal_rom, 0xf0, 0x10)
+        @expansion&.map(@read_pages, @write_pages)
+        map_debug_register if @debug_register
+      end
+
+      private
+
+      # The 8296's editor socket, which answers at $E000-$E7FF and
+      # $E900-$EFFF: a 4K ROM's halves there, or a 2K one twice over.
+      def editor_socket(file)
+        bytes = ROM.read(file)
+        bytes += bytes if bytes.length == 0x800
+        ROM.new(bytes, length: 0x1000, start: 0xe000)
+      end
+
+      def map_debug_register
+        @debug_register.under = @write_pages[0x8b]
+        @write_pages[0x8b] = @debug_register
+      end
+
+      def map(chip, first, count)
+        @read_pages.fill(chip, first, count)
+        @write_pages.fill(chip, first, count)
+      end
+    end
+  end
+end

data/lib/badline/pet/canvas.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # The picture a front end shows, a palette index a dot: 0 for black and
+    # 1 for the lit phosphor. The video paints it eight dots at a time, one
+    # character ROM row, and leaves alone the dots that would not change:
+    # each four dots remember the row last painted from them, and a
+    # painting that overlaps theirs from elsewhere makes them forget it.
+    #
+    # Each line keeps the span its last painting covered. When a line's
+    # span changes, the dots it covered before and doesn't now go black.
+    class Canvas
+      # Black and the green of a P1 phosphor, as the VICE testbench's
+      # references draw them.
+      PALETTE = [0x000000, 0x41ff00].freeze
+
+      # The eight dots of each ROM row, the leftmost in bit 7.
+      DOTS = Array.new(256) { |bits| Array.new(8) { |dot| (bits >> (7 - dot)) & 1 } }.freeze
+
+      attr_reader :display, :width, :height, :dirty_lines
+
+      # Nothing paints within +margin+ dots of either side.
+      def initialize(width, height, margin: 0)
+        @first = margin
+        @last = width - 8 - margin
+        @width = width
+        @height = height
+        @display = Array.new(width * height, 0)
+        @dirty_lines = Array.new(height, true)
+        @slot_width = width >> 2
+        @painted = Array.new(@slot_width * height, 0)
+        @span_from = Array.new(height, 0)
+        @span_to = Array.new(height, 0)
+      end
+
+      def palette = PALETTE
+
+      def clear_dirty_lines!
+        @dirty_lines.fill(false)
+      end
+
+      # Paints `bits` on `line` from dot `column` on, if they fit.
+      def paint(column, line, bits)
+        return if column < @first || column > @last
+
+        slot = (line * @slot_width) + (column >> 2)
+        return if @painted[slot] == bits
+
+        @painted[slot] = bits
+        @painted[slot - 1] = -1 if slot.positive?
+        @painted[slot + 1] = -1 if slot + 1 < @painted.length
+        @display[(line * @width) + column, 8] = DOTS[bits]
+        @dirty_lines[line] = true
+      end
+
+      # Sets `line`'s span to the dots from `from` up to `to`, none if `to`
+      # isn't past `from`, and blacks out what its last one covered beyond
+      # it.
+      def span(line, from, to)
+        width = @width
+        from = 0 if from.negative?
+        to = width if to > width
+        from = to = 0 if to <= from
+        old_from = @span_from[line]
+        old_to = @span_to[line]
+        return if from == old_from && to == old_to
+
+        blank(line, old_from, [from, old_to].min) if old_from < from
+        blank(line, [to, old_from].max, old_to) if old_to > to
+        @span_from[line] = from
+        @span_to[line] = to
+      end
+
+      # Blacks out every dot, as at power on.
+      def clear!
+        @display.fill(0)
+        @painted.fill(0)
+        @span_from.fill(0)
+        @span_to.fill(0)
+        @dirty_lines.fill(true)
+      end
+
+      private
+
+      def blank(line, from, to)
+        return if to <= from
+
+        @display.fill(0, (line * @width) + from, to - from)
+        first = (line * @slot_width) + (from >> 2)
+        @painted.fill(0, first, ((to + 3) >> 2) - (from >> 2))
+        @painted[first - 1] = -1 if from >= 4
+        @dirty_lines[line] = true
+      end
+    end
+  end
+end