init
This commit is contained in:
649
libs/compat.lua
Normal file
649
libs/compat.lua
Normal file
@@ -0,0 +1,649 @@
|
||||
local lib = {}
|
||||
|
||||
local expect
|
||||
do
|
||||
local h = fs.open("rom/modules/main/cc/expect.lua", "r")
|
||||
local f, err = loadstring(h.readAll(), "@/rom/modules/main/cc/expect.lua")
|
||||
h.close()
|
||||
|
||||
if not f then error(err) end
|
||||
expect = f().expect
|
||||
end
|
||||
|
||||
function lib.setupENV(win)
|
||||
local expect = dofile("rom/modules/main/cc/expect.lua").expect
|
||||
|
||||
local native = term.native and term.native() or term
|
||||
local redirectTarget = native
|
||||
|
||||
local function wrap(_sFunction)
|
||||
return function(...)
|
||||
return redirectTarget[_sFunction](...)
|
||||
end
|
||||
end
|
||||
|
||||
local term = {}
|
||||
|
||||
--- Redirects terminal output to a monitor, a [`window`], or any other custom
|
||||
-- terminal object. Once the redirect is performed, any calls to a "term"
|
||||
-- function - or to a function that makes use of a term function, as [`print`] -
|
||||
-- will instead operate with the new terminal object.
|
||||
--
|
||||
-- A "terminal object" is simply a table that contains functions with the same
|
||||
-- names - and general features - as those found in the term table. For example,
|
||||
-- a wrapped monitor is suitable.
|
||||
--
|
||||
-- The redirect can be undone by pointing back to the previous terminal object
|
||||
-- (which this function returns whenever you switch).
|
||||
--
|
||||
-- @tparam Redirect target The terminal redirect the [`term`] API will draw to.
|
||||
-- @treturn Redirect The previous redirect object, as returned by
|
||||
-- [`term.current`].
|
||||
-- @since 1.31
|
||||
-- @usage
|
||||
-- Redirect to a monitor on the right of the computer.
|
||||
--
|
||||
-- term.redirect(peripheral.wrap("right"))
|
||||
term.redirect = function(target)
|
||||
expect(1, target, "table")
|
||||
if target == term or target == _G.term then
|
||||
error("term is not a recommended redirect target, try term.current() instead", 2)
|
||||
end
|
||||
for k, v in pairs(native) do
|
||||
if type(k) == "string" and type(v) == "function" then
|
||||
if type(target[k]) ~= "function" then
|
||||
target[k] = function()
|
||||
error("Redirect object is missing method " .. k .. ".", 2)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
local oldRedirectTarget = redirectTarget
|
||||
redirectTarget = target
|
||||
return oldRedirectTarget
|
||||
end
|
||||
|
||||
--- Returns the current terminal object of the computer.
|
||||
--
|
||||
-- @treturn Redirect The current terminal redirect
|
||||
-- @since 1.6
|
||||
-- @usage
|
||||
-- Create a new [`window`] which draws to the current redirect target.
|
||||
--
|
||||
-- window.create(term.current(), 1, 1, 10, 10)
|
||||
term.current = function()
|
||||
return redirectTarget
|
||||
end
|
||||
|
||||
--- Get the native terminal object of the current computer.
|
||||
--
|
||||
-- It is recommended you do not use this function unless you absolutely have
|
||||
-- to. In a multitasked environment, [`term.native`] will _not_ be the current
|
||||
-- terminal object, and so drawing may interfere with other programs.
|
||||
--
|
||||
-- @treturn Redirect The native terminal redirect.
|
||||
-- @since 1.6
|
||||
term.native = function()
|
||||
return native
|
||||
end
|
||||
|
||||
-- Some methods shouldn't go through redirects, so we move them to the main
|
||||
-- term API.
|
||||
for _, method in ipairs { "nativePaletteColor", "nativePaletteColour" } do
|
||||
term[method] = native[method]
|
||||
native[method] = nil
|
||||
end
|
||||
|
||||
for k, v in pairs(native) do
|
||||
if type(k) == "string" and type(v) == "function" and rawget(term, k) == nil then
|
||||
term[k] = wrap(k)
|
||||
end
|
||||
end
|
||||
term.redirect(win)
|
||||
local function read(_sReplaceChar, _tHistory, _fnComplete, _sDefault)
|
||||
expect(1, _sReplaceChar, "string", "nil")
|
||||
expect(2, _tHistory, "table", "nil")
|
||||
expect(3, _fnComplete, "function", "nil")
|
||||
expect(4, _sDefault, "string", "nil")
|
||||
|
||||
term.setCursorBlink(true)
|
||||
|
||||
local sLine
|
||||
if type(_sDefault) == "string" then
|
||||
sLine = _sDefault
|
||||
else
|
||||
sLine = ""
|
||||
end
|
||||
local nHistoryPos
|
||||
local nPos, nScroll = #sLine, 0
|
||||
if _sReplaceChar then
|
||||
_sReplaceChar = string.sub(_sReplaceChar, 1, 1)
|
||||
end
|
||||
|
||||
local tCompletions
|
||||
local nCompletion
|
||||
local function recomplete()
|
||||
if _fnComplete and nPos == #sLine then
|
||||
tCompletions = _fnComplete(sLine)
|
||||
if tCompletions and #tCompletions > 0 then
|
||||
nCompletion = 1
|
||||
else
|
||||
nCompletion = nil
|
||||
end
|
||||
else
|
||||
tCompletions = nil
|
||||
nCompletion = nil
|
||||
end
|
||||
end
|
||||
|
||||
local function uncomplete()
|
||||
tCompletions = nil
|
||||
nCompletion = nil
|
||||
end
|
||||
|
||||
local w = term.getSize()
|
||||
local sx = term.getCursorPos()
|
||||
|
||||
local function redraw(_bClear)
|
||||
local cursor_pos = nPos - nScroll
|
||||
if sx + cursor_pos >= w then
|
||||
-- We've moved beyond the RHS, ensure we're on the edge.
|
||||
nScroll = sx + nPos - w
|
||||
elseif cursor_pos < 0 then
|
||||
-- We've moved beyond the LHS, ensure we're on the edge.
|
||||
nScroll = nPos
|
||||
end
|
||||
|
||||
local _, cy = term.getCursorPos()
|
||||
term.setCursorPos(sx, cy)
|
||||
local sReplace = _bClear and " " or _sReplaceChar
|
||||
if sReplace then
|
||||
term.write(string.rep(sReplace, math.max(#sLine - nScroll, 0)))
|
||||
else
|
||||
term.write(string.sub(sLine, nScroll + 1))
|
||||
end
|
||||
|
||||
if nCompletion then
|
||||
local sCompletion = tCompletions[nCompletion]
|
||||
local oldText, oldBg
|
||||
if not _bClear then
|
||||
oldText = term.getTextColor()
|
||||
oldBg = term.getBackgroundColor()
|
||||
term.setTextColor(colors.white)
|
||||
term.setBackgroundColor(colors.gray)
|
||||
end
|
||||
if sReplace then
|
||||
term.write(string.rep(sReplace, #sCompletion))
|
||||
else
|
||||
term.write(sCompletion)
|
||||
end
|
||||
if not _bClear then
|
||||
term.setTextColor(oldText)
|
||||
term.setBackgroundColor(oldBg)
|
||||
end
|
||||
end
|
||||
|
||||
term.setCursorPos(sx + nPos - nScroll, cy)
|
||||
end
|
||||
|
||||
local function clear()
|
||||
redraw(true)
|
||||
end
|
||||
|
||||
recomplete()
|
||||
redraw()
|
||||
|
||||
local function acceptCompletion()
|
||||
if nCompletion then
|
||||
-- Clear
|
||||
clear()
|
||||
|
||||
-- Find the common prefix of all the other suggestions which start with the same letter as the current one
|
||||
local sCompletion = tCompletions[nCompletion]
|
||||
sLine = sLine .. sCompletion
|
||||
nPos = #sLine
|
||||
|
||||
-- Redraw
|
||||
recomplete()
|
||||
redraw()
|
||||
end
|
||||
end
|
||||
while true do
|
||||
local sEvent, param, param1, param2 = os.pullEvent()
|
||||
if sEvent == "char" then
|
||||
-- Typed key
|
||||
clear()
|
||||
sLine = string.sub(sLine, 1, nPos) .. param .. string.sub(sLine, nPos + 1)
|
||||
nPos = nPos + 1
|
||||
recomplete()
|
||||
redraw()
|
||||
elseif sEvent == "paste" then
|
||||
-- Pasted text
|
||||
clear()
|
||||
sLine = string.sub(sLine, 1, nPos) .. param .. string.sub(sLine, nPos + 1)
|
||||
nPos = nPos + #param
|
||||
recomplete()
|
||||
redraw()
|
||||
elseif sEvent == "key" then
|
||||
if param == keys.enter or param == keys.numPadEnter then
|
||||
-- Enter/Numpad Enter
|
||||
if nCompletion then
|
||||
clear()
|
||||
uncomplete()
|
||||
redraw()
|
||||
end
|
||||
break
|
||||
elseif param == keys.left then
|
||||
-- Left
|
||||
if nPos > 0 then
|
||||
clear()
|
||||
nPos = nPos - 1
|
||||
recomplete()
|
||||
redraw()
|
||||
end
|
||||
elseif param == keys.right then
|
||||
-- Right
|
||||
if nPos < #sLine then
|
||||
-- Move right
|
||||
clear()
|
||||
nPos = nPos + 1
|
||||
recomplete()
|
||||
redraw()
|
||||
else
|
||||
-- Accept autocomplete
|
||||
acceptCompletion()
|
||||
end
|
||||
elseif param == keys.up or param == keys.down then
|
||||
-- Up or down
|
||||
if nCompletion then
|
||||
-- Cycle completions
|
||||
clear()
|
||||
if param == keys.up then
|
||||
nCompletion = nCompletion - 1
|
||||
if nCompletion < 1 then
|
||||
nCompletion = #tCompletions
|
||||
end
|
||||
elseif param == keys.down then
|
||||
nCompletion = nCompletion + 1
|
||||
if nCompletion > #tCompletions then
|
||||
nCompletion = 1
|
||||
end
|
||||
end
|
||||
redraw()
|
||||
elseif _tHistory then
|
||||
-- Cycle history
|
||||
clear()
|
||||
if param == keys.up then
|
||||
-- Up
|
||||
if nHistoryPos == nil then
|
||||
if #_tHistory > 0 then
|
||||
nHistoryPos = #_tHistory
|
||||
end
|
||||
elseif nHistoryPos > 1 then
|
||||
nHistoryPos = nHistoryPos - 1
|
||||
end
|
||||
else
|
||||
-- Down
|
||||
if nHistoryPos == #_tHistory then
|
||||
nHistoryPos = nil
|
||||
elseif nHistoryPos ~= nil then
|
||||
nHistoryPos = nHistoryPos + 1
|
||||
end
|
||||
end
|
||||
if nHistoryPos then
|
||||
sLine = _tHistory[nHistoryPos]
|
||||
nPos, nScroll = #sLine, 0
|
||||
else
|
||||
sLine = ""
|
||||
nPos, nScroll = 0, 0
|
||||
end
|
||||
uncomplete()
|
||||
redraw()
|
||||
end
|
||||
elseif param == keys.backspace then
|
||||
-- Backspace
|
||||
if nPos > 0 then
|
||||
clear()
|
||||
sLine = string.sub(sLine, 1, nPos - 1) .. string.sub(sLine, nPos + 1)
|
||||
nPos = nPos - 1
|
||||
if nScroll > 0 then nScroll = nScroll - 1 end
|
||||
recomplete()
|
||||
redraw()
|
||||
end
|
||||
elseif param == keys.home then
|
||||
-- Home
|
||||
if nPos > 0 then
|
||||
clear()
|
||||
nPos = 0
|
||||
recomplete()
|
||||
redraw()
|
||||
end
|
||||
elseif param == keys.delete then
|
||||
-- Delete
|
||||
if nPos < #sLine then
|
||||
clear()
|
||||
sLine = string.sub(sLine, 1, nPos) .. string.sub(sLine, nPos + 2)
|
||||
recomplete()
|
||||
redraw()
|
||||
end
|
||||
elseif param == keys["end"] then
|
||||
-- End
|
||||
if nPos < #sLine then
|
||||
clear()
|
||||
nPos = #sLine
|
||||
recomplete()
|
||||
redraw()
|
||||
end
|
||||
elseif param == keys.tab then
|
||||
-- Tab (accept autocomplete)
|
||||
acceptCompletion()
|
||||
end
|
||||
elseif sEvent == "mouse_click" or sEvent == "mouse_drag" and param == 1 then
|
||||
local _, cy = term.getCursorPos()
|
||||
if param1 >= sx and param1 <= w and param2 == cy then
|
||||
-- Ensure we don't scroll beyond the current line
|
||||
nPos = math.min(math.max(nScroll + param1 - sx, 0), #sLine)
|
||||
redraw()
|
||||
end
|
||||
elseif sEvent == "term_resize" then
|
||||
-- Terminal resized
|
||||
w = term.getSize()
|
||||
redraw()
|
||||
end
|
||||
end
|
||||
|
||||
local _, cy = term.getCursorPos()
|
||||
term.setCursorBlink(false)
|
||||
term.setCursorPos(w + 1, cy)
|
||||
print()
|
||||
|
||||
return sLine
|
||||
end
|
||||
|
||||
|
||||
local function write(sText)
|
||||
expect(1, sText, "string", "number")
|
||||
|
||||
local w, h = term.getSize()
|
||||
local x, y = term.getCursorPos()
|
||||
|
||||
local nLinesPrinted = 0
|
||||
local function newLine()
|
||||
if y + 1 <= h then
|
||||
term.setCursorPos(1, y + 1)
|
||||
else
|
||||
term.setCursorPos(1, h)
|
||||
term.scroll(1)
|
||||
end
|
||||
x, y = term.getCursorPos()
|
||||
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
|
||||
term.write(whitespace)
|
||||
x, y = term.getCursorPos()
|
||||
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 > w then
|
||||
-- Print a multiline word
|
||||
while #text > 0 do
|
||||
if x > w then
|
||||
newLine()
|
||||
end
|
||||
term.write(text)
|
||||
text = string.sub(text, w - x + 2)
|
||||
x, y = term.getCursorPos()
|
||||
end
|
||||
else
|
||||
-- Print a word normally
|
||||
if x + #text - 1 > w then
|
||||
newLine()
|
||||
end
|
||||
term.write(text)
|
||||
x, y = term.getCursorPos()
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return nLinesPrinted
|
||||
end
|
||||
function print(...)
|
||||
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 + write(s)
|
||||
end
|
||||
nLinesPrinted = nLinesPrinted + write("\n")
|
||||
return nLinesPrinted
|
||||
end
|
||||
|
||||
local function printError(...)
|
||||
local oldColour
|
||||
if term.isColour() then
|
||||
oldColour = term.getTextColour()
|
||||
term.setTextColour(colors.red)
|
||||
end
|
||||
print(...)
|
||||
if term.isColour() then
|
||||
term.setTextColour(oldColour)
|
||||
end
|
||||
end
|
||||
local tAPIsLoading = {}
|
||||
|
||||
local bAPIError = false
|
||||
|
||||
local env = setmetatable({
|
||||
term = term,
|
||||
write = write,
|
||||
read = read,
|
||||
shell = shell,
|
||||
print = print,
|
||||
printError = printError
|
||||
}, { __index = _G })
|
||||
|
||||
local function loadAPI(_sPath)
|
||||
expect(1, _sPath, "string")
|
||||
local sName = fs.getName(_sPath)
|
||||
if sName:sub(-4) == ".lua" then
|
||||
sName = sName:sub(1, -5)
|
||||
end
|
||||
if sName == "term" then
|
||||
return true
|
||||
end
|
||||
if tAPIsLoading[sName] == true then
|
||||
printError("API " .. sName .. " is already being loaded")
|
||||
return false
|
||||
end
|
||||
tAPIsLoading[sName] = true
|
||||
|
||||
local tEnv = {}
|
||||
setmetatable(tEnv, { __index = env })
|
||||
local fnAPI, err = loadfile(_sPath, nil, tEnv)
|
||||
if fnAPI then
|
||||
local ok, err = pcall(fnAPI)
|
||||
if not ok then
|
||||
tAPIsLoading[sName] = nil
|
||||
return error("Failed to load API " .. sName .. " due to " .. err, 1)
|
||||
end
|
||||
else
|
||||
tAPIsLoading[sName] = nil
|
||||
return error("Failed to load API " .. sName .. " due to " .. err, 1)
|
||||
end
|
||||
|
||||
local tAPI = {}
|
||||
for k, v in pairs(tEnv) do
|
||||
if k ~= "_ENV" then
|
||||
tAPI[k] = v
|
||||
end
|
||||
end
|
||||
env[sName] = tAPI
|
||||
tAPIsLoading[sName] = nil
|
||||
return true
|
||||
end
|
||||
|
||||
local function load_apis(dir)
|
||||
if not fs.isDir(dir) then return end
|
||||
|
||||
for _, file in ipairs(fs.list(dir)) do
|
||||
if file:sub(1, 1) ~= "." then
|
||||
local path = fs.combine(dir, file)
|
||||
if not fs.isDir(path) then
|
||||
if not loadAPI(path) then
|
||||
bAPIError = true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
load_apis("rom/apis")
|
||||
if http then load_apis("rom/apis/http") end
|
||||
if turtle then load_apis("rom/apis/turtle") end
|
||||
if pocket then load_apis("rom/apis/pocket") end
|
||||
env._ENV = env
|
||||
env._G = env
|
||||
|
||||
return env
|
||||
end
|
||||
|
||||
local function generate_id(length)
|
||||
local id = ""
|
||||
for _ = 1, length do
|
||||
id = id .. string.char(math.random(97, 122))
|
||||
end
|
||||
return id
|
||||
end
|
||||
|
||||
local function runInRuntime(func, win)
|
||||
expect(1, func, "function")
|
||||
expect(2, win, "table")
|
||||
local co = coroutine.create(func)
|
||||
local winid = generate_id(40)
|
||||
local filter = nil
|
||||
local event_data = { n = 0 }
|
||||
local run = true
|
||||
function win.clicked(xc, yc, button)
|
||||
os.queueEvent("mouse_click_" .. winid, button, xc, yc, winid)
|
||||
end
|
||||
|
||||
function win.released(xc, yc, button)
|
||||
os.queueEvent("mouse_up_" .. winid, button, xc, yc, winid)
|
||||
end
|
||||
|
||||
function win.dragged(xc, yc, button)
|
||||
os.queueEvent("mouse_drag_" .. winid, button, xc, yc, winid)
|
||||
end
|
||||
|
||||
function win.scrolled(dir, xc, yc)
|
||||
os.queueEvent("mouse_scroll_" .. winid, dir, xc, yc, winid)
|
||||
end
|
||||
|
||||
function win.char(ch)
|
||||
os.queueEvent("char_" .. winid, ch, winid)
|
||||
end
|
||||
|
||||
function win.key(key, is_held)
|
||||
os.queueEvent("key_" .. winid, key, is_held, winid)
|
||||
end
|
||||
|
||||
function win.key_up(key)
|
||||
os.queueEvent("key_up_" .. winid, key, winid)
|
||||
end
|
||||
|
||||
function win.closeRequested()
|
||||
run = false
|
||||
end
|
||||
|
||||
local function escape_lua_pattern(s)
|
||||
-- magic chars: ( ) . % + - * ? [ ^ $ ]
|
||||
return (s:gsub("([%^%$%(%)%%%.%[%]%*%+%-%?])", "%%%1"))
|
||||
end
|
||||
|
||||
local start = true
|
||||
while run and coroutine.status(co) ~= "dead" do
|
||||
if event_data.n > 0 or start then
|
||||
local ok, msg = coroutine.resume(co, table.unpack(event_data, 1, event_data.n))
|
||||
start = false
|
||||
if ok then
|
||||
filter = msg
|
||||
else
|
||||
error(msg)
|
||||
end
|
||||
end
|
||||
local data = table.pack(os.pullEvent())
|
||||
data[1] = data[1]:gsub(escape_lua_pattern "_" .. winid, "")
|
||||
if data[1] == filter or filter == nil or data[1] == "terminated" then
|
||||
if data[1] == "char" then
|
||||
if data[#data] == winid then
|
||||
data.n = data.n - 1
|
||||
event_data = data
|
||||
end
|
||||
elseif data[1] == "key" then
|
||||
if data[#data] == winid then
|
||||
data.n = data.n - 1
|
||||
event_data = data
|
||||
end
|
||||
elseif data[1] == "mouse_click" then
|
||||
if data[#data] == winid then
|
||||
data.n = data.n - 1
|
||||
event_data = data
|
||||
end
|
||||
elseif data[1] == "mouse_drag" then
|
||||
if data[#data] == winid then
|
||||
data.n = data.n - 1
|
||||
event_data = data
|
||||
end
|
||||
elseif data[1] == "key_up" then
|
||||
if data[#data] == winid then
|
||||
data.n = data.n - 1
|
||||
event_data = data
|
||||
end
|
||||
elseif data[1] == "mouse_up" then
|
||||
if data[#data] == winid then
|
||||
data.n = data.n - 1
|
||||
event_data = data
|
||||
end
|
||||
elseif data[1] == "mouse_scroll" then
|
||||
if data[#data] == winid then
|
||||
data.n = data.n - 1
|
||||
event_data = data
|
||||
end
|
||||
else
|
||||
event_data = data
|
||||
end
|
||||
else
|
||||
event_data = { n = 0 }
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function lib.runFunc(func, win)
|
||||
runInRuntime(setfenv(func, lib.setupENV(win)), win)
|
||||
end
|
||||
|
||||
function lib.runFile(file, win)
|
||||
local func = loadfile(file)
|
||||
runInRuntime(setfenv(func, lib.setupENV(win)), win)
|
||||
end
|
||||
|
||||
return lib
|
||||
Reference in New Issue
Block a user