badline 0.6.1 → 0.8.0

data/lib/badline/frontend/painter.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # Draws on an SDL renderer in the C64's colours and its character ROM's
+    # font: filled boxes, lines and text. The font is the ROM's second set,
+    # with both cases, turned into a texture once: 16 by 16 glyphs of 8 by 8
+    # pixels, white where the glyph is set and clear elsewhere, tinted to
+    # the colour asked for as each glyph is drawn.
+    class Painter
+      GLYPH = 8
+      ATLAS = GLYPH * 16
+
+      # An opaque white pixel, in the low half of a word and in the high
+      # half, where it only fits a signed 64-bit word as a negative number.
+      SET = 0xffffffff
+      SET_HIGH = -0x1_0000_0000
+
+      SPACE = 0x20
+
+      # Icons drawn in the C64's 8 by 8 cells, which take the places of the
+      # first reversed glyphs, from ICON on.
+      ICON = 0x80
+      ICONS = {
+        play: %w[.X...... .XX..... .XXX.... .XXXX... .XXXX... .XXX.... .XX..... .X......],
+        pause: %w[........ .XX..XX. .XX..XX. .XX..XX. .XX..XX. .XX..XX. .XX..XX. ........],
+        previous: %w[X.....X. X....XX. X...XXX. X..XXXX. X..XXXX. X...XXX. X....XX. X.....X.],
+        next: %w[.X.....X .XX....X .XXX...X .XXXX..X .XXXX..X .XXX...X .XX....X .X.....X],
+        left: %w[........ ....X... ...XX... ..XXX... ..XXX... ...XX... ....X... ........],
+        right: %w[........ ...X.... ...XX... ...XXX.. ...XXX.. ...XX... ...X.... ........]
+      }.freeze
+      ICON_NAMES = ICONS.keys.freeze
+
+      # The screen code of each printable ASCII character in the second set.
+      # The rest show as a question mark.
+      SCREEN_CODES = Array.new(128) do |ascii|
+        if ascii.between?(0x20, 0x3f) || ascii.between?(0x41, 0x5a) then ascii
+        elsif ascii == 0x40 then 0
+        elsif ascii.between?(0x61, 0x7a) then ascii - 0x60
+        elsif ascii == 0x5b then 27
+        elsif ascii == 0x5d then 29
+        elsif ascii == 0x5e then 30
+        elsif ascii == 0x5f then 100
+        else 63
+        end
+      end.freeze
+
+      def initialize(renderer)
+        @renderer = renderer
+        @font = SDL.SDL_CreateTexture(renderer, SDL::PIXELFORMAT_ARGB8888, SDL::TEXTUREACCESS_STREAMING, ATLAS, ATLAS)
+        SDL.SDL_SetTextureBlendMode(@font, SDL::BLENDMODE_BLEND)
+        load_font
+        SDL.rect_w(SDL.glyph_rect, GLYPH)
+        SDL.rect_h(SDL.glyph_rect, GLYPH)
+        @tint = -1
+        @size = 0
+      end
+
+      def close = SDL.SDL_DestroyTexture(@font)
+
+      def box(left, top, width, height, rgb)
+        @size = 0
+        rect = SDL.rect
+        SDL.rect_x(rect, left)
+        SDL.rect_y(rect, top)
+        SDL.rect_w(rect, width)
+        SDL.rect_h(rect, height)
+        pen(rgb)
+        SDL.SDL_RenderFillRect(@renderer, rect)
+      end
+
+      # Joins the points, each made by Painter.point, with lines.
+      def polyline(points, rgb)
+        pen(rgb)
+        SDL.SDL_RenderDrawLines(@renderer, points, points.size)
+      end
+
+      # A point for #polyline: an SDL_Point, two 32-bit ints packed into one
+      # of the words an Integer Array hands to C, x in the low half.
+      def self.point(left, top) = left | (top << 32)
+
+      # Draws the text with its top left at `left` and `top`, each glyph
+      # `scale` times its size, and returns the width drawn.
+      def text(left, top, string, rgb, scale: 1)
+        tint(rgb)
+        place(top, GLYPH * scale)
+        x = left
+        string.each_char do |char|
+          code = screen_code(char)
+          glyph(code, x) unless code == SPACE
+          x += @size
+        end
+        x - left
+      end
+
+      def self.width(string, scale: 1) = string.length * GLYPH * scale
+
+      # The string cut to `columns` characters in its middle, so both its
+      # start and its end show.
+      def self.fit(string, columns)
+        return string if string.length <= columns
+
+        head = (columns - 3) / 2
+        tail = columns - 3 - head
+        "#{string[0, head]}...#{string[string.length - tail, tail]}"
+      end
+
+      def icon(name, left, top, rgb, scale: 1)
+        tint(rgb)
+        place(top, GLYPH * scale)
+        glyph(ICON + ICON_NAMES.index(name), left)
+      end
+
+      private
+
+      def screen_code(char)
+        ascii = char.ord
+        ascii < 128 ? SCREEN_CODES[ascii] : 63
+      end
+
+      # Sets the row and size glyphs go at, which a run of text shares.
+      def place(top, size)
+        to = SDL.rect
+        SDL.rect_y(to, top)
+        return if size == @size
+
+        @size = size
+        SDL.rect_w(to, size)
+        SDL.rect_h(to, size)
+      end
+
+      def glyph(code, left)
+        from = SDL.glyph_rect
+        SDL.rect_x(from, (code % 16) * GLYPH)
+        SDL.rect_y(from, (code / 16) * GLYPH)
+        to = SDL.rect
+        SDL.rect_x(to, left)
+        SDL.SDL_RenderCopy(@renderer, @font, from, to)
+      end
+
+      def pen(rgb)
+        SDL.SDL_SetRenderDrawColor(@renderer, (rgb >> 16) & 0xff, (rgb >> 8) & 0xff, rgb & 0xff, 255)
+      end
+
+      def tint(rgb)
+        return if rgb == @tint
+
+        @tint = rgb
+        SDL.SDL_SetTextureColorMod(@font, (rgb >> 16) & 0xff, (rgb >> 8) & 0xff, rgb & 0xff)
+      end
+
+      # Two pixels to a word, the left one in the low half, as Screen packs
+      # them.
+      def load_font
+        rom = ROM.read("character.rom")
+        words = Array.new(ATLAS * ATLAS / 2, 0)
+        256.times { |code| unpack_glyph(rom[0x800 + (code * GLYPH), GLYPH], code, words) }
+        ICON_NAMES.each_with_index { |name, index| unpack_glyph(icon_rows(name), ICON + index, words) }
+        rect = SDL.glyph_rect
+        SDL.rect_x(rect, 0)
+        SDL.rect_y(rect, 0)
+        SDL.rect_w(rect, ATLAS)
+        SDL.rect_h(rect, ATLAS)
+        SDL.SDL_UpdateTexture(@font, rect, words, ATLAS * 4)
+      end
+
+      def icon_rows(name)
+        ICONS.fetch(name).map { |row| row.tr(".X", "01").to_i(2) }
+      end
+
+      def unpack_glyph(rows, code, words)
+        GLYPH.times do |row|
+          bits = rows[row]
+          y = ((code / 16) * GLYPH) + row
+          x = (code % 16) * GLYPH
+          4.times do |pair|
+            left = bits[7 - (pair * 2)] == 1 ? SET : 0
+            right = bits[6 - (pair * 2)] == 1 ? SET_HIGH : 0
+            words[(((y * ATLAS) + x) / 2) + pair] = left | right
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/frontend/pause_menu.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The emulator's pause menu, which F9 opens over the frozen picture.
+    # The machine stands still while it's open. Its sections follow the
+    # machine's hardware: the drive, the datasette, the expansion port, the
+    # control ports, the sound and the power. It's drawn in colours outside
+    # the C64's palette, so it reads as the emulator's and not the
+    # machine's, and F9 or Esc closes it again.
+    #
+    # INSERT on a page opens the file browser for that device. Quick open
+    # starts a file as the command line does, in a new machine, and it and
+    # a cartridge going in or out ask first, as each power cycles the
+    # machine.
+    class PauseMenu
+      SECTIONS = ["DRIVE 8", "DATASETTE", "EXPANSION PORT", "PORTS", "SOUND", "POWER"].freeze
+      PAGES = %i[drive datasette expansion ports sound power].freeze
+      DISKS = %w[.d64 .d71 .d81 .g64 .t64].freeze
+
+      PANEL = 0x1d2230
+      EDGE = 0x3a4256
+      TEXT = 0xc9d1e0
+      BRIGHT = 0xffc66d
+      DIM = 0x6b7489
+      FILL = 0x343c50
+
+      LEFT = 16
+      TOP = 16
+      WIDTH = Screen::WIDTH - 32
+      HEIGHT = Screen::HEIGHT - 32
+      BODY = 154
+
+      ESCAPE = 41
+      RETURN = 40
+      SPACE = 44
+      ARROWS = { 79 => :right, 80 => :left, 81 => :down, 82 => :up }.freeze
+      MOUSEWHEEL = 0x403
+
+      # Takes the media, the REU and whether disks are writable from Options.
+      def initialize(painter, options)
+        media_path = options.media_path.to_s
+        @painter = painter
+        @buttons = Buttons.new(painter, [TEXT, BRIGHT, PANEL, FILL])
+        @pages = MenuPages.new(painter, @buttons, PauseMenu.disk_path(media_path), options)
+        @dialogs = MenuDialogs.new(painter, @buttons, @pages.media, options)
+        @open = false
+        @section = 0
+      end
+
+      # The path of the disk the command line puts in device 8, or an empty
+      # one for other media.
+      def self.disk_path(path)
+        return "" if path.empty?
+        return path if File.directory?(path)
+
+        DISKS.include?(File.extname(path).downcase) ? path : ""
+      end
+
+      def open? = @open
+
+      # The machine Quick open started, which the app runs in place of the
+      # one before once #frame returns :swap.
+      def computer = @dialogs.computer
+
+      def show(computer, controls, sound)
+        @open = true
+        @buttons.focus = PAGES[@section]
+        @pages.machine(computer, controls, sound)
+        SDL.SDL_SetRelativeMouseMode(0)
+        draw
+      end
+
+      def close
+        @open = false
+      end
+
+      # Opens on the file the SDL event says was dropped on the window,
+      # and says whether the menu stays open to ask about it: a disk or tape
+      # goes straight in, and anything else asks first.
+      def drop(computer, controls, sound)
+        show(computer, controls, sound)
+        file = SDL.event_file(SDL.event)
+        asks = @dialogs.drop(LibC.strstr(file, ""))
+        LibC.free(file)
+        asks
+      end
+
+      # Handles a key pressed while the menu is open: the arrows move
+      # between the buttons, and a section opens as they reach it, Return
+      # or Space presses the button, and F9 or Esc closes the menu. While
+      # the file browser or a question is open, the keys go to it, and Esc
+      # goes back to the page. Returns the action the app has to take on,
+      # as #click does.
+      def key(scancode)
+        return :resume if scancode == Keys::F9
+        return @dialogs.key(scancode) if @dialogs.open?
+        return :resume if scancode == ESCAPE
+        return choose(@buttons.focus) if [RETURN, SPACE].include?(scancode)
+
+        direction = ARROWS[scancode]
+        move(direction) unless direction.nil?
+        nil
+      end
+
+      # Handles a click, and returns the action the app has to take on, if
+      # any: :resume, :quit, :freeze or :swap.
+      def click(left, top)
+        action = @buttons.action_at(left, top)
+        return @dialogs.click(action, top) if %i[browse confirm cancel].include?(action)
+
+        choose(action)
+      end
+
+      # Handles the events that came in, draws the menu over the frozen
+      # picture, dimmed, and returns the action the app has to take on, if
+      # any, leaving the events after one for the machine. Key releases
+      # still reach the machine, so no key stays held down while it stands
+      # still.
+      def frame(renderer, texture, controls)
+        action = nil
+        action = event(SDL.event_type(SDL.event), controls) while action.nil? && SDL.SDL_PollEvent(SDL.event) != 0
+        SDL.SDL_SetTextureColorMod(texture, 96, 96, 96)
+        SDL.SDL_RenderClear(renderer)
+        SDL.SDL_RenderCopy(renderer, texture, nil, nil)
+        SDL.SDL_SetTextureColorMod(texture, 255, 255, 255)
+        draw
+        SDL.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255)
+        SDL.SDL_RenderPresent(renderer)
+        SDL.SDL_Delay(10)
+        action
+      end
+
+      def draw
+        painter = @painter
+        @buttons.forget
+        painter.box(LEFT, TOP, WIDTH, HEIGHT, PANEL)
+        painter.box(LEFT, TOP + 24, WIDTH, 1, EDGE)
+        painter.text(LEFT + 8, TOP + 9, "PAUSED", BRIGHT)
+        resume = "RESUME"
+        @buttons.plain(LEFT + WIDTH - 8 - Painter.width(resume) - (Buttons::PAD * 2), TOP + 7, resume, :resume)
+        return @dialogs.draw(LEFT + 8, TOP + 34, WIDTH - 16) if @dialogs.open?
+
+        painter.box(BODY - 8, TOP + 32, 1, HEIGHT - 56, EDGE)
+        draw_sections
+        @buttons.plain(LEFT + 6, TOP + HEIGHT - 28, "QUICK OPEN...", :quick_open)
+        painter.text(LEFT + 8, TOP + HEIGHT - 12, "F9/ESC: RESUME", DIM)
+        @pages.draw(PAGES[@section], BODY, TOP + 34)
+      end
+
+      private
+
+      def choose(pressed)
+        return nil if pressed.nil?
+
+        action = @buttons.resolve(pressed)
+        index = PAGES.index(action)
+        unless index.nil?
+          @section = index
+          return nil
+        end
+        return action if %i[resume quit freeze].include?(action)
+
+        menu_action(action)
+      end
+
+      def menu_action(action)
+        case action
+        when :insert_disk then @dialogs.browse(:disk)
+        when :insert_tape then @dialogs.browse(:tape)
+        when :insert_cartridge then @dialogs.browse(:cartridge)
+        when :quick_open then @dialogs.browse(:program)
+        when :remove_cartridge then @dialogs.ask_remove
+        else @pages.perform(action)
+        end
+        nil
+      end
+
+      # Moves the focus: down from RESUME to the sections, through them,
+      # where each opens as it's reached, on to Quick open, right into a
+      # page, up and down it, and left out of it again.
+      def move(direction)
+        focus = @buttons.focus
+        section = focus == :quick_open ? PAGES.size : PAGES.index(focus)
+        if focus == :resume
+          @buttons.focus = PAGES[@section] if %i[down left].include?(direction)
+        elsif section.nil?
+          move_in_page(direction)
+        else
+          move_in_sections(section, direction)
+        end
+      end
+
+      # Up and down go through the page's rows, and left goes back to its
+      # section.
+      def move_in_page(direction)
+        case direction
+        when :up, :down then @buttons.shift(direction == :up ? -1 : 1, PAGES.size + 2)
+        when :left then @buttons.focus = PAGES[@section]
+        end
+      end
+
+      def move_in_sections(section, direction)
+        case direction
+        when :up then section.zero? ? @buttons.focus = :resume : open_section(section - 1)
+        when :down then section < PAGES.size - 1 ? open_section(section + 1) : @buttons.focus = :quick_open
+        when :right then @buttons.focus = @buttons.action(PAGES.size + 2) || @buttons.focus if section < PAGES.size
+        end
+      end
+
+      # Opens a section, laid out at once, so keys that come before the next
+      # frame find its rows.
+      def open_section(index)
+        @section = index
+        @buttons.focus = PAGES[index]
+        draw
+      end
+
+      def event(type, controls)
+        event = SDL.event
+        case type
+        when SDL::QUIT then :quit
+        when SDL::KEYDOWN then key_down(SDL.event_scancode(event), SDL.event_repeat(event))
+        when SDL::KEYUP then controls.key(SDL.event_scancode(event), false) && nil
+        when SDL::MOUSEMOTION then @buttons.point(SDL.event_x(event), SDL.event_y(event)) && nil
+        when SDL::MOUSEBUTTONDOWN
+          SDL.event_button(event) == 1 ? click(SDL.event_x(event), SDL.event_y(event)) : nil
+        when MOUSEWHEEL then @dialogs.scroll(-3 * SDL.event_x(event)) && nil
+        end
+      end
+
+      # A key held down repeats only the arrows.
+      def key_down(scancode, repeat)
+        repeat.zero? || ARROWS.key?(scancode) ? key(scancode) : nil
+      end
+
+      def draw_sections
+        top = TOP + 32
+        SECTIONS.each_with_index do |name, index|
+          @buttons.plain(LEFT + 6, top, name.ljust(14), PAGES[index], on: index == @section)
+          top += Buttons::HEIGHT + 2
+        end
+      end
+    end
+  end
+end

