CanvasTerm.lua

--------------------------------------------------------------------------------------------------------
-- Wojbies API 4.3 - CanvasTerm - Api for drawing window-like term object on Plethora overlay glasses --
--------------------------------------------------------------------------------------------------------
--   Copyright (c) 2015-2021 Wojbie ([email protected])
--   Redistribution and use in source and binary forms, with or without modification, are permitted (subject to the limitations in the disclaimer below) provided that the following conditions are met:
--   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
--   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
--   3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
--   4. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
--   5. The origin of this software must not be misrepresented; you must not claim that you wrote the original software.
--   NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. YOU ACKNOWLEDGE THAT THIS SOFTWARE IS NOT DESIGNED, LICENSED OR INTENDED FOR USE IN THE DESIGN, CONSTRUCTION, OPERATION OR MAINTENANCE OF ANY NUCLEAR FACILITY.

--### Basic utility functions
local function copyTable(...)
    local tArgs = {...}
    local copy = {}
    for _, piece in pairs(tArgs) do
        if piece and type(piece) == "table" then
            for key, val in pairs(piece) do
                if type(val) == "table" then copy[key] = copyTable( copy[key] or {}, val)
                else copy[key] = val end
            end
        end
    end
    return copy
end

--### Initializing
local c = shell and {} or (_ENV or getfenv())
c.versionName = "CanvasTerm By Wojbie"
c.versionNum = 4.338 --2020-01-15

local expect = require "cc.expect".expect

--### Internal palette related tables.
local tDefaultPallette = {[ colors.white ] = 0xF0F0F0, [ colors.orange ] = 0xF2B233, [ colors.magenta ] = 0xE57FD8, [ colors.lightBlue ] = 0x99B2F2, [ colors.yellow ] = 0xDEDE6C, [ colors.lime ] = 0x7FCC19, [ colors.pink ] = 0xF2B2CC, [ colors.gray ] = 0x4C4C4C, [ colors.lightGray ] = 0x999999, [ colors.cyan ] = 0x4C99B2, [ colors.purple ] = 0xB266E5, [ colors.blue ] = 0x3366CC, [ colors.brown ] = 0x7F664C, [ colors.green ] = 0x57A64E, [ colors.red ] = 0xCC4C4C, [ colors.black ] = 0x111111}

local tRGBA = {[ "0" ] = 0xF0F0F0FF, [ "1" ] = 0xF2B233FF, [ "2" ] = 0xE57FD8FF, [ "3" ] = 0x99B2F2FF, [ "4" ] = 0xDEDE6CFF, [ "5" ] = 0x7FCC19FF, [ "6" ] = 0xF2B2CCFF, [ "7" ] = 0x4C4C4CFF, [ "8" ] = 0x999999FF, [ "9" ] = 0x4C99B2FF, [ "a" ] = 0xB266E5FF, [ "b" ] = 0x3366CCFF, [ "c" ] = 0x7F664CFF, [ "d" ] = 0x57A64EFF, [ "e" ] = 0xCC4C4CFF, [ "f" ] = 0x111111FF}

local tHex = {[ colors.white ] = "0", [ colors.orange ] = "1", [ colors.magenta ] = "2", [ colors.lightBlue ] = "3", [ colors.yellow ] = "4", [ colors.lime ] = "5", [ colors.pink ] = "6", [ colors.gray ] = "7", [ colors.lightGray ] = "8", [ colors.cyan ] = "9", [ colors.purple ] = "a", [ colors.blue ] = "b", [ colors.brown ] = "c", [ colors.green ] = "d", [ colors.red ] = "e", [ colors.black ] = "f"}

c.dummyTerm = function(nWidth, nHeight, bColor)

    local isColor = bColor and true or false
    local tDefaultPallette = copyTable(tDefaultPallette)

    local dummy = {}
    dummy.getPaletteColour = function( c ) return colors.unpackRGB(tDefaultPallette[c])  end
    dummy.isColor = function() return isColor end

    local buffer = window.create( dummy, 1, 1, nWidth, nHeight, false )
    local bufferResize = buffer.reposition

    buffer.setVisible = nil
    buffer.redraw = nil
    buffer.restoreCursor = nil
    buffer.getPosition = nil
    buffer.reposition = nil
    buffer.resize = function(nWidth, nHeight) return bufferResize(1, 1, nWidth, nHeight) end

    return buffer
