mirror of https://github.com/kepler155c/opus
474 lines
9.1 KiB
Lua
474 lines
9.1 KiB
Lua
local Canvas = require('opus.ui.canvas')
|
|
|
|
local colors = _G.colors
|
|
local term = _G.term
|
|
local _gsub = string.gsub
|
|
|
|
local Terminal = { }
|
|
|
|
local mapColorToGray = {
|
|
[ colors.white ] = colors.white,
|
|
[ colors.orange ] = colors.lightGray,
|
|
[ colors.magenta ] = colors.lightGray,
|
|
[ colors.lightBlue ] = colors.lightGray,
|
|
[ colors.yellow ] = colors.lightGray,
|
|
[ colors.lime ] = colors.lightGray,
|
|
[ colors.pink ] = colors.lightGray,
|
|
[ colors.gray ] = colors.gray,
|
|
[ colors.lightGray ] = colors.lightGray,
|
|
[ colors.cyan ] = colors.lightGray,
|
|
[ colors.purple ] = colors.gray,
|
|
[ colors.blue ] = colors.gray,
|
|
[ colors.brown ] = colors.gray,
|
|
[ colors.green ] = colors.lightGray,
|
|
[ colors.red ] = colors.gray,
|
|
[ colors.black ] = colors.black,
|
|
}
|
|
|
|
-- Replacement for window api with scrolling and buffering
|
|
function Terminal.window(parent, sx, sy, w, h, isVisible)
|
|
isVisible = isVisible ~= false
|
|
if not w or not h then
|
|
w, h = parent.getSize()
|
|
end
|
|
|
|
local win = { }
|
|
local maxScroll
|
|
local cx, cy = 1, 1
|
|
local blink = false
|
|
local _bg, _fg = colors.black, colors.white
|
|
|
|
win.canvas = Canvas({
|
|
x = sx,
|
|
y = sy,
|
|
width = w,
|
|
height = h,
|
|
isColor = parent.isColor(),
|
|
offy = 0,
|
|
bg = _bg,
|
|
fg = _fg,
|
|
})
|
|
|
|
local function update()
|
|
if isVisible then
|
|
win.canvas:render(parent)
|
|
win.setCursorPos(cx, cy)
|
|
end
|
|
end
|
|
|
|
local function scrollTo(y)
|
|
y = math.max(0, y)
|
|
y = math.min(#win.canvas.lines - win.canvas.height, y)
|
|
|
|
if y ~= win.canvas.offy then
|
|
win.canvas.offy = y
|
|
win.canvas:dirty()
|
|
update()
|
|
end
|
|
end
|
|
|
|
function win.write(str)
|
|
str = tostring(str) or ''
|
|
win.canvas:write(cx, cy + win.canvas.offy, str, win.canvas.bg, win.canvas.fg)
|
|
win.setCursorPos(cx + #str, cy)
|
|
update()
|
|
end
|
|
|
|
function win.blit(str, fg, bg)
|
|
win.canvas:blit(cx, cy + win.canvas.offy, str, bg, fg)
|
|
win.setCursorPos(cx + #str, cy)
|
|
update()
|
|
end
|
|
|
|
function win.clear()
|
|
win.canvas.offy = 0
|
|
for i = #win.canvas.lines, win.canvas.height + 1, -1 do
|
|
win.canvas.lines[i] = nil
|
|
end
|
|
win.canvas:clear()
|
|
update()
|
|
end
|
|
|
|
function win.getLine(n)
|
|
local line = win.canvas.lines[n]
|
|
return line.text, line.fg, line.bg
|
|
end
|
|
|
|
function win.clearLine()
|
|
win.canvas:clearLine(cy + win.canvas.offy)
|
|
win.setCursorPos(cx, cy)
|
|
update()
|
|
end
|
|
|
|
function win.getCursorPos()
|
|
return cx, cy
|
|
end
|
|
|
|
function win.setCursorPos(x, y)
|
|
cx, cy = math.floor(x), math.floor(y)
|
|
if isVisible then
|
|
parent.setCursorPos(cx + win.canvas.x - 1, cy + win.canvas.y - 1)
|
|
end
|
|
end
|
|
|
|
function win.getCursorBlink()
|
|
return blink
|
|
end
|
|
|
|
function win.setCursorBlink(b)
|
|
blink = b
|
|
if isVisible then
|
|
parent.setCursorBlink(b)
|
|
end
|
|
end
|
|
|
|
function win.isColor()
|
|
return win.canvas.isColor
|
|
end
|
|
win.isColour = win.isColor
|
|
|
|
function win.setTextColor(c)
|
|
win.canvas.fg = c
|
|
end
|
|
win.setTextColour = win.setTextColor
|
|
|
|
function win.getPaletteColor(n)
|
|
if parent.getPaletteColor then
|
|
return parent.getPaletteColor(n)
|
|
end
|
|
return 0, 0, 0
|
|
end
|
|
win.getPaletteColour = win.getPaletteColor
|
|
|
|
function win.setPaletteColor(n, r, g, b)
|
|
if parent.setPaletteColor then
|
|
return parent.setPaletteColor(n, r, g, b)
|
|
end
|
|
end
|
|
win.setPaletteColour = win.setPaletteColor
|
|
|
|
function win.setBackgroundColor(c)
|
|
win.canvas.bg = c
|
|
end
|
|
win.setBackgroundColour = win.setBackgroundColor
|
|
|
|
function win.getSize()
|
|
return win.canvas.width, win.canvas.height
|
|
end
|
|
|
|
function win.scroll(n)
|
|
n = n or 1
|
|
if n > 0 then
|
|
local lines = #win.canvas.lines
|
|
for i = 1, n do
|
|
win.canvas.lines[lines + i] = { }
|
|
win.canvas:clearLine(lines + i)
|
|
end
|
|
while #win.canvas.lines > (maxScroll or win.canvas.height) do
|
|
table.remove(win.canvas.lines, 1)
|
|
end
|
|
scrollTo(#win.canvas.lines)
|
|
win.canvas:dirty()
|
|
update()
|
|
end
|
|
end
|
|
|
|
function win.getTextColor()
|
|
return win.canvas.fg
|
|
end
|
|
win.getTextColour = win.getTextColor
|
|
|
|
function win.getBackgroundColor()
|
|
return win.canvas.bg
|
|
end
|
|
win.getBackgroundColour = win.getBackgroundColor
|
|
|
|
function win.setVisible(visible)
|
|
if visible ~= isVisible then
|
|
isVisible = visible
|
|
if isVisible then
|
|
win.canvas:dirty()
|
|
update()
|
|
end
|
|
end
|
|
end
|
|
|
|
function win.redraw()
|
|
if isVisible then
|
|
win.canvas:dirty()
|
|
update()
|
|
end
|
|
end
|
|
|
|
function win.restoreCursor()
|
|
if isVisible then
|
|
win.setCursorPos(cx, cy)
|
|
win.setTextColor(win.canvas.fg)
|
|
win.setCursorBlink(blink)
|
|
end
|
|
end
|
|
|
|
function win.getPosition()
|
|
return win.canvas.x, win.canvas.y
|
|
end
|
|
|
|
function win.reposition(x, y, width, height)
|
|
if not maxScroll then
|
|
win.canvas:move(x, y)
|
|
win.canvas:resize(width or win.canvas.width, height or win.canvas.height)
|
|
return
|
|
end
|
|
|
|
-- special processing for scrolling terminal like windows
|
|
local delta = height - win.canvas.height
|
|
|
|
if delta > 0 then -- grow
|
|
for _ = 1, delta do
|
|
win.canvas.lines[#win.canvas.lines + 1] = { }
|
|
win.canvas:clearLine(#win.canvas.lines)
|
|
end
|
|
|
|
elseif delta < 0 then -- shrink
|
|
for _ = delta + 1, 0 do
|
|
if cy < win.canvas.height then
|
|
win.canvas.lines[#win.canvas.lines] = nil
|
|
else
|
|
cy = cy - 1
|
|
win.canvas.offy = win.canvas.offy + 1
|
|
end
|
|
end
|
|
end
|
|
|
|
win.canvas:resizeBuffer(width, #win.canvas.lines)
|
|
|
|
win.canvas.height = height
|
|
win.canvas.width = width
|
|
win.canvas:move(x, y)
|
|
|
|
update()
|
|
end
|
|
|
|
--[[ Additional methods ]]--
|
|
function win.scrollDown()
|
|
scrollTo(win.canvas.offy + 1)
|
|
end
|
|
|
|
function win.scrollUp()
|
|
scrollTo(win.canvas.offy - 1)
|
|
end
|
|
|
|
function win.scrollTop()
|
|
scrollTo(0)
|
|
end
|
|
|
|
function win.scrollBottom()
|
|
scrollTo(#win.canvas.lines)
|
|
end
|
|
|
|
function win.setMaxScroll(ms)
|
|
maxScroll = ms
|
|
end
|
|
|
|
function win.getCanvas()
|
|
return win.canvas
|
|
end
|
|
|
|
function win.getParent()
|
|
return parent
|
|
end
|
|
|
|
function win.writeX(sText)
|
|
-- expect(1, sText, "string", "number")
|
|
local nLinesPrinted = 0
|
|
local function newLine()
|
|
if cy + 1 <= win.canvas.height then
|
|
cx, cy = 1, cy + 1
|
|
else
|
|
cx, cy = 1, win.canvas.height
|
|
win.scroll(1)
|
|
end
|
|
nLinesPrinted = nLinesPrinted + 1
|
|
end
|
|
|
|
-- Print the line with proper word wrapping
|
|
sText = tostring(sText)
|
|
while #sText > 0 do
|
|
local whitespace = string.match(sText, "^[ \t]+")
|
|
if whitespace then
|
|
-- Print whitespace
|
|
win.write(whitespace)
|
|
sText = string.sub(sText, #whitespace + 1)
|
|
end
|
|
|
|
local newline = string.match(sText, "^\n")
|
|
if newline then
|
|
-- Print newlines
|
|
newLine()
|
|
sText = string.sub(sText, 2)
|
|
end
|
|
|
|
local text = string.match(sText, "^[^ \t\n]+")
|
|
if text then
|
|
sText = string.sub(sText, #text + 1)
|
|
if #text > win.canvas.width then
|
|
-- Print a multiline word
|
|
while #text > 0 do
|
|
if cx > win.canvas.width then
|
|
newLine()
|
|
end
|
|
win.write(text)
|
|
text = string.sub(text, win.canvas.width - cx + 2)
|
|
end
|
|
else
|
|
-- Print a word normally
|
|
if cx + #text - 1 > win.canvas.width then
|
|
newLine()
|
|
end
|
|
win.write(text)
|
|
end
|
|
end
|
|
end
|
|
|
|
return nLinesPrinted
|
|
end
|
|
|
|
function win.print(...)
|
|
local vis = isVisible
|
|
isVisible = false
|
|
local nLinesPrinted = 0
|
|
local nLimit = select("#", ...)
|
|
for n = 1, nLimit do
|
|
local s = tostring(select(n, ...))
|
|
if n < nLimit then
|
|
s = s .. "\t"
|
|
end
|
|
nLinesPrinted = nLinesPrinted + win.writeX(s)
|
|
end
|
|
nLinesPrinted = nLinesPrinted + win.writeX("\n")
|
|
isVisible = vis
|
|
update()
|
|
return nLinesPrinted
|
|
end
|
|
|
|
win.canvas:clear()
|
|
|
|
return win
|
|
end
|
|
|
|
-- get windows contents
|
|
function Terminal.getContents(win)
|
|
if not win.getLine then
|
|
error('window is required')
|
|
end
|
|
|
|
local lines = { }
|
|
local _, h = win.getSize()
|
|
|
|
for i = 1, h do
|
|
local text, fg, bg = win.getLine(i)
|
|
lines[i] = {
|
|
text = text,
|
|
fg = fg,
|
|
bg = bg,
|
|
}
|
|
end
|
|
|
|
return lines
|
|
end
|
|
|
|
function Terminal.colorToGrayscale(c)
|
|
return mapColorToGray[c]
|
|
end
|
|
|
|
function Terminal.toGrayscale(ct)
|
|
local methods = { 'setBackgroundColor', 'setBackgroundColour',
|
|
'setTextColor', 'setTextColour' }
|
|
for _,v in pairs(methods) do
|
|
local fn = ct[v]
|
|
ct[v] = function(c)
|
|
fn(mapColorToGray[c])
|
|
end
|
|
end
|
|
|
|
local bcolors = {
|
|
[ '1' ] = '8',
|
|
[ '2' ] = '8',
|
|
[ '3' ] = '8',
|
|
[ '4' ] = '8',
|
|
[ '5' ] = '8',
|
|
[ '6' ] = '8',
|
|
[ '9' ] = '8',
|
|
[ 'a' ] = '7',
|
|
[ 'b' ] = '7',
|
|
[ 'c' ] = '7',
|
|
[ 'd' ] = '8',
|
|
[ 'e' ] = '7',
|
|
}
|
|
|
|
local function translate(s)
|
|
if s then
|
|
s = _gsub(s, "%w", bcolors)
|
|
end
|
|
return s
|
|
end
|
|
|
|
local fn = ct.blit
|
|
ct.blit = function(text, fg, bg)
|
|
fn(text, translate(fg), translate(bg))
|
|
end
|
|
end
|
|
|
|
function Terminal.getNullTerm(ct)
|
|
local nt = Terminal.copy(ct)
|
|
|
|
local methods = { 'blit', 'clear', 'clearLine', 'scroll',
|
|
'setCursorBlink', 'setCursorPos', 'write' }
|
|
for _,v in pairs(methods) do
|
|
nt[v] = function() end
|
|
end
|
|
|
|
return nt
|
|
end
|
|
|
|
function Terminal.copy(it, ot)
|
|
ot = ot or { }
|
|
for k,v in pairs(it) do
|
|
if type(v) == 'function' then
|
|
ot[k] = v
|
|
end
|
|
end
|
|
return ot
|
|
end
|
|
|
|
function Terminal.mirror(ct, dt)
|
|
local t = { }
|
|
for k,f in pairs(ct) do
|
|
t[k] = function(...)
|
|
local ret = { f(...) }
|
|
if dt[k] then
|
|
dt[k](...)
|
|
end
|
|
return table.unpack(ret)
|
|
end
|
|
end
|
|
return t
|
|
end
|
|
|
|
function Terminal.readPassword(prompt)
|
|
if prompt then
|
|
term.write(prompt)
|
|
end
|
|
local fn = term.current().write
|
|
term.current().write = function() end
|
|
local s
|
|
pcall(function() s = _G.read(prompt) end)
|
|
term.current().write = fn
|
|
|
|
if s == '' then
|
|
return
|
|
end
|
|
return s
|
|
end
|
|
|
|
return Terminal
|