data/lib/badline/frontend/player_commands.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # What the SID player's window does with an action a key or a click asks
+    # for: one that picks or steps through the views or the SID models, or
+    # picks the SID shown, changes the PlayerState, and any other goes on to
+    # the jukebox.
+    class PlayerCommands
+      VIEWS = PlayerHeader::VIEWS
+      CHIPS = PlayerHeader::CHIPS
+      SIDS = SIDView::SIDS
+
+      def initialize(state)
+        @state = state
+      end
+
+      # Returns the action for the jukebox, or nil when the window has
+      # handled it.
+      def handle(action)
+        state = @state
+        if action == :view then state.view = (state.view + 1) % VIEWS.size
+        elsif action == :chip then state.chip = (state.chip + 1) % CHIPS.size
+        elsif VIEWS.include?(action) then state.view = VIEWS.index(action)
+        elsif CHIPS.include?(action) then state.chip = CHIPS.index(action)
+        elsif SIDS.include?(action) then state.sid = SIDS.index(action)
+        else return action
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/badline/frontend/player_footer.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The bottom of the SID player's window: how far the subtune has played,
+    # on a bar a click seeks along, marked with where a seek is headed, and the buttons that pause and step
+    # through the queue's tunes and the tune's subtunes and turn the queue's
+    # modes on and off.
+    class PlayerFooter
+      HEIGHT = 44
+      WIDTH = PlayerHeader::WIDTH
+      CLOCK = "00:00 / 00:00"
+      BAR_LEFT = 16
+      BAR_WIDTH = WIDTH - 32 - (CLOCK.length * Painter::GLYPH) - 8
+      TOGGLES = ["SHUFFLE", "LOOP", "ALL SUBTUNES"].freeze
+      TOGGLE_ACTIONS = %i[shuffle loop all_subtunes].freeze
+      TOGGLE_NOTES = ["shuffle", "loop", "all subtunes"].freeze
+
+      def initialize(painter, buttons)
+        @painter = painter
+        @buttons = buttons
+      end
+
+      def draw(state, top)
+        draw_progress(state, top + 4)
+        row = top + 18
+        x = 12
+        x += @buttons.icon(x, row, :previous, :previous, scale: 2) + 4
+        x += @buttons.icon(x, row, state.paused? ? :play : :pause, :pause, scale: 2) + 4
+        x += @buttons.icon(x, row, :next, :next, scale: 2) + 8
+        unless state.tunes.zero?
+          x += @painter.text(x, row + 6, "TUNE #{state.tune}/#{state.tunes}", SIDView::BRIGHT) + 24
+          draw_subtunes(state, x, row + 4)
+        end
+        draw_toggles(state, row + 4)
+      end
+
+      # The seconds into the subtune a click `left` along the bar asks for.
+      def self.seek(left, length) = ((left - BAR_LEFT).to_f / BAR_WIDTH).clamp(0.0, 1.0) * length
+
+      private
+
+      def draw_subtunes(state, left, row)
+        x = left + @painter.text(left, row + 2, "SUBTUNE", SIDView::TEXT) + 4
+        x += @buttons.icon(x, row, :left, :previous_subtune)
+        x += @painter.text(x + 2, row + 2, "#{state.subtune}/#{state.subtunes}", SIDView::BRIGHT) + 4
+        @buttons.icon(x, row, :right, :next_subtune)
+      end
+
+      def draw_progress(state, top)
+        played = state.played
+        width = BAR_WIDTH
+        @buttons.area([BAR_LEFT, top - 2, width, 12], :seek)
+        @painter.box(BAR_LEFT, top + 2, width, 4, SIDView::BOX)
+        draw_target(state, top) if state.seeking?
+        @painter.box(BAR_LEFT, top + 2, along(state, played), 4, SIDView::BRIGHT)
+        @painter.text(WIDTH - 16 - Painter.width(CLOCK), top, "#{clock(played)} / #{clock(state.length)}",
+                      SIDView::TEXT)
+      end
+
+      def draw_target(state, top)
+        target = along(state, state.target)
+        @painter.box(BAR_LEFT, top + 2, target, 4, SIDView::DIM)
+        @painter.box(BAR_LEFT + [target, BAR_WIDTH - 1].min, top - 1, 1, 10, SIDView::BRIGHT)
+      end
+
+      # How far along the bar `seconds` into the subtune is.
+      def along(state, seconds)
+        length = state.length
+        length.positive? ? (BAR_WIDTH * seconds / length).round.clamp(0, BAR_WIDTH) : 0
+      end
+
+      def draw_toggles(state, row)
+        x = PlayerHeader.right_aligned(TOGGLES)
+        TOGGLES.each_with_index do |label, toggle|
+          x += @buttons.text(x, row, label, TOGGLE_ACTIONS[toggle], on: state.on?(TOGGLE_NOTES[toggle])) + 4
+        end
+      end
+
+      def clock(seconds)
+        whole = seconds.floor
+        format("%<minutes>d:%<seconds>02d", minutes: whole / 60, seconds: whole % 60)
+      end
+    end
+  end
+end