end local dummyTerm = c.dummyTerm

local textOffsetX = { --How much it goes to right on each symbol
    ["!"] = 2, ['"'] = 1, ["'"] = 2, ['('] = 1, [')'] = 1, ['*'] = 1, [","] = 2, ["."] = 2, [":"] = 2, [";"] = 2, ["I"] = 1, ["["] = 1, ["]"] = 1, ["`"] = 2, ["f"] = 1, ["i"] = 2, ["k"] = 1, ["l"] = 2, ["t"] = 1, ["{"] = 1, ["|"] = 2, ["}"] = 1,
    ["\161"] = 2, ["\162"] = 1, ["\164"] = 1, ["\165"] = 1, ["\166"] = 3, ["\167"] = 1, ["\168"] = 1, ["\169"] = 1, ["\176"] = -1, ["\181"] = 1, ["\182"] = 1, ["\184"] = 2, ["\195"] = 1, ["\204"] = 1, ["\205"] = 1, ["\206"] = 1, ["\207"] = 1, ["\208"] = 1, ["\210"] = 1, ["\215"] = 1, ["\217"] = 1, ["\219"] = 1, ["\221"] = 1, ["\222"] = 1, ["\236"] = 1, ["\237"] = 2, ["\239"] = 1, ["\240"] = 1, ["\253"] = 1, ["\254"] = 1,
}
for i = 1, 8 do textOffsetX[string.char(i)] = -1 end
for i = 11, 12 do textOffsetX[string.char(i)] = -1 end
for i = 14, 31 do textOffsetX[string.char(i)] = -1 end
for i = 127, 159 do textOffsetX[string.char(i)] = -1 end
textOffsetX["\173"] = -1

