495 lines
17 KiB
Lua
495 lines
17 KiB
Lua
---@module "cctAPI"
|
|
|
|
---example:
|
|
---```
|
|
---for pos, code in codes("你好world") do
|
|
--- print(pos, code)
|
|
---end
|
|
------>
|
|
---1 20320
|
|
---4 22909
|
|
---7 119
|
|
---8 111
|
|
---9 114
|
|
---10 108
|
|
---11 100
|
|
---```
|
|
---@param str string
|
|
---@return fun():pos:integer, code:integer
|
|
local function codes(str)
|
|
local len = #str
|
|
local i = 0
|
|
|
|
local function illegalChar()
|
|
error("Illegal UTF-8 character at position " .. tostring(i))
|
|
end
|
|
|
|
return function()
|
|
i = i + 1
|
|
---@diagnostic disable-next-line
|
|
if i > len then return end
|
|
|
|
local pos = i
|
|
local byte = string.byte(str, i)
|
|
|
|
-- Single-byte character
|
|
if byte < 0x80 then
|
|
return pos, byte
|
|
|
|
-- Multi-byte sequences
|
|
elseif byte >= 0xC0 then
|
|
local bytes_remaining, code = 0, 0
|
|
|
|
if byte < 0xE0 then -- 2-byte sequence
|
|
bytes_remaining = 1
|
|
code = byte - 0xC0
|
|
elseif byte < 0xF0 then -- 3-byte sequence
|
|
bytes_remaining = 2
|
|
code = byte - 0xE0
|
|
elseif byte < 0xF8 then -- 4-byte sequence
|
|
bytes_remaining = 3
|
|
code = byte - 0xF0
|
|
else
|
|
illegalChar()
|
|
end
|
|
|
|
-- Validate remaining bytes
|
|
if i + bytes_remaining > len then
|
|
illegalChar()
|
|
end
|
|
|
|
-- Calculate code point
|
|
for j = 1, bytes_remaining do
|
|
i = i + 1
|
|
local next_byte = string.byte(str, i)
|
|
if next_byte < 0x80 or next_byte >= 0xC0 then
|
|
illegalChar()
|
|
end
|
|
code = code * 0x40 + (next_byte - 0x80)
|
|
end
|
|
|
|
return pos, code
|
|
else
|
|
illegalChar()
|
|
---@diagnostic disable-next-line
|
|
end
|
|
end
|
|
end
|
|
|
|
---@type FontFamily
|
|
local defaultFontFamily = {
|
|
maxHeight = 4,
|
|
[1] = require("fonts/fusion-pixel-12px-proportional-zh_hans")
|
|
}
|
|
|
|
---@param str string read in `"rb"` mode from file
|
|
---@param nStartPos integer? 1~n, -n~-1 to represent pos reverse
|
|
---@param nEndPos integer? 1~n, -n~-1 to represent pos reverse
|
|
---@return string substring sub string of utf8 character from `nStartPos` to `nEndPos`
|
|
local function sub(str, nStartPos, nEndPos)
|
|
local charPos = 0
|
|
local utf8charPosToStr = {}
|
|
|
|
for pos, _ in codes(str) do
|
|
charPos = charPos + 1
|
|
utf8charPosToStr[charPos] = pos
|
|
end
|
|
|
|
nStartPos = nStartPos or 1
|
|
nEndPos = nEndPos or charPos
|
|
nStartPos = nStartPos < 0 and math.max(1, charPos + nStartPos + 1) or math.min(charPos, nStartPos)
|
|
nEndPos = nEndPos < 0 and math.max(1, charPos + nEndPos + 1) or math.min(charPos, nEndPos)
|
|
|
|
local startByte = utf8charPosToStr[nStartPos]
|
|
local endByte = utf8charPosToStr[nEndPos + 1] and utf8charPosToStr[nEndPos + 1] - 1 or #str
|
|
return string.sub(str, startByte, endByte)
|
|
end
|
|
|
|
---@class FontFamily
|
|
---@field maxHeight integer
|
|
---@diagnostic disable-next-line
|
|
---@field [integer] Font get from `require(font_name)`
|
|
|
|
---@param ... string module names of font, font should be
|
|
---@return FontFamily
|
|
local function getFontFamily(...)
|
|
local fonts = { maxHeight = 0 }
|
|
|
|
for i, path in ipairs({ ... }) do
|
|
if not fs.exists(path .. ".lua") then
|
|
error("Font module not found: " .. path)
|
|
end
|
|
|
|
local font = require(path)
|
|
if not font[72] then
|
|
error("'H'(ascII:72) not found in font " .. path)
|
|
end
|
|
|
|
fonts[i] = font
|
|
fonts.maxHeight = math.max(fonts.maxHeight, #font[72])
|
|
end
|
|
|
|
return fonts
|
|
end
|
|
---@alias bitmap string[] the bitmap of a character
|
|
|
|
---@param code integer
|
|
---@param fontFamily FontFamily
|
|
---@return bitmap
|
|
local function getCharMap(code, fontFamily)
|
|
local cm
|
|
for _, font in ipairs(fontFamily) do
|
|
cm = font[code]
|
|
if cm then
|
|
return cm
|
|
end
|
|
end
|
|
error(("char of utf8 %d is not supported"):format(code))
|
|
end
|
|
|
|
---@class Config
|
|
---@field fontFamily FontFamily?
|
|
---@field textColor number?
|
|
---@field backgroundColor number?
|
|
---@field masking [integer, integer, integer, integer]?
|
|
---@field autoScroll boolean
|
|
---@field autoNewLine boolean
|
|
---@field autoWrapMode "n"|"b"|"-"?
|
|
---@field autoWrapLen integer?
|
|
---@field avoidBorder boolean
|
|
---@field tabLen integer?
|
|
|
|
---@see Config
|
|
---@param preset "noauto"?
|
|
---@return Config
|
|
local function getCfg(preset)
|
|
---@type Config
|
|
local base = {
|
|
fontFamily = defaultFontFamily,
|
|
textColor = nil,
|
|
backgroundColor = nil,
|
|
masking = nil,
|
|
autoScroll = true,
|
|
autoNewLine = true,
|
|
autoWrapMode = "b",
|
|
autoWrapLen = nil,
|
|
avoidBorder = true,
|
|
tabLen = 2
|
|
}
|
|
if preset == "noauto" then
|
|
base.autoScroll = false
|
|
base.autoNewLine = false
|
|
base.autoWrapMode = "n"
|
|
end
|
|
return base
|
|
end
|
|
|
|
|
|
---`str` should be read in `"rb"` mode from file <br>
|
|
---`cfg` see [`getCfg()`](lua://Config)
|
|
---### Config
|
|
---- **textColor**
|
|
---- **backgroundColor**
|
|
---- **fontFamily** use [`getFontFamily()`](lua://FontFamily) to modify
|
|
---- **masking** representing x1, y1, x2, y2 of 2 coordinates, concent out of the rectange range won't print
|
|
---- **autoScroll** if true, if next line is over-height, [`term.scroll()`](https://tweaked.cc/module/term.html#v:scroll) will be called, masking will also be scrolled
|
|
---- **autoNewLine** if true, the output will be like a `\n` added to the end
|
|
---- **autoWrapMode** <br>
|
|
----- `"n"` do not auto wrap<br>
|
|
----- `"b"` English letter will not be broken<br>
|
|
----- `"-"` English letter will be broken by a `'-'`<br>
|
|
---here 'letter' matches regex `(?<![a-zA-Z'])[a-zA-Z']+-?`<br>
|
|
---actually realized avoid using `luautf8` or regex matching
|
|
---- **autoWrapLen** the maximum distance a line goes from the terminal's left
|
|
---- **avoidBorder** if true, autoScroll and autoWrap will avoid printing border pixels, which have render issue<br>
|
|
---for example, autoWrap will start new line at pos (2, y) instead of (1, y)
|
|
---- **tabLen** the count of `' '` to replace `'\t'`
|
|
---@param str string
|
|
---@param cfg Config?
|
|
local function printUtf8(str, cfg)
|
|
local cursorX, cursorY = term.getCursorPos()
|
|
local termWidth, termHeight = term.getSize()
|
|
|
|
local cfg = cfg or getCfg()
|
|
local oriTextColor, oriBackgroundColor = term.getTextColor(), term.getBackgroundColor()
|
|
local textColor = cfg.textColor or oriTextColor
|
|
local backgroundColor = cfg.backgroundColor or oriBackgroundColor
|
|
local masking = cfg.masking
|
|
local autoScroll = cfg.autoScroll or true
|
|
local autoNewLine = cfg.autoNewLine
|
|
local autoWrapMode = cfg.autoWrapMode or "b"
|
|
local autoWrapLen = cfg.autoWrapLen or termWidth
|
|
local avoidBorder = cfg.avoidBorder
|
|
local fontFamily = cfg.fontFamily or defaultFontFamily
|
|
local tabLen = cfg.tabLen or 2
|
|
str = string.gsub(str, '\t', string.rep(" ", tabLen))
|
|
local fontHeight = fontFamily.maxHeight
|
|
if avoidBorder and autoWrapMode ~= "n" then
|
|
autoWrapLen = math.min(termWidth - 1, autoWrapLen)
|
|
cursorX = math.max(2, cursorX)
|
|
cursorY = math.max(2, cursorY)
|
|
end
|
|
local maxHeight = avoidBorder and termHeight - 1 or termHeight
|
|
---@type integer[]
|
|
local letterBuffer = {}
|
|
local dashWidth = #getCharMap(45, fontFamily)[1]
|
|
---@type { pos: [integer, integer], code: integer }[]
|
|
local charBuffer = {}
|
|
|
|
---@param x integer
|
|
---@param y integer
|
|
---@return boolean
|
|
local function bInMasking(x, y)
|
|
---@diagnostic disable-next-line
|
|
return x >= masking[1] and x <= masking[3] and y >= masking[2] and y <= masking[4]
|
|
end
|
|
---add new line to charBuffer
|
|
local function posNewLine()
|
|
cursorX = avoidBorder and 2 or 1
|
|
if autoScroll and cursorY + fontHeight > maxHeight then
|
|
-- scroll term and masking
|
|
term.scroll(fontHeight)
|
|
for _, char in ipairs(charBuffer) do
|
|
char.pos[2] = char.pos[2] - fontHeight
|
|
end
|
|
if masking then
|
|
masking[2] = masking[2] - fontHeight
|
|
masking[4] = masking[4] - fontHeight
|
|
end
|
|
else
|
|
cursorY = cursorY + fontHeight
|
|
end
|
|
end
|
|
---print char in charBuffer
|
|
local function printChar()
|
|
local bIsLastReversed = false
|
|
term.setTextColor(textColor)
|
|
term.setBackgroundColor(backgroundColor)
|
|
for _, char in ipairs(charBuffer) do
|
|
---@type bitmap
|
|
local charMap
|
|
local code = char.code
|
|
for _, font in ipairs(fontFamily) do
|
|
if font[code] then
|
|
charMap = font[code]
|
|
break
|
|
end
|
|
end
|
|
|
|
local width, height = #charMap[1], #charMap
|
|
local cursorX, cursorY = unpack(char.pos)
|
|
if height < fontHeight then
|
|
if bIsLastReversed then
|
|
bIsLastReversed = false
|
|
term.setTextColor(textColor)
|
|
term.setBackgroundColor(backgroundColor)
|
|
end
|
|
for _ = 1, fontHeight - height do
|
|
term.setCursorPos(cursorX, cursorY)
|
|
term.write(string.rep(" ", width))
|
|
cursorY = cursorY + 1
|
|
end
|
|
end
|
|
for y = 1, height do
|
|
local posY = cursorY + y - 1
|
|
term.setCursorPos(cursorX, posY)
|
|
local sCharMapBuffer = charMap[y]
|
|
for x = 1, width do
|
|
if not masking or bInMasking(cursorX + x - 1, posY) then
|
|
local code = string.byte(sCharMapBuffer, x)
|
|
if code < 128 then
|
|
code = code + 128
|
|
if not bIsLastReversed then
|
|
bIsLastReversed = true
|
|
term.setTextColor(backgroundColor)
|
|
term.setBackgroundColor(textColor)
|
|
end
|
|
else
|
|
if bIsLastReversed then
|
|
bIsLastReversed = false
|
|
term.setTextColor(textColor)
|
|
term.setBackgroundColor(backgroundColor)
|
|
end
|
|
end
|
|
term.write(string.char(code))
|
|
else
|
|
term.setCursorPos(cursorX + x, posY)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
term.setTextColor(oriTextColor)
|
|
term.setBackgroundColor(oriBackgroundColor)
|
|
if autoNewLine then
|
|
term.setCursorPos(1, cursorY + fontHeight)
|
|
else
|
|
term.setCursorPos(cursorX, cursorY)
|
|
end
|
|
end
|
|
local bIsLetter = false
|
|
local function releaseLetter()
|
|
if bIsLetter then
|
|
if autoWrapMode == "-" then
|
|
local widthSum = cursorX - 1
|
|
local widthBuffer = {}
|
|
for index, letter in ipairs(letterBuffer) do
|
|
widthBuffer[index] = #getCharMap(letter, fontFamily)[1]
|
|
end
|
|
local ind = 1
|
|
local letterBufferLen = #letterBuffer
|
|
local lastDashPos = 1
|
|
|
|
|
|
while ind <= letterBufferLen do
|
|
widthSum = widthSum + widthBuffer[ind]
|
|
if widthSum > autoWrapLen then
|
|
while widthSum + dashWidth > autoWrapLen do
|
|
if ind == lastDashPos then
|
|
-- when have to insert dash in the first character, posNewLine() or throw
|
|
if ind == 1 and cursorX ~= (avoidBorder and 2 or 1) then
|
|
widthSum = 0
|
|
else
|
|
error("dash too wide or autoWrapLen too small")
|
|
end
|
|
end
|
|
widthSum = widthSum - widthBuffer[ind]
|
|
ind = ind - 1
|
|
end
|
|
-- pos letters before dash
|
|
for i = lastDashPos, ind do
|
|
charBuffer[#charBuffer + 1] = {
|
|
pos = { cursorX, cursorY },
|
|
code = letterBuffer[i]
|
|
}
|
|
cursorX = cursorX + widthBuffer[i]
|
|
end
|
|
if widthSum >= 0 then
|
|
-- add dash
|
|
charBuffer[#charBuffer + 1] = {
|
|
pos = { cursorX, cursorY },
|
|
code = 45
|
|
}
|
|
end
|
|
-- reset
|
|
widthSum = 0
|
|
lastDashPos = ind + 1
|
|
posNewLine()
|
|
end
|
|
ind = ind + 1
|
|
end
|
|
-- pos letters after dash
|
|
for i = lastDashPos, letterBufferLen do
|
|
charBuffer[#charBuffer + 1] = {
|
|
pos = { cursorX, cursorY },
|
|
code = letterBuffer[i]
|
|
}
|
|
cursorX = cursorX + widthBuffer[i]
|
|
end
|
|
elseif autoWrapMode == "b" then
|
|
local widthSum = cursorX - 1
|
|
local widthBuffer = {}
|
|
local ind = 1
|
|
local letterBufferLen = #letterBuffer
|
|
while ind <= letterBufferLen do
|
|
local charMapWidth = #getCharMap(letterBuffer[ind], fontFamily)[1]
|
|
widthBuffer[ind] = charMapWidth
|
|
widthSum = widthSum + charMapWidth
|
|
ind = ind + 1
|
|
end
|
|
|
|
local forceNewLineFlag = false
|
|
if widthSum > autoWrapLen then
|
|
if cursorX == (avoidBorder and 2 or 1) then
|
|
forceNewLineFlag = true
|
|
else
|
|
widthSum = widthSum - cursorX + 1
|
|
if widthSum > autoWrapLen then
|
|
forceNewLineFlag = true
|
|
else
|
|
posNewLine()
|
|
end
|
|
end
|
|
end
|
|
if forceNewLineFlag then
|
|
for i = 1, letterBufferLen do
|
|
if cursorX + widthBuffer[i] > autoWrapLen then
|
|
posNewLine()
|
|
end
|
|
charBuffer[#charBuffer + 1] = {
|
|
pos = { cursorX, cursorY },
|
|
code = letterBuffer[i]
|
|
}
|
|
cursorX = cursorX + widthBuffer[i]
|
|
end
|
|
else
|
|
for i = 1, letterBufferLen do
|
|
charBuffer[#charBuffer + 1] = {
|
|
pos = { cursorX, cursorY },
|
|
code = letterBuffer[i]
|
|
}
|
|
cursorX = cursorX + widthBuffer[i]
|
|
end
|
|
end
|
|
elseif autoWrapMode == "n" then
|
|
for _, letter in ipairs(letterBuffer) do
|
|
charBuffer[#charBuffer + 1] = {
|
|
pos = { cursorX, cursorY },
|
|
code = letter
|
|
}
|
|
cursorX = cursorX + #getCharMap(letter, fontFamily)[1]
|
|
end
|
|
end
|
|
letterBuffer = {}
|
|
bIsLetter = false
|
|
end
|
|
end
|
|
|
|
local lastLR = false
|
|
for _, code in codes(str) do
|
|
-- handle break line, \r, \n and \r\n will be transferred
|
|
if code == 13 then
|
|
releaseLetter()
|
|
lastLR = true
|
|
posNewLine()
|
|
elseif code == 10 and not lastLR then
|
|
lastLR = false
|
|
releaseLetter()
|
|
posNewLine()
|
|
|
|
-- record letter for break line
|
|
elseif code == 45 and bIsLetter then
|
|
lastLR = false
|
|
letterBuffer[#letterBuffer + 1] = code
|
|
releaseLetter()
|
|
elseif code >= 65 and code <= 90 or (code >= 97 and code <= 122) or code == 39 then
|
|
lastLR = false
|
|
letterBuffer[#letterBuffer + 1] = code
|
|
bIsLetter = true
|
|
|
|
-- pos char
|
|
else
|
|
lastLR = false
|
|
releaseLetter()
|
|
local charMapWidth = #getCharMap(code, fontFamily)[1]
|
|
if autoWrapMode ~= "n" and cursorX + charMapWidth - 1 > autoWrapLen then
|
|
posNewLine()
|
|
end
|
|
charBuffer[#charBuffer + 1] = {
|
|
pos = { cursorX, cursorY },
|
|
code = code
|
|
}
|
|
cursorX = cursorX + charMapWidth
|
|
end
|
|
end
|
|
releaseLetter()
|
|
printChar()
|
|
end
|
|
return {
|
|
codes = codes,
|
|
printUtf8 = printUtf8,
|
|
getFontFamily = getFontFamily,
|
|
sub = sub,
|
|
getCfg = getCfg,
|
|
getCharMap = getCharMap
|
|
}
|