data/lib/badline/frontend/player_header.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The top of the SID player's window: the tune's name, author and
+    # release, the STIL credit for what the subtune covers at the moment, a
+    # warning when there is one, and the buttons for the views and the SID
+    # model.
+    class PlayerHeader
+      WIDTH = 640
+      VIEW_NAMES = %w[VISUALIZER SID INFO].freeze
+      VIEWS = %i[visualizer sid info].freeze
+      CHIP_NAMES = %w[AUTO 6581 8580].freeze
+      CHIPS = %i[auto mos6581 mos8580].freeze
+
+      def initialize(painter, buttons)
+        @painter = painter
+        @buttons = buttons
+      end
+
+      # Underlines the models playing while AUTO picks them.
+      def draw(state, tune, playing_models, credit)
+        unless tune.nil?
+          @painter.text(16, 8, fit(tune.name, 26), SIDView::BRIGHT, scale: 2)
+          @painter.text(16, 28, fit([tune.author, tune.released].reject(&:empty?).join(" - "), 50), SIDView::TEXT)
+          @painter.text(16, 40, fit(credit, 76), SIDView::BRIGHT)
+          @painter.text(16, 52, warning(state), PlayerWindow::WARNING)
+        end
+        draw_views(state)
+        draw_chips(state, playing_models)
+      end
+
+      def self.right_aligned(labels) = WIDTH - 12 - labels.sum { |label| Painter.width(label) + 8 }
+
+      private
+
+      def warning(state) = state.on?("below real time") ? "Running below real time" : ""
+
+      def draw_views(state)
+        x = PlayerHeader.right_aligned(VIEW_NAMES)
+        VIEW_NAMES.each_with_index do |name, view|
+          x += @buttons.text(x, 6, name, VIEWS[view], on: view == state.view) + 4
+        end
+      end
+
+      def draw_chips(state, playing_models)
+        x = PlayerHeader.right_aligned(CHIP_NAMES)
+        CHIP_NAMES.each_with_index do |name, chip|
+          width = @buttons.text(x, 24, name, CHIPS[chip], on: chip == state.chip)
+          if state.chip.zero? && playing_models.include?(CHIPS[chip])
+            @painter.box(x + 2, 37, width - 4, 1, SIDView::BRIGHT)
+          end
+          x += width + 4
+        end
+      end
+
+      def fit(text, chars) = text.length > chars ? "#{text[0, chars - 2]}.." : text
+    end
+  end
+end