--### Main function
c.create = function( parent, nX, nY, nWidth, nHeight, nScale, bVisible, bFrameCursor, bDisableAutoRedraw )

    expect(1, parent, "table")
    if not parent.addGroup then
        error( "Invalid parent object, please provide 2d canvas. try canvas() or canvas3d().create().addFrame()", 2 )
    end
    expect(2, nX, "number")
    expect(3, nY, "number")
    expect(4, nWidth, "number")
    expect(5, nHeight, "number")
    expect(6, nScale, "number", "nil")
    expect(7, bVisible, "boolean", "nil")
    expect(8, bFrameCursor, "boolean", "nil")
    expect(9, bDisableAutoRedraw, "boolean", "nil")

    bVisible = bVisible ~= false
    nScale = nScale or 1

    local group = parent.addGroup({nX, nY})
    local buffer = dummyTerm(nWidth, nHeight, true)
    local bufferResize = buffer.resize
    buffer.resize = nil
    local tRGBA = copyTable(tRGBA)
    local tHex = copyTable(tHex)
    local textOffsetX = copyTable(textOffsetX)
    local tFrame, tTexts, tBacks, tCursor
    local tText, tFront, tBack, tCursorMeta
    local bBlink, bOnScreen = true, true
    local nTextScaler = 4 / 6

    local function build()
        tTexts = {}
        tBacks = {}
        local xSize = 4 * nScale
        local ySize = 6 * nScale
        tFrame = group.addRectangle( 0 , 0 , xSize * nWidth + 2, ySize * nHeight + 2, 0x111111FF)
        for y = 1, nHeight do
            tBacks[y] = {}
            tTexts[y] = {}
            for x = 1, nWidth do
                tBacks[y][x] = group.addRectangle( (x - 1) * xSize + 1 , (y - 1) * ySize + 1 , xSize, ySize, 0x7F664CFF)
            end
            for x = 1, nWidth do
                tTexts[y][x] = group.addText({(x - 1) * xSize + 1, (y - 1) * ySize + 1}, "A", 0x57A64EFF, nScale * nTextScaler)
                tTexts[y][x].x = (x - 1) * xSize + 1
                tTexts[y][x].y = (y - 1) * ySize + 1
            end
        end
            tCursor = group.addGroup({0, 0})
            tCursor.cursor = tCursor.addText({1, 1}, "_", 0xF0F0F0FF, nScale * nTextScaler)
        if bFrameCursor then
            tCursor.lines = tCursor.addLines({1, 1}, {1, ySize + 1}, {xSize + 1, ySize + 1}, {xSize + 1, 1}, 0xF0F0F0FF, 1)
        end
        bBlink = true
        tText = {}
        tFront = {}
        tBack = {}
        tCursorMeta = {}
        for i in pairs(tHex) do
            tRGBA[tHex[i]] = bit.bor(bit.blshift(colors.packRGB(buffer.getPaletteColour(i)), 8), 0xFF)
        end
    end

    local function destroy()
        for y = 1, nHeight do
            for x = 1, nWidth do tBacks[y][x].remove() end
            for x = 1, nWidth do tTexts[y][x].remove() end
        end
        tFrame.remove()
        tCursor.remove()
    end

    local function redrawLine(nLine, bForce)
        local text, front, back = buffer.getLine(nLine)
        if bForce or tBack[nLine] ~= back then --dirty back
            local rowBack = tBacks[nLine]
            back:gsub("()(.)", function(x, c)
                if rowBack[x].color ~= tRGBA[c] then
                    rowBack[x].setColor(tRGBA[c])
                    rowBack[x].color = tRGBA[c]
                end
            end)
            tBack[nLine] = back
        end
        if bForce or tText[nLine] ~= text or tFront[nLine] ~= front then --dirty text
            local rowText = tTexts[nLine]
            front:gsub("()(.)", function(x, c)
                if rowText[x].color ~= tRGBA[c] then
                    rowText[x].setColor(tRGBA[c])
                    rowText[x].color = tRGBA[c]
                end
            end)
            text:gsub("()(.)", function(x, c)
                if rowText[x].text ~= c then
                    rowText[x].setText(c)
                    rowText[x].setPosition(rowText[x].x + (textOffsetX[c] or 0) * nTextScaler * nScale, rowText[x].y)
                    rowText[x].text = c
                end
            end)
            tText[nLine] = text
            tFront[nLine] = front
        end
    end

    local function redraw(bForce)
        for y = 1, nHeight do
            redrawLine(y, bForce)
        end
    end

    local function updateCursor()
        local cx, cy = buffer.getCursorPos()
        if tCursorMeta.x ~= cx or tCursorMeta.y ~= cy then
            bOnScreen = cx > 0 and cx <= nWidth and cy > 0 and cy <= nHeight
            tCursor.setPosition((cx - 1) * 4 * nScale, (cy - 1) * 6 * nScale)
            tCursorMeta.x, tCursorMeta.y = cx, cy
        end
        local cColor = tRGBA[tHex[buffer.getTextColor()]]
        if tCursorMeta.color ~= cColor then
            tCursor.cursor.setColor(cColor)
            tCursorMeta.color = cColor
        end
        local cBlink = buffer.getCursorBlink()
        if tCursorMeta.blink ~= cBlink or tCursorMeta.bOnScreen ~= bOnScreen then
            tCursor.cursor.setAlpha(bBlink and bOnScreen and cBlink and 0xFF or 0)
            tCursorMeta.blink = cBlink
            tCursorMeta.bOnScreen = bOnScreen
        end
    end

    local function updatePaletteColor(c)
        if tHex[c] then
            local col =  bit.bor(bit.blshift(colors.packRGB(buffer.getPaletteColour(c)), 8), 0xFF)
            if tRGBA[tHex[c]] ~= col then
                tRGBA[tHex[c]] = col
                return true
            end
        end
        return false
    end

    local function updatePalette()
        local changed = false
        for i in pairs(tHex) do
            local col = bit.bor(bit.blshift(colors.packRGB(buffer.getPaletteColour(i)), 8), 0xFF)
            if tRGBA[tHex[i]] ~= col then
                tRGBA[tHex[i]] = col
                changed = true
            end
        end
        return changed
    end

    local function blinker()
        if math.floor(os.epoch("utc") / 400) % 2 == 0 ~= bBlink then
            bBlink = not bBlink
            tCursor.cursor.setAlpha(bBlink and bOnScreen and buffer.getCursorBlink() and 0xFF or 0)
        end
    end


    local redrawDirtiers = {["clear"] = true, ["scroll"] = true }
    local redrawLineDirtiers = {["write"] = true, ["blit"] = true, ["clearLine"] = true }
    local cursorDirters = {["setCursorPos"] = true, ["setCursorBlink"] = true, ["setTextColor"] = true, ["setTextColour"] = true}
    local paletteDirters = {["setPaletteColor"] = true, ["setPaletteColour"] = true}

    local canvasTerm = {}

    for i, k in pairs(buffer) do
        if bDisableAutoRedraw then
            canvasTerm[i] = k
        elseif redrawDirtiers[i] then
            canvasTerm[i] = function(...)
                local returns = table.pack(k(...))
                if bVisible then redraw() updateCursor() end
                return table.unpack(returns, 1, returns.n)
            end
        elseif redrawLineDirtiers[i] then
            canvasTerm[i] = function(...)
                local returns = table.pack(k(...))
                if bVisible then redrawLine(select(2, buffer.getCursorPos())) updateCursor() end
                return table.unpack(returns, 1, returns.n)
            end
        elseif cursorDirters[i] then
            canvasTerm[i] = function(...)
                local returns = table.pack(k(...))
                if bVisible then updateCursor() end
                return table.unpack(returns, 1, returns.n)
            end
        elseif paletteDirters[i] then
            canvasTerm[i] = function(c, ...)
                local returns = table.pack(k(c, ...))
                local changed = updatePaletteColor(c)
                if bVisible then redraw(changed) updateCursor() end
                return table.unpack(returns, 1, returns.n)
            end
        else
            canvasTerm[i] = k
        end
    end

    canvasTerm.setVisible = function( b )
        expect(1, b, "boolean")
        if bVisible ~= b then
            bVisible = b
            if bVisible then
                build()
                redraw()
                updateCursor()
            else
                destroy()
            end
        end
    end

    if bDisableAutoRedraw then

        canvasTerm.flush = function()
            if bVisible then
                local changed = updatePalette()
                redraw(changed)
                updateCursor()
            end
        end

    end

    canvasTerm.loadLines = function(tWindow)
        expect(1, tWindow, "table")
        assert(tWindow.getLine, "Error. loadLones requires windows table with getLine supported")
        local _, inY = tWindow.getSize()
        local cX, xY = buffer.getCursorPos()
        for i in pairs(tHex) do
            buffer.setPaletteColour(i, tWindow.getPaletteColour(i))
        end
        for y = 1, math.min(nHeight, inY) do
            buffer.setCursorPos(1, y)
            buffer.blit(tWindow.getLine(y))
        end
        buffer.setCursorPos(cX, xY)
        if bVisible then
            local changed = updatePalette()
            redraw(changed)
            updateCursor()
        end
    end

    canvasTerm.blinker = function()
        if bVisible then
            blinker()
        end
    end

    canvasTerm.reposition = function( nNewX, nNewY, nNewWidth, nNewHeight, nNewScale, newParent )
        if nNewX ~= nil or nNewY ~= nil then
            expect(1, nNewX, "number")
            expect(2, nNewY, "number")
        end
        if nNewWidth ~= nil or nNewHeight ~= nil then
            expect(3, nNewWidth, "number")
            expect(4, nNewHeight, "number")
        end
        expect(5, nNewScale, "number", "nil")
        expect(6, newParent, "table", "nil")

        if bVisible then
            destroy()
        end

        nX = nNewX or nX
        nY = nNewY or nY
        nWidth = nNewWidth or nWidth
        nHeight = nNewHeight or nHeight
        nScale = nNewScale or nScale
        parent = newParent or parent

        group.remove()
        group = parent.addGroup({nX, nY})
        bufferResize(nWidth, nHeight)

        if bVisible then
            build()
            redraw()
            updateCursor()
        end
    end

    if bVisible then
        build()
        redraw()
        updateCursor()
    end

    return canvasTerm
end

--### Finalizing
return c