319 lines
8.8 KiB
Ruby
319 lines
8.8 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require_relative 'widget'
|
|
require_relative 'window'
|
|
|
|
module BBS
|
|
# Menubar — a horizontal strip at the top of the screen with named
|
|
# menus. Each menu has a label like "&File" (Alt-F opens it) and a list of
|
|
# MenuItem objects.
|
|
class Menubar < Widget
|
|
Menu = Struct.new(:label, :items, :x, keyword_init: true) do
|
|
def hotkey
|
|
idx = label.index('&')
|
|
idx && idx + 1 < label.length ? label[idx + 1].downcase : nil
|
|
end
|
|
|
|
def display = label.sub('&', '')
|
|
end
|
|
|
|
MenuItem = Struct.new(:label, :shortcut, :enabled, :on_select, :separator,
|
|
keyword_init: true) do
|
|
def hotkey
|
|
return nil if separator
|
|
idx = label.index('&')
|
|
idx && idx + 1 < label.length ? label[idx + 1].downcase : nil
|
|
end
|
|
|
|
def display = separator ? '─' : label.sub('&', '')
|
|
end
|
|
|
|
attr_reader :menus
|
|
attr_accessor :on_activate
|
|
|
|
def initialize(**kw)
|
|
super
|
|
@menus = []
|
|
@open_index = nil
|
|
@item_index = 0
|
|
@on_activate = nil
|
|
end
|
|
|
|
def add_menu(label, &block)
|
|
builder = MenuBuilder.new
|
|
builder.instance_eval(&block) if block
|
|
@menus << Menu.new(label: label, items: builder.items, x: nil)
|
|
self
|
|
end
|
|
|
|
def open? = !@open_index.nil?
|
|
def opened_menu = @open_index ? @menus[@open_index] : nil
|
|
def open_index = @open_index
|
|
def selected_item = opened_menu&.items&.[](@item_index)
|
|
|
|
def open(index)
|
|
idx = index.clamp(0, @menus.size - 1)
|
|
@open_index = idx
|
|
@item_index = first_selectable_index(@menus[idx].items) || 0
|
|
end
|
|
|
|
def close
|
|
@open_index = nil
|
|
@item_index = 0
|
|
end
|
|
|
|
def focusable? = false
|
|
|
|
def render(frame)
|
|
sgr = style(:menubar)
|
|
sel = style(:menubar_selected)
|
|
hotkey = style(:menubar_hotkey)
|
|
sel_hot = style(:menubar_sel_hot)
|
|
|
|
frame.move(bounds.x, bounds.y)
|
|
frame.write(' ' * bounds.width, sgr: sgr)
|
|
|
|
cx = bounds.x + 1
|
|
@menus.each_with_index do |menu, i|
|
|
menu.x = cx
|
|
is_open = (@open_index == i)
|
|
slabel = is_open ? sel : sgr
|
|
shotkey = is_open ? sel_hot : hotkey
|
|
frame.move(cx, bounds.y)
|
|
frame.write(' ', sgr: slabel)
|
|
render_hotkey_label(frame, menu.label, cx + 1, bounds.y, slabel, shotkey)
|
|
frame.move(cx + 1 + menu.display.length, bounds.y)
|
|
frame.write(' ', sgr: slabel)
|
|
cx += menu.display.length + 3
|
|
end
|
|
|
|
render_dropdown(frame) if open?
|
|
end
|
|
|
|
def handle_event(event)
|
|
return navigate(event) if open?
|
|
return open_via_keyboard(event) if event.key?
|
|
if event.mouse? && event.mouse.kind == :press && event.mouse.button == :left
|
|
return handle_mouse_press(event)
|
|
end
|
|
nil
|
|
end
|
|
|
|
def navigate(event)
|
|
if event.mouse?
|
|
if event.mouse.kind == :press && event.mouse.button == :left
|
|
return handle_mouse_press(event)
|
|
end
|
|
return :handled
|
|
end
|
|
|
|
menu = opened_menu
|
|
return nil unless menu
|
|
case event.key
|
|
when :left
|
|
@open_index = (@open_index - 1) % @menus.size
|
|
@item_index = first_selectable_index(opened_menu.items) || 0
|
|
when :right
|
|
@open_index = (@open_index + 1) % @menus.size
|
|
@item_index = first_selectable_index(opened_menu.items) || 0
|
|
when :up
|
|
@item_index = prev_selectable_index(menu.items, @item_index)
|
|
when :down
|
|
@item_index = next_selectable_index(menu.items, @item_index)
|
|
when :escape, :f10
|
|
close
|
|
when :enter
|
|
return activate_current
|
|
else
|
|
if event.char?
|
|
activated = activate_by_hotkey(menu.items, event.key)
|
|
return activated if activated
|
|
end
|
|
end
|
|
:handled
|
|
end
|
|
|
|
def open_via_keyboard(event)
|
|
if event.key == :f10
|
|
open(0)
|
|
return :handled
|
|
end
|
|
if event.alt? && event.alt_char
|
|
idx = @menus.find_index { |m| m.hotkey == event.alt_char.downcase }
|
|
if idx
|
|
open(idx)
|
|
return :handled
|
|
end
|
|
end
|
|
nil
|
|
end
|
|
|
|
private
|
|
|
|
def handle_mouse_press(event)
|
|
if event.y == bounds.y
|
|
# menubar click
|
|
idx = @menus.find_index do |m|
|
|
m.x && event.x >= m.x && event.x < m.x + m.display.length + 2
|
|
end
|
|
if idx
|
|
@open_index == idx ? close : open(idx)
|
|
return :handled
|
|
end
|
|
close
|
|
return :handled
|
|
end
|
|
|
|
if open?
|
|
menu = opened_menu
|
|
x0 = menu.x
|
|
y0 = bounds.y + 1
|
|
w = menu_width(menu)
|
|
h = menu.items.size + 2
|
|
if event.x >= x0 && event.x < x0 + w && event.y >= y0 && event.y < y0 + h
|
|
inner_y = event.y - y0 - 1
|
|
if inner_y >= 0 && inner_y < menu.items.size
|
|
item = menu.items[inner_y]
|
|
unless item.separator || item.enabled == false
|
|
@item_index = inner_y
|
|
return activate_current
|
|
end
|
|
end
|
|
return :handled
|
|
end
|
|
close
|
|
return :handled
|
|
end
|
|
nil
|
|
end
|
|
|
|
def activate_current
|
|
item = selected_item
|
|
return :handled unless item && !item.separator && item.enabled != false
|
|
close
|
|
result = item.on_select&.call(item)
|
|
@on_activate&.call(item)
|
|
result == :halt ? :halt : :handled
|
|
end
|
|
|
|
def activate_by_hotkey(items, ch)
|
|
down = ch.downcase
|
|
idx = items.find_index { |i| !i.separator && i.enabled != false && i.hotkey == down }
|
|
return nil unless idx
|
|
@item_index = idx
|
|
activate_current
|
|
end
|
|
|
|
def first_selectable_index(items)
|
|
items.find_index { |i| !i.separator && i.enabled != false }
|
|
end
|
|
|
|
def next_selectable_index(items, from)
|
|
n = items.size
|
|
i = from
|
|
n.times do
|
|
i = (i + 1) % n
|
|
return i if !items[i].separator && items[i].enabled != false
|
|
end
|
|
from
|
|
end
|
|
|
|
def prev_selectable_index(items, from)
|
|
n = items.size
|
|
i = from
|
|
n.times do
|
|
i = (i - 1) % n
|
|
return i if !items[i].separator && items[i].enabled != false
|
|
end
|
|
from
|
|
end
|
|
|
|
def menu_width(menu)
|
|
max_label = menu.items.reject(&:separator).map { |i| i.display.length }.max || 0
|
|
max_short = menu.items.reject(&:separator).map { |i| i.shortcut.to_s.length }.max || 0
|
|
max_label + max_short + 6
|
|
end
|
|
|
|
def render_dropdown(frame)
|
|
menu = opened_menu
|
|
return unless menu
|
|
x = menu.x
|
|
y = bounds.y + 1
|
|
w = menu_width(menu)
|
|
h = menu.items.size + 2
|
|
frame.shadow(x: x, y: y, width: w, height: h, sgr: style(:window_shadow))
|
|
frame.box(x: x, y: y, width: w, height: h,
|
|
sgr: style(:menu_border), fill_sgr: style(:menu_bg))
|
|
|
|
menu.items.each_with_index do |item, idx|
|
|
row_y = y + 1 + idx
|
|
if item.separator
|
|
frame.hline(x: x + 1, y: row_y, length: w - 2, char: '─', sgr: style(:menu_border))
|
|
next
|
|
end
|
|
selected = (idx == @item_index)
|
|
sgr = if !item.enabled.nil? && item.enabled == false
|
|
style(:menu_disabled)
|
|
elsif selected
|
|
style(:menu_selected)
|
|
else
|
|
style(:menu_text)
|
|
end
|
|
frame.move(x + 1, row_y)
|
|
frame.write(' ' * (w - 2), sgr: sgr)
|
|
|
|
# label with hotkey highlight
|
|
frame.move(x + 2, row_y)
|
|
label = item.label
|
|
idx_amp = label.index('&')
|
|
if idx_amp && item.enabled != false
|
|
frame.write(label[0, idx_amp], sgr: sgr)
|
|
frame.write(label[idx_amp + 1], sgr: selected ? sgr : style(:menu_hotkey))
|
|
rest = label[(idx_amp + 2)..]
|
|
frame.write(rest, sgr: sgr) if rest
|
|
else
|
|
frame.write(item.display, sgr: sgr)
|
|
end
|
|
|
|
if item.shortcut
|
|
short = item.shortcut.to_s
|
|
frame.move(x + w - 1 - short.length, row_y)
|
|
frame.write(short, sgr: sgr)
|
|
end
|
|
end
|
|
end
|
|
|
|
def render_hotkey_label(frame, label, x, y, sgr, hotkey_sgr)
|
|
idx = label.index('&')
|
|
if idx
|
|
frame.move(x, y)
|
|
frame.write(label[0, idx], sgr: sgr) if idx > 0
|
|
frame.write(label[idx + 1], sgr: hotkey_sgr)
|
|
rest = label[(idx + 2)..]
|
|
frame.write(rest, sgr: sgr) if rest && !rest.empty?
|
|
else
|
|
frame.move(x, y)
|
|
frame.write(label, sgr: sgr)
|
|
end
|
|
end
|
|
|
|
class MenuBuilder
|
|
attr_reader :items
|
|
|
|
def initialize
|
|
@items = []
|
|
end
|
|
|
|
def item(label, shortcut: nil, enabled: true, &block)
|
|
@items << MenuItem.new(label: label, shortcut: shortcut,
|
|
enabled: enabled, on_select: block, separator: false)
|
|
end
|
|
|
|
def separator
|
|
@items << MenuItem.new(label: '', shortcut: nil, enabled: false,
|
|
on_select: nil, separator: true)
|
|
end
|
|
end
|
|
end
|
|
end
|