PAIN (computercraft)

--[[
    PAIN image editor for ComputerCraft
    Get it with
     wget https://raw.githubusercontent.com/LDDestroier/CC/master/pain.lua pain
     pastebin get wJQ7jav0 pain
     std ld pain pain
--]]

local plc = {} -- pain local, to avoid upvalue limit
plc.askToSerialize = false
plc.defaultSaveFormat = 4 -- will change if importing image, or making new file with extension in name
--[[
    plc.defaultSaveFormat possible parameters:
    1. NFP (paint)
    2. NFT (npaintpro)
    3. BLT (blittle)
    4. Native PAIN
    5. GIF
    6. UCG
--]]

plc.progname = fs.getName(shell.getRunningProgram())
plc.apipath = ".painapi"

local painconfig = {
    undoBufferSize = 8,         -- amount of times undo will save your neck
    readNonImageAsNFP = true,   -- reads non-image files as NFP images
    useFlattenGIF = true,       -- will flatten compressed GIFs
    gridBleedThrough = false,   -- will draw grid instead of character value of dots
    doFillDiagonal = false,     -- checks for diagonal dots when using fill tool
    doFillAnimation = false,    -- whether or not to animate the fill tool
    useSetVisible = false,      -- whether or not to use term.current().setVisible, if possible
}

local useConfig = function(mode)
    if mode == "save" then
        local file = fs.open(fs.combine(plc.apipath,"painconfig"), "w")
        file.write(textutils.serialize(painconfig))
        file.close()
    elseif mode == "load" then
        if fs.exists(fs.combine(plc.apipath,"painconfig")) then
            local file = fs.open(fs.combine(plc.apipath,"painconfig"), "r")
            painconfig = textutils.unserialize(file.readAll())
            file.close()
        end
    end
end

useConfig("load")
useConfig("save")

plc.displayHelp = function()
    print(plc.progname)
    print(plc.progname.." <filename>")
    print(plc.progname.." [-h/--help]")
    print("Press F1 in program for more.")
end

plc.tsv = function(visible)
    if term.current().setVisible and painconfig.useSetVisible then
        term.current().setVisible(visible)
    end
end

--local undoBuffer
plc.undoPos = 1
plc.pMode = 0
local scr_x, scr_y = term.getSize()
local screenEdges = {
    scr_x,
    scr_y,
}

plc.tArg = {...}
if (plc.tArg[1] == "--help" or plc.tArg[1] == "-h") and shell then
    return plc.displayHelp()
end

if plc.tArg[2] == "view" then
    plc.pMode = 1
elseif (plc.tArg[2] == "moo") and (not fs.exists("moo")) then
    return print("This PAIN does not have Super Cow Powers.")
end

-- plc.fileName
if (not term.isColor()) and (plc.pMode ~= 1) then
    error("PAIN only works with Advanced Computers.")
end

local barmsg = "Press F1 for help."
local paintEncoded
local lastPaintEncoded
local frame = 1
local doRender = false
local metaHistory = {}
local firstTerm, blittleTerm = term.current()
plc.bepimode = false      -- this is a family-friendly program! now stand still while I murder you
plc.evenDrawGrid = true   -- will you evenDraw(the)Grid ?
plc.renderBlittle = false -- whether or not to render all in blittle
plc.firstBG = term.getBackgroundColor()
plc.firstTX = term.getTextColor()
plc.changedImage = false
plc.isCurrentlyFilling = false
local theClipboard = {}

local _
local tableconcat = table.concat

local rendback = {
    b = colors.black,
    t = colors.gray,
}

local grid

local yield = function()
    os.queueEvent("yield")
    os.pullEvent("yield")
end

local paint = {
    scrollX = 0,
    scrollY = 0,
    t = colors.gray,
    b = colors.white,
    m = 1,  --  in case you want to use PAIN as a level editor or something
    c = " ",
    doGray = false,
}
local boxchar = {topLeft = true, topRight = true, left = true, right = true, bottomLeft = true, bottomRight = true}
local swapColors = false -- swaps background and text colors, for use with those tricky box characters
local scrollX, scrollY = 0, 0

local keysDown = {}
local miceDown = {}

local doRenderBar = 1 -- Not true or false

local fixstr = function(str)
    return str:gsub("\\(%d%d%d)",string.char)
end

local choice = function(input,breakkeys,returnNumber)
    local fpos = 0
    repeat
        event, key = os.pullEvent("key")
        if type(key) == "number" then key = keys.getName(key) end
        if key == nil then key = " " end
        if type(breakkeys) == "table" then
            for a = 1, #breakkeys do
                if key == breakkeys[a] then
                    return ""
                end
            end
        end
        fpos = string.find(input, key)
    until fpos
    return returnNumber and fpos or key
end
local explode = function(div,str)
    if (div=='') then return false end
    local pos,arr = 0,{}
    for st,sp in function() return string.find(str,div,pos,true) end do
        arr[#arr+1] = str:sub(pos,st-1)
        pos = sp + 1
    end
    arr[#arr+1] = str:sub(pos)
    return arr
end

local cutString = function(max_line_length, str) -- from stack overflow
   local lines = {}
   local line
   str:gsub('(%s*)(%S+)',
      function(spc, word)
         if not line or #line + #spc + #word > max_line_length then
            lines[#lines+1] = line
            line = word
         else
            line = line..spc..word
         end
      end
   )
   lines[#lines+1] = line
   return lines
end

local getDrawingCharacter = function(topLeft, topRight, left, right, bottomLeft, bottomRight) -- thank you oli414
  local data = 128
  if not bottomRight then
        data = data + (topLeft and 1 or 0)
        data = data + (topRight and 2 or 0)
        data = data + (left and 4 or 0)
        data = data + (right and 8 or 0)
        data = data + (bottomLeft and 16 or 0)
  else
        data = data + (topLeft and 0 or 1)
        data = data + (topRight and 0 or 2)
        data = data + (left and 0 or 4)
        data = data + (right and 0 or 8)
        data = data + (bottomLeft and 0 or 16)
  end
  return {char = string.char(data), inverted = bottomRight}
end

local cutUp = function(len,tbl)
    local output = {}
    local e = 0
    local s
    for a = 1, #tbl do
        if #(tbl[a]:gsub(" ","")) == 0 then
            s = {""}
        else
            s = cutString(len,tbl[a])
        end
        for b = 1, #s do
            output[#output+1] = s[b]
        end
    end
    return output
end

local getEvents = function(...)
    local arg, output = table.pack(...)
    while true do
        output = {os.pullEvent()}
        for a = 1, #arg do
            if type(arg[a]) == "boolean" then
                if doRender == arg[a] then
                    return {}
                end
            elseif output[1] == arg[a] then
                return table.unpack(output)
            end
        end
    end
end



local sanitize = function(sani,tize)
    local _,x = string.find(sani,tize)
    if x then
        return sani:sub(x+1)
    else
        return sani
    end
end
local ro = function(input, max)
    return math.floor(input % max)
end

local guiHelp = function(inputText)
    term.redirect(firstTerm)
    scr_x, scr_y = term.current().getSize()
    local _helpText = inputText or [[

'PAIN' super-verbose help page
  Programmed by LDDestroier

(use UP/DOWN or scrollwheel, exit with Q)
If you wish to use PAIN to its fullest, read everything here.
You'll be image-editing like a pro in no time flat.

Syntax:
>pain <filename> [view] [x] [y]
>pain [-n]
>pain [-h/--help]

[view]: renders the image once (optionally scrolling with [x] and [y])
"-n" or no arguments: Create new document, declare name upon saving
"-h" or "--help": Display short syntax help

You can see what colors are selected based on the word "PAIN" on the hotbar.

Hotkeys:
 left/right ctrl: Toggle the menu

 left click:
  +left shift = Drag and let go to draw a line
  -alone      = Place a dot

 Right Click: delete pixel

 Middle Click, or "T": Place text down with current colors; cancel with X

 "Z":
  +LeftAlt = Redo
  -alone   = Undo

 "P": Pick colors from position onscreen; cancel with X

 "N":
  +LeftShift = Change character to that of a special character
  -alone     = Change box character for drawing
  (cancel with CTRL, N, or by clicking outside)

 "[" or mouse scroll down:
  +LeftShift = Change to previous text color
  -alone     = Change to previous background color

 "]" or mouse scroll up:
  +LeftShift = Change to next text color
  -alone     = Change to next background color

 "F1":
  -alone = Access help screen

 "F3:"
  -alone = View all connected monitors

 Spacebar:
  +LeftShift = Toggle background grid
  -alone     = Toggle bar visibility

 Arrow keys:
  +LeftShift = Displaces the entire frame
  +Tab       = Moves canvas one pixel at a time
  -alone     = Looks around the canvas smoothly

 "+" (or equals):
  +LeftAlt    = Swap the current frame with the next frame
  +LeftShift  = Merge the current frame atop the next frame
  +RightShift = If you are making a new frame, duplicates the last frame
  -alone      = Change to next frame

 "-":
  +LeftAlt   = Swap the current frame with the previous frame
  +LeftShift = Merge the current frame atop the previous frame
  -alone     = Change to previous frame

 (oh good, you're actually reading this stuff)

 "A": Set the coordinates to 0,0

 "B": Toggle redirect to blittle, to preview in teletext characters

 "c":
  +LeftAlt = Select region to copy to specified clipboard
    -alone   = Input coordinates to scroll over to

 "LeftAlt + X": Select region to cut to specified clipboard

 "LeftAlt + X": Pastes from specified clipboard

 "G": toggle grayscale mode.
  Everything is in shades of gray.
  If you Save, it saves in grayscale.

 "F":
  +LeftShift = fill all empty pixels with background color and selected box character
  -alone     = activate fill tool - click anywhere to fill with color

 "M": set metadata for pixels (for game makers, otherwise please ignore)

==================================
 Thy Menu (accessible with CTRL):
==================================

 Left click on a menu item to select it.
 If you click on the menubar, release on an option to select it.

 "File > Save"
 Saves all frames to a specially formatted PAIN paint file. The format PAIN uses is very inefficient despite my best efforts, so Export if you don't use text or multiple frame.

 "File > Save As"
 Same as "File > Save", but you change the filename.

 "File > Export"
 Exports current frame to NFP, NFT, BLT, or the horribly inefficient PAIN format.

 "File > Open"
 Opens up a file picker for you to change the image currently being edited.

 "Edit > Delete Frame"
 Deletes the current frame. Tells you off if you try to delete the only frame.

 "Edit > Clear"
 Deletes all pixels on the current frame.

 "Edit > Crop Frame"
 Deletes all pixels that are outside of the screen.

 "Edit > Change Box Character"
 Opens the block character selection. Used for making those delicious subpixel pictures.

 "Edit > Change Special Character"
 Opens the special character selector, which lets you change the paint character to that of byte 0 to 255.

 "Edit > BLittle Shrink"
 Shrinks the current frame using the BLittle API. Very lossy unless you use one color, or are careful with how you use colors. You can set "Always Render Grid" to true to assist in making blocky graphics.

 "Edit > BLittle Grow"
 Grows the image by (2x, 3y) to reverse the effects of "BLittle Shrink". This isn't lossy, since all it does is inflate an image's size and converts the corresponding block characters.

 "Edit > Copy"
 Drag to select a region of the screen, and save it in a clipboard of a specified name.

 "Edit > Cut"
 Same as Copy, but will delete the selected region on the screen.

 "Edit > Paste"
 Takes the contents of the specified clipboard, and plops it on the canvas where the mouse is.
 (The mouse will indicate the top-left corner of the pasted selection)

 "Set > ..."
 Each option will toggle a config option (or set it's value to something else).
 Changing a value is saved automatically, and effective immediately.

 "Window > Set Screen Size"
 Sets the sizes of the screen border references displayed on the canvas.
 You can also input the name of a monitor object, and it will use its size instead.

 "Window > Set Grid Colors"
 Sets the backdrop colors to your currently selected color configuration.

 "About > PAIN"
 Tells you about PAIN and its developer.

 "About > File Formats"
 Tells you the ins and outs of the file formats, and a brief description of their creators.

 "About > Help"
 Opens up this help page.

 "Exit"
 Closes PAIN. I know, riviting stuff. You can close out of this help page with "Q", speaking of.


I hope my PAIN causes you joy.
]]
    _helpText = explode("\n",_helpText)
    helpText = cutUp(scr_x,_helpText)
    local helpscroll = 0
    term.setBackgroundColor(colors.gray)
    term.setTextColor(colors.white)
    term.clear()
    local evt, key
    while true do
        term.clear()
        for a = 1, scr_y do
            term.setCursorPos(1,a)
            term.clearLine()
            write(helpText[a-helpscroll] or "")
        end
        repeat
            evt,key = os.pullEvent()
        until evt == "key" or evt == "mouse_scroll"
        if evt == "key" then
            if key == keys.up then
                helpscroll = helpscroll + 1
            elseif key == keys.down then
                helpscroll = helpscroll - 1
            elseif key == keys.pageUp then
                helpscroll = helpscroll + scr_y
            elseif key == keys.pageDown then
                helpscroll = helpscroll - scr_y
            elseif (key == keys.q) or (key == keys.space) then
                doRender = true
                if plc.renderBlittle then term.redirect(blittleTerm) end
                scr_x, scr_y = term.current().getSize()
                return
            end
        elseif evt == "mouse_scroll" then
            helpscroll = helpscroll - key
        end
        if helpscroll > 0 then
            helpscroll = 0
        elseif helpscroll < -(#helpText-(scr_y-3)) then
            helpscroll = -(#helpText-(scr_y-3))
        end
    end
end

local tableRemfind = function(tbl, str)
    local out = tbl
    for a = 1, #tbl do
        if tbl[a] == str then
            table.remove(out,a)
            return out,a
        end
    end
    return {}
end

local stringShift = function(str,amt)
    return str:sub(ro(amt-1,#str)+1)..str:sub(1,ro(amt-1,#str))
end

local deepCopy
deepCopy = function(obj)
    if type(obj) ~= 'table' then return obj end
    local res = {}
    for k, v in pairs(obj) do res[deepCopy(k)] = deepCopy(v) end
    return res
end

local clearLines = function(y1, y2)
    local cx,cy = term.getCursorPos()
    for y = y1, y2 do
        term.setCursorPos(1,y)
        term.clearLine()
    end
    term.setCursorPos(cx,cy)
end

local renderBottomBar = function(txt,extraClearY)
    term.setCursorPos(1,scr_y - math.floor(#txt/scr_x))
    term.setBackgroundColor(colors.lightGray)
    term.setTextColor(colors.black)
    clearLines(scr_y - (math.floor(#txt/scr_x) - (extraClearY or 0)), scr_y)
    return write(txt)
end

local bottomPrompt = function(txt,history,cho,breakkeys,returnNumber,writeIndent)
    local writeIndent = renderBottomBar(txt,writeIndent)
    local out
    sleep(0)
    if cho then
        out = choice(cho,breakkeys,returnNumber)
    else
        out = read(_,history)
    end
    return out, writeIndent
end

local makeSubMenu = function(x,y,options)
    local longestLen = 0
    for a = 1, #options do
        if #options[a] > longestLen then
            longestLen = #options[a]
        end
    end
    longestLen = longestLen + 1
    term.setTextColor(colors.black)
    local sel = 1
    local rend = function()
        for a = #options, 1, -1 do
            term.setCursorPos(x or 1, ((y or (scr_y-1)) - (#options-1)) + (a - 1))
            term.setBackgroundColor(a == sel and colors.white or colors.lightGray)
            term.write(options[a])
            term.setBackgroundColor(colors.lightGray)
            term.write((" "):rep(longestLen-#options[a]))
        end
    end
    local usingMouse = false
    while true do
        rend()
        local evt, key, mx, my = os.pullEvent()
        if evt == "key" then
            if key == keys.up then
                sel = sel - 1
            elseif key == keys.down then
                sel = sel + 1
            elseif (key == keys.enter) or (key == keys.right) then
                return sel, longestLen
            elseif (key == keys.leftCtrl) or (key == keys.rightCtrl) or (key == keys.backspace) or (key == keys.left) then
                return false, longestLen
            end
        elseif evt == "mouse_drag" or evt == "mouse_click" then
            if (mx >= x) and (mx < x+longestLen) and (my <= y and my > y-#options) then
                sel = math.min(#options,math.max(1,(my+#options) - y))
                usingMouse = true
            else
                usingMouse = false
                if evt == "mouse_click" then
                    return false, longestLen
                end
            end
        elseif evt == "mouse_up" then
            if usingMouse then
                return sel, longestLen
            end
        end
        if sel > #options then sel = 1 elseif sel < 1 then sel = #options end
    end
end

local getDotsInLine = function( startX, startY, endX, endY ) -- stolen from the paintutils API...nwehehehe
    local out = {}
    startX = math.floor(startX)
    startY = math.floor(startY)
    endX = math.floor(endX)
    endY = math.floor(endY)
    if startX == endX and startY == endY then
        out = {{x=startX,y=startY}}
        return out
    end
    local minX = math.min( startX, endX )
    if minX == startX then
        minY = startY
        maxX = endX
        maxY = endY
    else
        minY = endY
        maxX = startX
        maxY = startY
    end
    local xDiff = maxX - minX
    local yDiff = maxY - minY
    if xDiff > math.abs(yDiff) then
        local y = minY
        local dy = yDiff / xDiff
        for x=minX,maxX do
            out[#out+1] = {x=x,y=math.floor(y+0.5)}
            y = y + dy
        end
    else
        local x = minX
        local dx = xDiff / yDiff
        if maxY >= minY then
            for y=minY,maxY do
                out[#out+1] = {x=math.floor(x+0.5),y=y}
                x = x + dx
            end
        else
            for y=minY,maxY,-1 do
                out[#out+1] = {x=math.floor(x+0.5),y=y}
                x = x - dx
            end
        end
    end
    return out
end

local movePaintEncoded = function(pe,xdiff,ydiff)
    local outpootis = deepCopy(pe)
    for a = 1, #outpootis do
        outpootis[a].x = outpootis[a].x+xdiff
        outpootis[a].y = outpootis[a].y+ydiff
    end
    return outpootis
end

local clearRedundant = function(dots)
    local input = {}
    local pheight = 0
    local pwidth = 0
    local minX, minY = 0, 0
    for a = 1, #dots do
        pheight = math.max(pheight, dots[a].y)
        pwidth = math.max(pwidth, dots[a].x)
        minX = math.min(minX, dots[a].x)
        minY = math.min(minY, dots[a].y)
    end
    for a = 1, #dots do
        if not input[dots[a].y] then input[dots[a].y] = {} end
        input[dots[a].y][dots[a].x] = dots[a]
    end
    local output = {}
    local frame = 0
    for y = minY, pheight do
        for x = minX, pwidth do
            if input[y] then
                if input[y][x] then
                    output[#output+1] = input[y][x]
                end
            end
            if frame >= 50 then
                -- yield()
                frame = 0
            end
        end
    end
    return output
end

local grayOut = function(color)
    local c = deepCopy(_G.colors)
    local grays = {
        [c.white] = c.white,
        [c.orange] = c.lightGray,
        [c.magenta] = c.lightGray,
        [c.lightBlue] = c.lightGray,
        [c.yellow] = c.white,
        [c.lime] = c.lightGray,
        [c.pink] = c.lightGray,
        [c.gray] = c.gray,
        [c.lightGray] = c.lightGray,
        [c.cyan] = c.lightGray,
        [c.purple] = c.gray,
        [c.blue] = c.gray,
        [c.brown] = c.gray,
        [c.green] = c.lightGray,
        [c.red] = c.gray,
        [c.black] = c.black,
    }
    if (not color) or (color == " ") then return color end
    local newColor = grays[color] or 1
    return newColor
end

local getOnscreenCoords = function(tbl,_x,_y)
    local screenTbl = {}
    for a = 1, #tbl do
        if tbl[a].x+paint.scrollX > 0 and tbl[a].x+paint.scrollX <= scr_x then
            if tbl[a].y+paint.scrollY > 0 and tbl[a].y+paint.scrollY <= scr_y then
                screenTbl[#screenTbl+1] = {tbl[a].x+paint.scrollX,tbl[a].y+paint.scrollY}
            end
        end
    end
    if not _x and _y then
        return screenTbl
    else
        for a = 1, #screenTbl do
            if screenTbl[a][1] == _x and screenTbl[a][2] == _y then
                return true
            end
        end
        return false
    end
end

local clearAllRedundant = function(info)
    local output = {}
    for a = 1, #info do
        output[a] = clearRedundant(info[a])
        if a % 4 == 0 then yield() end
    end
    return output
end

local saveFile = function(path,info)
    local output = clearAllRedundant(info)
    local fileout = textutils.serialize(output):gsub("  ",""):gsub("\n",""):gsub(" = ","="):gsub(",}","}"):gsub("}},{{","}},\n{{")
    if #fileout >= fs.getFreeSpace(fs.getDir(path)) then
        barmsg = "Not enough space."
        return
    end
    local file = fs.open(path,"w")
    file.write(fileout)
    file.close()
end
local renderBar = function(msg,dontSetVisible)
    if (doRenderBar == 0) or plc.renderBlittle then return end
    if not dontSetVisible then plc.tsv(false) end
    term.setCursorPos(1,scr_y)
    term.setBackgroundColor(colors.lightGray)
    term.setTextColor(colors.black)
    term.clearLine()
    term.setBackgroundColor(paint.b or rendback.b)
    term.setTextColor(paint.t or rendback.t)
    term.setCursorPos(2,scr_y)
    term.write("PAIN")
    term.setBackgroundColor(colors.lightGray)
    term.setTextColor(colors.black)
    local fmsg = tableconcat({"Fr:",frame,"/",#paintEncoded," (",paint.scrollX,",",paint.scrollY,")"})
    term.setCursorPos(7,scr_y)
    term.write(msg)
    term.setCursorPos(scr_x-(#fmsg),scr_y)
    term.write(fmsg)
    if not dontSetVisible then plc.tsv(true) end
end

local tableFormatPE = function(input)
    local doot = {}
    local pwidths = {}
    local pheight = 0
    for k, dot in pairs(input) do
        pwidths[dot.y] = math.max((pwidths[dot.y] or 0), dot.x)
        pheight = math.max(pheight, dot.y)
        doot[dot.y] = doot[dot.y] or {}
        doot[dot.y][dot.x] = {
            char = dot.c,
            text = CTB(dot.t),
            back = CTB(dot.b)
        }
    end
    for y = 1, pheight do
        pwidths[y] = pwidths[y] or 0
        if doot[y] then
            for x = 1, pwidths[y] do
                doot[y][x] = doot[y][x] or {
                    text = " ",
                    back = " ",
                    char = " ",
                }
            end
        else
            doot[y] = false
        end
    end
    return doot, pheight, pwidths
end

CTB = function(_color) --Color To Blit
    local blitcolors = {
        [0] = " ",
        [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",
    }
    if _color == nil then return nil end
    return blitcolors[_color] or "f"
end

BTC = function(_color,allowZero) --Blit To Color
    local blitcolors = {
        [" "] = allowZero and 0 or nil,
        ["0"] = colors.white,
        ["1"] = colors.orange,
        ["2"] = colors.magenta,
        ["3"] = colors.lightBlue,
        ["4"] = colors.yellow,
        ["5"] = colors.lime,
        ["6"] = colors.pink,
        ["7"] = colors.gray,
        ["8"] = colors.lightGray,
        ["9"] = colors.cyan,
        ["a"] = colors.purple,
        ["b"] = colors.blue,
        ["c"] = colors.brown,
        ["d"] = colors.green,
        ["e"] = colors.red,
        ["f"] = colors.black,
    }
    if _color == nil then return nil end
    return blitcolors[_color]
end

local renderPainyThings = function(xscroll,yscroll,doGrid)
    local yadjust = (plc.renderBlittle and 0 or doRenderBar)
    if plc.bepimode then
        grid = {
            "Bepis",
            "episB",
            "pisBe",
            "isBep",
            "sBepi",
        }
    else
        grid = {
            "%%..",
            "%%..",
            "%%..",
            "..%%",
            "..%%",
            "..%%",
        }
    end
    term.setBackgroundColor(rendback.b)
    term.setTextColor(rendback.t)
    local badchar = "/"
    local blittlelabel = "blittle max"
    local screenlabel = "screen max"

    local dotBuffChar, dotBuffBack = "", "" --only used if gridBleedThrough is true
    local doot
    if doGrid then
        for y = 1, scr_y - yadjust do
            term.setCursorPos(1,y)
            -- the single most convoluted line I've ever written that works, and I love it
            term.write(stringShift(grid[ro(y+(yscroll+2),#grid)+1],xscroll+1):rep(math.ceil(scr_x/#grid[ro(y+(yscroll+2),#grid)+1])):sub(1,scr_x))
            term.setCursorPos((xscroll <= 0) and (1-xscroll) or 0,y)
            if ((screenEdges[2]+1)-yscroll) == y then --regular limit
                term.write( (string.rep("@", math.max(0,( (screenEdges[1])     ) - (#screenlabel+1)  )) ..screenlabel:gsub(" ","@"):upper().."@@"):sub(xscroll>0 and xscroll or 0):sub(1,1+screenEdges[1]) )
            elseif (((screenEdges[2]*3)+1)-yscroll) == y then --blittle limit
                term.write( (string.rep("@", math.max(0,( ((screenEdges[1]*2))   ) - (#blittlelabel+1) ))..blittlelabel:gsub(" ","@"):upper().."@@"):sub(xscroll>0 and xscroll or 0):sub(1,1+screenEdges[1]*2) )
            end
            -- Stupid easter eggs, ho! --
            if 1000-yscroll == y then
                term.setCursorPos(1000-xscroll,y)
                term.write(" What ARE you doing? Stop messing around! ")
            end
            if 2016-yscroll == y then
                term.setCursorPos(200-xscroll,y)
                term.write(" Lines don't like to be intersected, you know. ")
            end
            if 2017-yscroll == y then
                term.setCursorPos(200-xscroll,y)
                term.write(" It makes them very crossed. ")
            end
            if 800-yscroll == y then
                term.setCursorPos(1700-xscroll,y)
                term.write(" You stare deeply into the void. ")
            end
            if 801-yscroll == y then
                term.setCursorPos(1704-xscroll,y)
                term.write(" And the void ")
            end
            if 802-yscroll == y then
                term.setCursorPos(1704-xscroll,y)
                term.write(" stares back. ")
            end
            --Is this the end?--
            if (xscroll > ((screenEdges[1]*2)-scr_x)) then
                for y = 1, scr_y do
                    if y+yscroll <= (screenEdges[2]*3) then
                        if not (y == scr_y and doRenderBar == 1) then
                            term.setCursorPos((screenEdges[1]+1)-(xscroll-screenEdges[1]),y)
                            term.write("@")
                        end
                    end
                end
            end
            if (xscroll > (screenEdges[1]-scr_x)) then --regular limit
                for y = 1, scr_y do
                    if y+yscroll <= screenEdges[2] then
                        if not (y == scr_y and doRenderBar == 1) then
                            term.setCursorPos((screenEdges[1]+1)-xscroll,y)
                            term.write("@")
                        end
                    end
                end
            end
        end
        --render areas that won't save
        if xscroll < 0 then
            for y = 1, scr_y do
                if not (y == scr_y and doRenderBar == 1) then
                    term.setCursorPos(1,y)
                    term.write(badchar:rep(-xscroll))
                end
            end
        end
        if yscroll < 0 then
            for y = 1, -yscroll do
                if not (y == scr_y and doRenderBar == 1) then
                    term.setCursorPos(1,y)
                    term.write(badchar:rep(scr_x))
                end
            end
        end
    else
        for y = 1, scr_y - yadjust do
            term.setCursorPos(1,y)
            term.clearLine()
        end
    end
end

importFromPaint = function(theInput)
    local output = {}
    local input
    if type(theInput) == "string" then
        input = explode("\n",theInput)
    else
        input = {}
        for y = 1, #theInput do
            input[y] = ""
            for x = 1, #theInput[y] do
                input[y] = input[y]..(CTB(theInput[y][x]) or " ")
            end
        end
    end
    for a = 1, #input do
        line = input[a]
        for b = 1, #line do
            if (line:sub(b,b) ~= " ") and BTC(line:sub(b,b)) then
                output[#output+1] = {
                    x = b,
                    y = a,
                    t = colors.white,
                    b = BTC(line:sub(b,b)) or colors.black,
                    c = " ",
                }
            end
        end
    end
    return output
end

local lddfm = {
    scroll = 0,
    ypaths = {}
}

lddfm.scr_x, lddfm.scr_y = term.getSize()

lddfm.setPalate = function(_p)
    if type(_p) ~= "table" then
        _p = {}
    end
    lddfm.p = { --the DEFAULT color palate
        bg =        _p.bg or colors.gray,           -- whole background color
        d_txt =     _p.d_txt or colors.yellow,      -- directory text color
        d_bg =      _p.d_bg or colors.gray,         -- directory bg color
        f_txt =     _p.f_txt or colors.white,       -- file text color
        f_bg =      _p.f_bg or colors.gray,         -- file bg color
        p_txt =     _p.p_txt or colors.black,       -- path text color
        p_bg =      _p.p_bg or colors.lightGray,    -- path bg color
        close_txt = _p.close_txt or colors.gray,    -- close button text color
        close_bg =  _p.close_bg or colors.lightGray,-- close button bg color
        scr =       _p.scr or colors.lightGray,     -- scrollbar color
        scrbar =    _p.scrbar or colors.gray,       -- scroll tab color
    }
end

lddfm.setPalate()

lddfm.foldersOnTop = function(floop,path)
    local output = {}
    for a = 1, #floop do
        if fs.isDir(fs.combine(path,floop[a])) then
            table.insert(output,1,floop[a])
        else
            table.insert(output,floop[a])
        end
    end
    return output
end

lddfm.filterFileFolders = function(list,path,_noFiles,_noFolders,_noCD,_doHidden)
    local output = {}
    for a = 1, #list do
        local entry = fs.combine(path,list[a])
        if fs.isDir(entry) then
            if entry == ".." then
                if not (_noCD or _noFolders) then table.insert(output,list[a]) end
            else
                if not ((not _doHidden) and list[a]:sub(1,1) == ".") then
                    if not _noFolders then table.insert(output,list[a]) end
                end
            end
        else
            if not ((not _doHidden) and list[a]:sub(1,1) == ".") then
                if not _noFiles then table.insert(output,list[a]) end
            end
        end
    end
    return output
end

lddfm.isColor = function(col)
    for k,v in pairs(colors) do
        if v == col then
            return true, k
        end
    end
    return false
end

lddfm.clearLine = function(x1,x2,_y,_bg,_char)
    local cbg, bg = term.getBackgroundColor()
    local x,y = term.getCursorPos()
    local sx,sy = term.getSize()
    if type(_char) == "string" then char = _char else char = " " end
    if type(_bg) == "number" then
        if lddfm.isColor(_bg) then bg = _bg
        else bg = cbg end
    else bg = cbg end
    term.setCursorPos(x1 or 1, _y or y)
    term.setBackgroundColor(bg)
    if x2 then --it pains me to add an if statement to something as simple as this
        term.write((char or " "):rep(x2-x1))
    else
        term.write((char or " "):rep(sx-(x1 or 0)))
    end
    term.setBackgroundColor(cbg)
    term.setCursorPos(x,y)
end

lddfm.render = function(_x1,_y1,_x2,_y2,_rlist,_path,_rscroll,_canClose,_scrbarY)
    local px,py = term.getCursorPos()
    plc.tsv(false)
    local x1, x2, y1, y2 = _x1 or 1, _x2 or lddfm.scr_x, _y1 or 1, _y2 or lddfm.scr_y
    local rlist = _rlist or {"Invalid directory."}
    local path = _path or "And that's terrible."
    ypaths = {}
    local rscroll = _rscroll or 0
    for a = y1, y2 do
        lddfm.clearLine(x1,x2,a,lddfm.p.bg)
    end
    term.setCursorPos(x1,y1)
    term.setTextColor(lddfm.p.p_txt)
    lddfm.clearLine(x1,x2+1,y1,lddfm.p.p_bg)
    term.setBackgroundColor(lddfm.p.p_bg)
    term.write(("/"..path):sub(1,x2-x1))
    for a = 1,(y2-y1) do
        if rlist[a+rscroll] then
            term.setCursorPos(x1,a+(y1))
            if fs.isDir(fs.combine(path,rlist[a+rscroll])) then
                lddfm.clearLine(x1,x2,a+(y1),lddfm.p.d_bg)
                term.setTextColor(lddfm.p.d_txt)
                term.setBackgroundColor(lddfm.p.d_bg)
            else
                lddfm.clearLine(x1,x2,a+(y1),lddfm.p.f_bg)
                term.setTextColor(lddfm.p.f_txt)
                term.setBackgroundColor(lddfm.p.f_bg)
            end
            term.write(rlist[a+rscroll]:sub(1,x2-x1))
            ypaths[a+(y1)] = rlist[a+rscroll]
        else
            lddfm.clearLine(x1,x2,a+(y1),lddfm.p.bg)
        end
    end
    local scrbarY = _scrbarY or math.ceil( (y1+1)+( (_rscroll/(#_rlist-(y2-(y1+1))))*(y2-(y1+1)) ) )
    for a = y1+1, y2 do
        term.setCursorPos(x2,a)
        if a == scrbarY then
            term.setBackgroundColor(lddfm.p.scrbar)
        else
            term.setBackgroundColor(lddfm.p.scr)
        end
        term.write(" ")
    end
    if _canClose then
        term.setCursorPos(x2-4,y1)
        term.setTextColor(lddfm.p.close_txt)
        term.setBackgroundColor(lddfm.p.close_bg)
        term.write("close")
    end
    term.setCursorPos(px,py)
    plc.tsv(true)
    return scrbarY
end

lddfm.coolOutro = function(x1,y1,x2,y2,_bg,_txt,char)
    local cx, cy = term.getCursorPos()
    local bg, txt = term.getBackgroundColor(), term.getTextColor()
    term.setTextColor(_txt or colors.white)
    term.setBackgroundColor(_bg or colors.black)
    local _uwah = 0
    for y = y1, y2 do
        for x = x1, x2 do
            _uwah = _uwah + 1
            term.setCursorPos(x,y)
            term.write(char or " ")
            if _uwah >= math.ceil((x2-x1)*1.63) then sleep(0) _uwah = 0 end
        end
    end
    term.setTextColor(txt)
    term.setBackgroundColor(bg)
    term.setCursorPos(cx,cy)
end

lddfm.scrollMenu = function(amount,list,y1,y2)
    if #list >= y2-y1 then
        lddfm.scroll = lddfm.scroll + amount
        if lddfm.scroll < 0 then
            lddfm.scroll = 0
        end
        if lddfm.scroll > #list-(y2-y1) then
            lddfm.scroll = #list-(y2-y1)
        end
    end
end

lddfm.makeMenu = function(_x1,_y1,_x2,_y2,_path,_noFiles,_noFolders,_noCD,_noSelectFolders,_doHidden,_p,_canClose)
    if _noFiles and _noFolders then
        return false, "C'mon, man..."
    end
    if _x1 == true then
        return false, "arguments: x1, y1, x2, y2, path, noFiles, noFolders, noCD, noSelectFolders, doHidden, palate, canClose" -- a little help
    end
    lddfm.setPalate(_p)
    local path, list = _path or ""
    lddfm.scroll = 0
    local _pbg, _ptxt = term.getBackgroundColor(), term.getTextColor()
    local x1, x2, y1, y2 = _x1 or 1, _x2 or lddfm.scr_x, _y1 or 1, _y2 or lddfm.scr_y
    local keysDown = {}
    local _barrY
    while true do
        list = lddfm.foldersOnTop(lddfm.filterFileFolders(fs.list(path),path,_noFiles,_noFolders,_noCD,_doHidden),path)
        if (fs.getDir(path) ~= "..") and not (_noCD or _noFolders) then
            table.insert(list,1,"..")
        end
        _res, _barrY = pcall( function() return lddfm.render(x1,y1,x2,y2,list,path,lddfm.scroll,_canClose) end)
        if not _res then
            plc.tsv(true)
            error(_barrY)
        end
        local evt = {os.pullEvent()}
        if evt[1] == "mouse_scroll" then
            lddfm.scrollMenu(evt[2],list,y1,y2)
        elseif evt[1] == "mouse_click" then
            local butt,mx,my = evt[2],evt[3],evt[4]
            if (butt == 1 and my == y1 and mx <= x2 and mx >= x2-4) and _canClose then
                --lddfm.coolOutro(x1,y1,x2,y2)
                term.setTextColor(_ptxt) term.setBackgroundColor(_pbg)
                return false
            elseif ypaths[my] and (mx >= x1 and mx < x2) then --x2 is reserved for the scrollbar, breh
                if fs.isDir(fs.combine(path,ypaths[my])) then
                    if _noCD or butt == 3 then
                        if not _noSelectFolders or _noFolders then
                            --lddfm.coolOutro(x1,y1,x2,y2)
                            term.setTextColor(_ptxt) term.setBackgroundColor(_pbg)
                            return fs.combine(path,ypaths[my])
                        end
                    else
                        path = fs.combine(path,ypaths[my])
                        lddfm.scroll = 0
                    end
                else
                    term.setTextColor(_ptxt) term.setBackgroundColor(_pbg)
                    return fs.combine(path,ypaths[my])
                end
            end
        elseif evt[1] == "key" then
            keysDown[evt[2]] = true
            if evt[2] == keys.enter and not (_noFolders or _noCD or _noSelectFolders) then --the logic for _noCD being you'd normally need to go back a directory to select the current directory.
                --lddfm.coolOutro(x1,y1,x2,y2)
                term.setTextColor(_ptxt) term.setBackgroundColor(_pbg)
                return path
            end
            if evt[2] == keys.up then
                lddfm.scrollMenu(-1,list,y1,y2)
            elseif evt[2] == keys.down then
                lddfm.scrollMenu(1,list,y1,y2)
            end
            if evt[2] == keys.pageUp then
                lddfm.scrollMenu(y1-y2,list,y1,y2)
            elseif evt[2] == keys.pageDown then
                lddfm.scrollMenu(y2-y1,list,y1,y2)
            end
            if evt[2] == keys.home then
                lddfm.scroll = 0
            elseif evt[2] == keys["end"] then
                if #list > (y2-y1) then
                    lddfm.scroll = #list-(y2-y1)
                end
            end
            if evt[2] == keys.h then
                if keysDown[keys.leftCtrl] or keysDown[keys.rightCtrl] then
                    _doHidden = not _doHidden
                end
            elseif _canClose and (evt[2] == keys.x or evt[2] == keys.q or evt[2] == keys.leftCtrl) then
                --lddfm.coolOutro(x1,y1,x2,y2)
                term.setTextColor(_ptxt) term.setBackgroundColor(_pbg)
                return false
            end
        elseif evt[1] == "key_up" then
            keysDown[evt[2]] = false
        end
    end
end

local getBlittle = function()
    if not blittle then
        if fs.exists(fs.combine(plc.apipath,"blittle")) then
            os.loadAPI(fs.combine(plc.apipath,"blittle"))
            if not blittleTerm then
                blittleTerm = blittle.createWindow()
            end
            return blittleTerm, firstTerm
        else
            local geet = http.get("http://pastebin.com/raw/ujchRSnU")
            if not geet then
                return false
            else
                geet = geet.readAll()
                local file = fs.open(fs.combine(plc.apipath,"blittle"),"w")
                file.write(geet)
                file.close()
                os.loadAPI(fs.combine(plc.apipath,"blittle"))
                --fs.delete(plc.apipath)
                if not blittleTerm then
                    blittleTerm = blittle.createWindow()
                end
                return blittleTerm, firstTerm
            end
        end
    else
        if not blittleTerm then
            blittleTerm = blittle.createWindow()
        end
        return blittleTerm, firstTerm
    end
end

local getUCG = function()
    if not ucg then
        if fs.exists(fs.combine(plc.apipath,"ucg")) then
            os.loadAPI(fs.combine(plc.apipath,"ucg"))
            return true
        else
            local geet = http.get("https://raw.githubusercontent.com/ardera/libucg/master/src/libucg")
            if not geet then
                return false
            else
                geet = geet.readAll()
                local file = fs.open(fs.combine(plc.apipath,"ucg"),"w")
                file.write(geet)
                file.close()
                os.loadAPI(fs.combine(plc.apipath,"ucg"))
            end
        end
    end
end

local getBBPack = function()
    if not bbpack then
        if fs.exists(fs.combine(plc.apipath,"bbpack")) then
            os.loadAPI(fs.combine(plc.apipath,"bbpack"))
            return true
        else
            local geet = http.get("https://pastebin.com/raw/cUYTGbpb")
            if not geet then
                return false
            else
                geet = geet.readAll()
                local file = fs.open(fs.combine(plc.apipath,"bbpack"),"w")
                file.write(geet)
                file.close()
                os.loadAPI(fs.combine(plc.apipath,"bbpack"))
            end
        end
    end
end

local getGIF = function()
    getBBPack()
    if not GIF then
        if fs.exists(fs.combine(plc.apipath,"GIF")) then
            os.loadAPI(fs.combine(plc.apipath,"GIF"))
            return true
        else
            local geet = http.get("https://pastebin.com/raw/5uk9uRjC")
            if not geet then
                return false
            else
                geet = geet.readAll()
                local file = fs.open(fs.combine(plc.apipath,"GIF"),"w")
                file.write(geet)
                file.close()
                os.loadAPI(fs.combine(plc.apipath,"GIF"))
            end
        end
    end
end

local NFPserializeImage = function(str)
    local bepis = explode("\n",str)
    local output = {}
    for y = 1, #bepis do
        output[y] = {}
        for x = 1, #bepis[y] do
            output[y][x] = BTC(bepis[y]:sub(x,x),true)
        end
    end
    return textutils.unserialize(textutils.serialize(output):gsub("\n",""):gsub(" ",""):gsub(",}","}"))
end

local importFromGIF = function(filename,verbose)
    getGIF()
    local output = {}
    local image
    local rawGif = GIF.loadGIF(filename)
    if painconfig.useFlattenGIF then
        if verbose then
            print("Flattening...")
        end
        rawGif = GIF.flattenGIF(rawGif)
        sleep(0)
    end
    local cx, cy = term.getCursorPos()
    for a = 1, #rawGif do
        output[a] = importFromPaint(GIF.toPaintutils(rawGif[a]))
        if verbose then
            term.setCursorPos(cx,cy)
            write("Did "..a.."/"..#rawGif.." ")
        end
        if a % 1 then sleep(0) end --used to be a % 2, might change later
    end
    return output
end

local exportToPaint

local exportToGIF = function(input)
    getGIF()
    local outGIF = {}
    for a = 1, #paintEncoded do
        outGIF[a] = NFPserializeImage(exportToPaint(paintEncoded[a]))
        sleep(0)
    end
    if painconfig.useFlattenGIF then
        return GIF.flattenGIF(GIF.buildGIF(table.unpack(outGIF)),true)
    else
        return GIF.buildGIF(table.unpack(outGIF))
    end
end

local importFromUCG = function(filename)
    getUCG()
    return importFromPaint(ucg.readFile(filename))
end

local exportToUCG = function(filename, input)
    getUCG()
    ucg.writeFile(filename, NFPserializeImage(exportToPaint(input)))
end

renderPAIN = function(dots,xscroll,yscroll,doPain,dontRenderBar)
    plc.tsv(false)
    local beforeTX,beforeBG = term.getTextColor(), term.getBackgroundColor()
    local cx,cy = term.getCursorPos()
    local FUCK, SHIT = pcall(function()
            if doPain then
                if (not plc.renderBlittle) then
                    if not dontRenderBar then
                        renderBar(barmsg,true)
                    end
                    renderPainyThings(xscroll,yscroll,plc.evenDrawGrid)
                else
                    term.clear()
                end
            end
            for a = 1, #dots do
                local d = dots[a]
                if doPain then
                    if not ((d.y-yscroll >= 1 and d.y-yscroll <= scr_y-(plc.renderBlittle and 0 or doRenderBar)) and (d.x-xscroll >= 1 and d.x-xscroll <= scr_x)) then
                        d = nil
                    end
                end
                if d then
                    term.setCursorPos(d.x-(xscroll or 0),d.y-(yscroll or 0))
                    term.setBackgroundColor((paint.doGray and grayOut(d.b) or d.b) or rendback.b)
                    if painconfig.gridBleedThrough then
                        term.setTextColor(rendback.t)
                        term.write((d.x >= 1 and d.y >= 1) and grid[ ro( d.y+2, #grid)+1]:sub(1+ro(d.x+-1,#grid[1]), 1+ro(d.x+-1,#grid[1])) or "/")
                    else
                        term.setTextColor(      (paint.doGray and grayOut(d.t) or d.t) or rendback.t)
                        term.write(d.c or " ")
                    end
                end
            end
    end)
    term.setBackgroundColor(beforeBG or rendback.b)
    term.setTextColor(beforeTX or rendback.t)
    term.setCursorPos(cx,cy)
    plc.tsv(true)
    if not FUCK then error(SHIT) end --GOD DAMN IT
end

renderPAINFS = function(filename,xscroll,yscroll,frameNo,doPain)
    local file = fs.open(filename,"r")
    local contents = file.readAll()
    local amntFrames
    file.close()
    local tcontents = textutils.unserialize(contents)
    if type(tcontents) ~= "table" then
        tcontents = importFromPaint(contents)
    else
        amntFrames = #tcontents
        tcontents = tcontents[frameNo or 1]
    end
    renderPAIN(tcontents,xscroll,yscroll,doPain)
    return amntFrames
end

local putDotDown = function(dot) -- only 'x' and 'y' are required arguments
    paintEncoded[frame][#paintEncoded[frame]+1] = {
        x = dot.x + paint.scrollX,
        y = dot.y + paint.scrollY,
        c = dot.c or paint.c,
        b = dot.b or (swapColors and paint.t or paint.b),
        t = dot.t or (swapColors and paint.b or paint.t),
        m = dot.m or paint.m,
    }
end

local saveToUndoBuffer = function()
    if plc.undoPos < #plc.undoBuffer then
        for a = #plc.undoBuffer, plc.undoPos + 1, -1 do
            table.remove(plc.undoBuffer, a)
        end
    end
    if plc.undoPos >= painconfig.undoBufferSize then
        for a = 2, #plc.undoBuffer do
            plc.undoBuffer[a - 1] = plc.undoBuffer[a]
        end
        plc.undoBuffer[#plc.undoBuffer] = deepCopy(paintEncoded)
    else
        plc.undoPos = plc.undoPos + 1
        plc.undoBuffer[plc.undoPos] = deepCopy(paintEncoded)
    end
end

local doUndo = function()
    plc.undoPos = math.max(1, plc.undoPos - 1)
    paintEncoded = deepCopy(plc.undoBuffer[plc.undoPos])
    if not paintEncoded[frame] then
        frame = #paintEncoded
    end
end

local doRedo = function()
    plc.undoPos = math.min(#plc.undoBuffer, plc.undoPos + 1)
    paintEncoded = deepCopy(plc.undoBuffer[plc.undoPos])
    if not paintEncoded[frame] then
        frame = #paintEncoded
    end
end

local putDownText = function(x,y)
    term.setCursorPos(x,y)
    term.setTextColor((paint.doGray and grayOut(paint.t or rendback.t)) or (paint.t or rendback.t))
    term.setBackgroundColor((paint.doGray and grayOut(paint.b or rendback.b)) or (paint.b or rendback.b))
    local msg = read()
    if #msg > 0 then
        for a = 1, #msg do
            putDotDown({x=(x+a)-1, y=y, c=msg:sub(a,a)})
        end
    end
    saveToUndoBuffer()
end

local deleteDot = function(x,y) --deletes all dots at point x,y
    local good = false
    for a = #paintEncoded[frame],1,-1 do
        local b = paintEncoded[frame][a]
        if (x == b.x) and (y == b.y) then
            table.remove(paintEncoded[frame],a)
            good = true
        end
    end
    return good
end

exportToPaint = function(input,noTransparent) --exports paintEncoded frame to regular paint format. input is expected to be paintEncoded[frame]
    local doopTXT, doopTXCOL, doopBGCOL = {}, {}, {}
    local p = input
    local pheight = 0
    local pwidth = 0
    for a = 1, #p do
        if p[a].y > pheight then
            pheight = p[a].y
        end
        if p[a].x > pwidth then
            pwidth = p[a].x
        end
    end
    for k,v in pairs(p) do
        if not doopBGCOL[v.y] then
            doopBGCOL[v.y] = {}
            doopTXCOL[v.y] = {}
            doopTXT[v.y] = {}
        end
        doopBGCOL[v.y][v.x] = CTB(v.b)
        doopTXCOL[v.y][v.x] = CTB(v.t)
        doopTXT[v.y][v.x] = v.c
    end
    local nfpoutputTXT, nfpoutputTXCOL, nfpoutputBGCOL = "", "", ""
    for y = 1, pheight do
        if doopBGCOL[y] then
            for x = 1, pwidth do
                if doopBGCOL[y][x] then
                    nfpoutputBGCOL = nfpoutputBGCOL..doopBGCOL[y][x]
                    nfpoutputTXCOL = nfpoutputTXCOL..doopTXCOL[y][x]
                    nfpoutputTXT = nfpoutputTXT..(((doopTXT[y][x] == " " and noTransparent) and "\128" or doopTXT[y][x]) or " ")
                else
                    nfpoutputBGCOL = nfpoutputBGCOL..(noTransparent and "0" or " ")
                    nfpoutputTXCOL = nfpoutputTXCOL..(noTransparent and "0" or " ")
                    nfpoutputTXT = nfpoutputTXT.." "
                end
            end
        end
        if y ~= pheight then
            nfpoutputBGCOL = nfpoutputBGCOL.."\n"
            nfpoutputTXCOL = nfpoutputTXCOL.."\n"
            nfpoutputTXT = nfpoutputTXT.."\n"
        end
    end
    return nfpoutputBGCOL, pheight, pwidth
end

local exportToNFT = function(input)

    local bgcode, txcode = "\30", "\31"
    local output = ""
    local text, back

    local doot, pheight, pwidths = tableFormatPE(input)

    for y = 1, pheight do

        text, back = "0", "f"
        if doot[y] then
            for x = 1, pwidths[y] do

                if doot[y][x] then
                    if doot[y][x].back ~= back then
                        back = doot[y][x].back
                        output = output .. bgcode .. back
                    end
                    if doot[y][x].text ~= text then
                        text = doot[y][x].text
                        output = output .. txcode .. text
                    end
                    output = output .. doot[y][x].char
                else
                    output = output .. " "
                end

            end
        end

        if y < pheight then
            output = output .. "\n"
        end
    end
    return output
end

local importFromNFT = function(input) --imports NFT formatted string image to paintEncoded[frame] formatted table image. please return a paintEncoded[frame] formatted table.
    local tinput = explode("\n",input)
    local tcol,bcol
    local cx --represents the x position in the picture
    local sx --represents the x position in the file
    local output = {}
    for y = 1, #tinput do
        tcol,bcol = colors.white,colors.black
        cx, sx = 1, 0
        while sx < #tinput[y] do
            sx = sx + 1
            if tinput[y]:sub(sx,sx) == "\30" then
                bcol = BTC(tinput[y]:sub(sx+1,sx+1))
                sx = sx + 1
            elseif tinput[y]:sub(sx,sx) == "\31" then
                tcol = BTC(tinput[y]:sub(sx+1,sx+1))
                sx = sx + 1
            else
                if tcol and bcol then
                    output[#output+1] = {
                        ["x"] = cx,
                        ["y"] = y,
                        ["b"] = bcol,
                        ["t"] = tcol,
                        ["c"] = tinput[y]:sub(sx,sx),
                        ["m"] = 0,
                    }
                end
                cx = cx + 1
            end
        end
    end
    return output
end

exportToBLT = function(input,filename,doAllFrames,noSave)
    local output = {}
    local thisImage,pheight,pwidth,nfpinput
    getBlittle()
    for a = doAllFrames and 1 or frame, doAllFrames and #input or frame do
        output[#output+1] = blittle.shrink(NFPserializeImage(exportToPaint(input[a]),true),colors.black)
    end
    if #output == 1 then output = output[1] end
    if not noSave then
        blittle.save(output,filename)
    end
    return output
end

importFromBLT = function(input) --takes in filename, not contents
    local output = {}
    getBlittle()
    local wholePic = blittle.load(input)
    if wholePic.height then wholePic = {wholePic} end
    local image
    for a = 1, #wholePic do
        image = wholePic[a]
        output[#output+1] = {}
        for y = 1, image.height*3 do
            for x = 1, math.max(#image[1][math.ceil(y/3)],#image[2][math.ceil(y/3)],#image[3][math.ceil(y/3)])*2 do
                output[#output][#output[#output]+1] = {
                    m = 0,
                    x = x,
                    y = y,
                    t = BTC((image[2][math.ceil(y/3)]:sub(math.ceil(x/2),math.ceil(x/2)).."0"):sub(1,1)),
                    b = BTC((image[3][math.ceil(y/3)]:sub(math.ceil(x/2),math.ceil(x/2)).."0"):sub(1,1)),
                    c = BTC((image[1][math.ceil(y/3)]:sub(math.ceil(x/2),math.ceil(x/2)).." "):sub(1,1)),
                }
            end
        end
    end
    return output
end

local getTheDoots = function(pe)
    local hasBadDots = false
    local baddestX,baddestY = 1,1
    for b = 1, #pe do
        local doot = pe[b]
        if doot.x <= 0 or doot.y <= 0 then
            hasBadDots = true
            if doot.x < baddestX then
                baddestX = doot.x
            end
            if doot.y < baddestY then
                baddestY = doot.y
            end
        end
        if b % 64 == 0 then yield() end
    end
    return baddestX, baddestY
end

local checkBadDots = function()
    local hasBadDots = false
    for a = 1, #paintEncoded do
        local radx,rady = getTheDoots(paintEncoded[a])
        if radx ~= 1 or rady ~= 1 then
            hasBadDots = true
        end
    end
    if hasBadDots then
        local ting = bottomPrompt("Dot(s) are OoB! Save or fix? (Y/N/F)",_,"ynf",{keys.leftCtrl,keys.rightCtrl})
        if ting == "f" then
            for a = 1, #paintEncoded do
                local baddestX, baddestY = getTheDoots(paintEncoded[a])
                paintEncoded[a] = movePaintEncoded(paintEncoded[a],-(baddestX-1),-(baddestY-1))
            end
        elseif ting ~= "y" then
            barmsg = ""
            return false
        end
    end
end

local convertToGrayscale = function(pe)
    local output = pe
    for a = 1, #pe do
        for b = 1, #pe[a] do
            output[a][b].b = grayOut(pe[a][b].b)
            output[a][b].t = grayOut(pe[a][b].t)
            if not output[a][b].m then output[a][b].m = 1 end
        end
        if a % 2 == 0 then yield() end
    end
    return output
end

local reRenderPAIN = function(overrideRenderBar)
    local _reallyDoRenderBar = doRenderBar
--  doRenderBar = 1
    renderPAIN(paintEncoded[frame],paint.scrollX,paint.scrollY,true,overrideRenderBar)
    doRenderBar = _reallyDoRenderBar
end

local fillTool = function(_frame,cx,cy,dot,isDeleting) -- "_frame" is the frame NUMBER
    local maxX, maxY = 1, 1
    local minX, minY = 1, 1
    paintEncoded = clearAllRedundant(paintEncoded)
    local frame = paintEncoded[_frame]
    local scx, scy = cx+paint.scrollX, cy+paint.scrollY
    local output = {}
    for a = 1, #frame do
        maxX = math.max(maxX, frame[a].x)
        maxY = math.max(maxY, frame[a].y)
        minX = math.min(minX, frame[a].x)
        minY = math.min(minY, frame[a].y)
    end

    maxX = math.max(maxX, scx)
    maxY = math.max(maxY, scy)
    minX = math.min(minX, scx)
    minY = math.min(minY, scy)

    maxX = math.max(maxX, screenEdges[1])
    maxY = math.max(maxY, screenEdges[2])

    local doop = {}
    local touched = {}
    local check = {[scy] = {[scx] = true}}
    for y = minY, maxY do
        doop[y] = {}
        touched[y] = {}
        for x = minX, maxX do
            doop[y][x] = {
                c = " ",
                b = 0,
                t = 0
            }
            touched[y][x] = false
        end
    end
    for a = 1, #frame do
        doop[frame[a].y][frame[a].x] = {
            c = frame[a].c,
            t = frame[a].t,
            b = frame[a].b
        }
    end
    local initDot = {
        c = doop[scy][scx].c,
        t = doop[scy][scx].t,
        b = doop[scy][scx].b
    }
    local chkpos = function(x, y, checkList)
        if (x < minX or x > maxX) or (y < minY or y > maxY) then
            return false
        else
            if (doop[y][x].b ~= initDot.b) or (doop[y][x].t ~= initDot.t and doop[y][x].c ~= " ") or (doop[y][x].c ~= initDot.c) then
                return false
            end
            if check[y] then
                if check[y][x] then
                    return false
                end
            end
            if touched[y][x] then
                return false
            end
            return true
        end
    end
    local doBreak
    local step = 0
    local currentlyOnScreen
    while true do
        doBreak = true
        for chY, v in pairs(check) do
            for chX, isTrue in pairs(v) do
                currentlyOnScreen = (chX-paint.scrollX >= 1 and chX-paint.scrollX <= scr_x and chY-paint.scrollY >= 1 and chY-paint.scrollY <= scr_y)
                if isTrue and (not touched[chY][chX]) then
                    step = step + 1
                    if painconfig.doFillAnimation then
                        if currentlyOnScreen then
                            reRenderPAIN(true)
                        end
                    end
                    if isDeleting then
                        deleteDot(chX, chY)
                    else
                        frame[#frame+1] = {
                            x = chX,
                            y = chY,
                            c = dot.c,
                            t = dot.t,
                            b = dot.b
                        }
                    end
                    touched[chY][chX] = true
                    -- check adjacent
                    if chkpos(chX+1, chY) then
                        check[chY][chX+1] = true
                        doBreak = false
                    end
                    if chkpos(chX-1, chY) then
                        check[chY][chX-1] = true
                        doBreak = false
                    end
                    if chkpos(chX, chY+1) then
                        check[chY+1] = check[chY+1] or {}
                        check[chY+1][chX] = true
                        doBreak = false
                    end
                    if chkpos(chX, chY-1) then
                        check[chY-1] = check[chY-1] or {}
                        check[chY-1][chX] = true
                        doBreak = false
                    end
                    -- check diagonal
                    if painconfig.doFillDiagonal then
                        if chkpos(chX-1, chY-1) then
                            check[chY-1] = check[chY-1] or {}
                            check[chY-1][chX-1] = true
                            doBreak = false
                        end
                        if chkpos(chX+1, chY-1) then
                            check[chY-1] = check[chY-1] or {}
                            check[chY-1][chX+1] = true
                            doBreak = false
                        end
                        if chkpos(chX-1, chY+1) then
                            check[chY+1] = check[chY+1] or {}
                            check[chY+1][chX-1] = true
                            doBreak = false
                        end
                        if chkpos(chX+1, chY+1) then
                            check[chY+1] = check[chY+1] or {}
                            check[chY+1][chX+1] = true
                            doBreak = false
                        end
                    end
                    if step % ((painconfig.doFillAnimation and currentlyOnScreen) and 4 or 1024) == 0 then -- tries to prevent crash
                        sleep(0)
                    end
                end
            end
        end
        if doBreak then
            break
        end
    end
    paintEncoded = clearAllRedundant(paintEncoded)
end

local boxCharSelector = function()
    local co = function(pos)
        if pos then
            term.setTextColor(colors.lime)
            term.setBackgroundColor(colors.green)
        else
            term.setTextColor(colors.lightGray)
            term.setBackgroundColor(colors.gray)
        end
    end
    local rend = function()
        term.setCursorPos(1,scr_y)
        term.setBackgroundColor(colors.lightGray)
        term.setTextColor(colors.black)
        term.clearLine()
        term.write("Press CTRL or 'N' when ready.")
        term.setCursorPos(1,scr_y-3) co(boxchar.topLeft) write("Q") co(boxchar.topRight) write("W")
        term.setCursorPos(1,scr_y-2) co(boxchar.left) write("A") co(boxchar.right) write("S")
        term.setCursorPos(1,scr_y-1) co(boxchar.bottomLeft) write("Z") co(boxchar.bottomRight) write("X")
    end
    while true do
        rend()
        local evt = {os.pullEvent()}
        if evt[1] == "key" then
            local key = evt[2]
            if key == keys.leftCtrl or key == keys.rightCtrl or key == keys.n then
                break
            else
                if key == keys.q then boxchar.topLeft = not boxchar.topLeft end
                if key == keys.w then boxchar.topRight = not boxchar.topRight end
                if key == keys.a then boxchar.left = not boxchar.left end
                if key == keys.s then boxchar.right = not boxchar.right end
                if key == keys.z then boxchar.bottomLeft = not boxchar.bottomLeft end
                if key == keys.x then boxchar.bottomRight = not boxchar.bottomRight end
            end
        elseif evt[1] == "mouse_click" or evt[1] == "mouse_drag" then
            local button, mx, my = evt[2], evt[3], evt[4]
            if my >= scr_y-2 then
                if mx == 1 then
                    if my == scr_y - 3 then boxchar.topLeft = not boxchar.topLeft end
                    if my == scr_y - 2 then boxchar.left = not boxchar.left end
                    if my == scr_y - 1 then boxchar.bottomLeft = not boxchar.bottomLeft end
                elseif mx == 2 then
                    if my == scr_y - 3 then boxchar.topRight = not boxchar.topRight end
                    if my == scr_y - 2 then boxchar.right = not boxchar.right end
                    if my == scr_y - 1 then boxchar.bottomRight = not boxchar.bottomRight end
                elseif evt[1] == "mouse_click" then
                    break
                end
            elseif evt[1] == "mouse_click" then
                break
            end
        end
    end
    if boxchar.topLeft and boxchar.topRight and boxchar.left and boxchar.right and boxchar.bottomLeft and boxchar.bottomRight then
        swapColors = false
        return " "
    else
        local output = getDrawingCharacter(boxchar.topLeft, boxchar.topRight, boxchar.left, boxchar.right, boxchar.bottomLeft, boxchar.bottomRight)
        swapColors = not output.inverted
        return output.char
    end
end

local specialCharSelector = function()
    local chars = {}
    local buff = 0
    for y = 1, 16 do
        for x = 1, 16 do
            chars[y] = chars[y] or {}
            chars[y][x] = string.char(buff)
                        buff = buff + 1
        end
    end
    local sy = scr_y - (#chars + 1)
    local char = paint.c
    local render = function()
        for y = 1, #chars do
            for x = 1, #chars do
                term.setCursorPos(x,y+sy)
                if chars[y][x] == char then
                    term.blit(chars[y][x], "5", "d")
                else
                    term.blit(chars[y][x], "8", "7")
                end
            end
        end
    end
    local evt, butt, x, y
    render()

    term.setCursorPos(1,scr_y)
    term.setBackgroundColor(colors.lightGray)
    term.setTextColor(colors.black)
    term.clearLine()
    term.write("Press CTRL or 'N' when ready.")

    while true do
        evt, butt, x, y = os.pullEvent()
        if (evt == "mouse_click" or evt == "mouse_drag") then
            if chars[y-sy] then
                if chars[y-sy][x] then
                    if (chars[y-sy][x] ~= char) then
                        char = chars[y-sy][x]
                        render()
                    end
                else
                    return char
                end
            else
                return char
            end
        elseif evt == "key" then
            if (butt == keys.n) or (butt == keys.leftCtrl) then
                return char
            end
        end
    end
end

local dontDragThisTime = false
local resetInputState = function()
    miceDown = {}
    keysDown = {}
    isDragging = false
    dontDragThisTime = true
end

local gotoCoords = function()
    local newX = bottomPrompt("Goto X:")
    newX = tonumber(newX)
    local newY
        if newX then
        newY = bottomPrompt("Goto Y:")
        newY = tonumber(newY)
        paint.scrollX = newX or paint.scrollX
        paint.scrollY = newY or paint.scrollY
    end
end

local renderAllPAIN = function()
    renderPAIN(paintEncoded[frame],paint.scrollX,paint.scrollY,true)
end

local checkIfNFP = function(str) --does not check table format, only string format
    local good = {
        ['0'] = true,
        ['1'] = true,
        ['2'] = true,
        ['3'] = true,
        ['4'] = true,
        ['5'] = true,
        ['6'] = true,
        ['7'] = true,
        ['8'] = true,
        ['9'] = true,
        a = true,
        b = true,
        c = true,
        d = true,
        e = true,
        f = true,
        [" "] = true,
        ["\n"] = true
    }
    for a = 1, #str do
        if not good[str:sub(a,a):lower()] then
            return false
        end
    end
    return true
end

local selectRegion = function()
    local mevt, id, x1, y1 = os.pullEvent("mouse_click")
    local x2, y2, pos, redrawID
    local renderRectangle = true
    redrawID = os.startTimer(0.5)
    while true do
        mevt, id, x2, y2 = os.pullEvent()
        if mevt == "mouse_up" or mevt == "mouse_drag" or mevt == "mouse_click" then
            pos = {{
                    x1 < x2 and x1 or x2,
                    y1 < y2 and y1 or y2
                },{
                    x1 < x2 and x2 or x1,
                    y1 < y2 and y2 or y1
            }}
        end
        if mevt == "mouse_up" then
            break
        end
        if (mevt == "mouse_drag") or (mevt == "timer" and id == redrawID) then
            renderAllPAIN()
            if renderRectangle then
                term.setTextColor(rendback.t)
                term.setBackgroundColor(rendback.b)
                for y = pos[1][2], pos[2][2] do
                    if y ~= scr_y then
                        term.setCursorPos(pos[1][1], y)
                        if (y == pos[1][2] or y == pos[2][2]) then
                            term.write(("#"):rep(1 + pos[2][1] - pos[1][1]))
                        else
                            term.write("#")
                            term.setCursorPos(pos[2][1], y)
                            term.write("#")
                        end
                    end
                end
            end
        end
        if (mevt == "timer" and id == redrawID) then
            renderRectangle = not renderRectangle
            redrawID = os.startTimer(0.25)
        end
    end
    local output = {}
    pos[1][1] = pos[1][1] + paint.scrollX
    pos[2][1] = pos[2][1] + paint.scrollX
    pos[1][2] = pos[1][2] + paint.scrollY
    pos[2][2] = pos[2][2] + paint.scrollY
    for k,v in pairs(paintEncoded[frame]) do
        if v.x >= pos[1][1] and v.x <= pos[2][1] then
            if v.y >= pos[1][2] and v.y <= pos[2][2] then
                output[#output+1] = {
                    x = v.x - pos[1][1],
                    y = v.y - pos[1][2],
                    t = v.t,
                    c = v.c,
                    b = v.b,
                    m = v.m
                }
            end
        end
    end
    return output, pos[1][1], pos[1][2], pos[2][1], pos[2][2]
end

local openNewFile = function(fname, allowNonImageNFP)
    local file = fs.open(fname,"r")
    local contents = file.readAll()
    file.close()
    if type(textutils.unserialize(contents)) ~= "table" then
        term.setTextColor(colors.white)
        if contents:sub(1,3) == "BLT" then --thank you bomb bloke for this easy identifier
            if plc.pMode ~= 1 then print("Importing from BLT...") end
            return importFromBLT(fname), 3
        elseif contents:sub(1,3) == "GIF" then
            if plc.pMode ~= 1 then print("Importing from GIF, this'll take a while...") end
            return importFromGIF(fname,true), 5
        elseif contents:sub(1,4) == "?!7\2" then
            if plc.pMode ~= 1 then print("Importing from UCG...") end
            return {importFromUCG(fname)}, 6
        elseif contents:find(string.char(30)) and contents:find(string.char(31)) then
            if plc.pMode ~= 1 then print("Importing from NFT...") end
            return {importFromNFT(contents)}, 2
        elseif (checkIfNFP(contents) or allowNonImageNFP) then
            print("Importing from NFP...")
            return {importFromPaint(contents)}, 1
        else
            return false, "That is not a valid image file."
        end
    else
        return textutils.unserialize(contents), 4
    end
end

local editFuncs = {
    copy = function()
        local board = bottomPrompt("Copy to board: ")
        renderAllPAIN()
        renderBottomBar("Select region to copy.")
        local selectedDots = selectRegion()
        theClipboard[board] = selectedDots
        barmsg = "Copied to '"..board.."'"
        doRender = true
        keysDown = {}
        miceDown = {}
    end,
    cut = function()
        local board = bottomPrompt("Cut to board: ")
        renderAllPAIN()
        renderBottomBar("Select region to cut.")
        local selectedDots, x1, y1, x2, y2 = selectRegion()
        theClipboard[board] = selectedDots
        local dot
        for i = #paintEncoded[frame], 1, -1 do
            dot = paintEncoded[frame][i]
            if dot.x >= x1 and dot.x <= x2 then
                if dot.y >= y1 and dot.y <= y2 then
                    table.remove(paintEncoded[frame], i)
                end
            end
        end
        barmsg = "Cut to '"..board.."'"
        doRender = true
        saveToUndoBuffer()
        keysDown = {}
        miceDown = {}
    end,
    paste = function()
        local board = bottomPrompt("Paste from board: ")
        renderAllPAIN()
        renderBottomBar("Click to paste. (top left corner)")
        if theClipboard[board] then
            local mevt
            repeat
                mevt = {os.pullEvent()}
            until (mevt[1] == "key" and mevt[2] == keys.x) or (mevt[1] == "mouse_click" and mevt[2] == 1 and (mevt[4] or scr_y) <= scr_y-1)
            for k,v in pairs(theClipboard[board]) do
                paintEncoded[frame][#paintEncoded[frame]+1] = {
                    x = v.x + paint.scrollX + (mevt[3]),
                    y = v.y + paint.scrollY + (mevt[4]),
                    c = v.c,
                    t = v.t,
                    b = v.b,
                    m = v.m
                }
            end
            paintEncoded[frame] = clearRedundant(paintEncoded[frame])
            barmsg = "Pasted from '"..board.."'"
            doRender = true
            saveToUndoBuffer()
            keysDown = {}
            miceDown = {}
        else
            barmsg = "No such clipboard."
            doRender = true
        end
    end
}

local blockEnlargeFrame = function(frameNo)

    local frame = deepCopy(paintEncoded[frameNo])
    local charConvert = {
        ["\129"] = {{true , false},{false, false},{false, false}},
        ["\130"] = {{false, true },{false, false},{false, false}},
        ["\131"] = {{true , true },{false, false},{false, false}},
        ["\132"] = {{false, false},{true , false},{false, false}},
        ["\133"] = {{true , false},{true , false},{false, false}},
        ["\134"] = {{false, true },{true , false},{false, false}},
        ["\135"] = {{true , true },{true , false},{false, false}},
        ["\136"] = {{false, false},{false, true },{false, false}},
        ["\137"] = {{true , false},{false, true },{false, false}},
        ["\138"] = {{false, true },{false, true },{false, false}},
        ["\139"] = {{true , true },{false, true },{false, false}},
        ["\140"] = {{false, false},{true , true },{false, false}},
        ["\141"] = {{true , false},{true , true },{false, false}},
        ["\142"] = {{false, true },{true , true },{false, false}},
        ["\143"] = {{true , true },{true , true },{false, false}},
        ["\144"] = {{false, false},{false, false},{true , false}},
        ["\145"] = {{true , false},{false, false},{true , false}},
        ["\146"] = {{false, true },{false, false},{true , false}},
        ["\147"] = {{true , true },{false, false},{true , false}},
        ["\148"] = {{false, false},{true , false},{true , false}},
        ["\149"] = {{true , false},{true , false},{true , false}},
        ["\150"] = {{false, true },{true , false},{true , false}},
        ["\151"] = {{true , true },{true , false},{true , false}},
        ["\152"] = {{false, false},{false, true },{true , false}},
        ["\153"] = {{true , false},{false, true },{true , false}},
        ["\154"] = {{false, true },{false, true },{true , false}},
        ["\155"] = {{true , true },{false, true },{true , false}},
        ["\156"] = {{false, false},{true , true },{true , false}},
        ["\157"] = {{true , false},{true , true },{true , false}},
        ["\158"] = {{false, true },{true , true },{true , false}},
        ["\159"] = {{true , true },{true , true },{true , false}},
    }
    local output, b = {}
    for k, dot in pairs(frame) do
        b = charConvert[dot.c] or {{false, false},{false, false},{false, false}}
        for y = 1, #b do
            for x = 1, #b[y] do
                output[#output+1] = {
                    x = (dot.x - 1) * 2 + (x - 0),
                    y = (dot.y - 1) * 3 + (y - 0),
                    c = " ",
--                  t = b[y][x] and dot.t or dot.b,
--                  b = b[y][x] and dot.b or dot.t
                    t = b[y][x] and dot.b or dot.t,
                    b = b[y][x] and dot.t or dot.b
                }
            end
        end
    end
    barmsg = "Grew image."

    return output
end

local displayMenu = function()
    doRender = false
    menuOptions = {"File","Edit","Window","Set","About","Exit"}
    local diss = " "..tableconcat(menuOptions," ")
    local cleary = scr_y-math.floor(#diss/scr_x)

    local fileSave = function()
        checkBadDots()
        local output = deepCopy(paintEncoded)
        if paint.doGray then
            output = convertToGrayscale(output)
        end
        if not plc.fileName then
            renderBottomBar("Save as: ")
            local fnguess = read()
            if fs.isReadOnly(fnguess) then
                barmsg = "'"..fnguess.."' is read only."
                return false
            elseif fnguess:gsub(" ","") == "" then
                return false
            elseif fs.isDir(fnguess) then
                barmsg = "'"..fnguess.."' is already a directory."
                return false
            elseif #fnguess > 255 then
                barmsg = "Filename is too long."
                return false
            else
                plc.fileName = fnguess
            end
        end
        saveFile(plc.fileName,output)
        term.setCursorPos(9,scr_y)
        return plc.fileName
    end
    local filePrint = function()
        local usedDots, dot = {}, {}
        for a = 1, #paintEncoded[frame] do
            dot = paintEncoded[frame][a]
            if dot.x > paint.scrollX and dot.x < (paint.scrollX + 25) and dot.y > paint.scrollX and dot.y < (paint.scrollY + 21) then
                if dot.c ~= " " then
                    usedDots[dot.t] = usedDots[dot.t] or {}
                    usedDots[dot.t][#usedDots[dot.t]+1] = {
                        x = dot.x - paint.scrollX,
                        y = dot.y - paint.scrollY,
                        char = dot.c
                    }
                end
            end
        end
        local dyes = {
            [1] = "bonemeal",
            [2] = "orange dye",
            [4] = "magenta dye",
            [8] = "light blue dye",
            [16] = "dandelion yellow",
            [32] = "lime dye",
            [64] = "pink dye",
            [128] = "gray dye",
            [256] = "light gray dye",
            [512] = "cyan dye",
            [1024] = "purple dye",
            [2048] = "lapis lazuli",
            [4096] = "cocoa beans",
            [8192] = "cactus green",
            [16384] = "rose red",
            [32768] = "ink sac",
        }
        local printer = peripheral.find("printer")
        if not printer then
            barmsg = "No printer found."
            return false
        end
        local page
        for color, dotList in pairs(usedDots) do
            term.setBackgroundColor(colors.black)
            term.setTextColor((color == colors.black) and colors.gray or color)
            term.clear()
            cwrite("Please insert "..dyes[color].." into the printer.", nil, math.floor(scr_y/2))
            term.setTextColor(colors.lightGray)
            cwrite("Then, press spacebar.", nil, math.floor(scr_y/2) + 1)
            local evt
            sleep(0)
            repeat
                evt = {os.pullEvent("key")}
            until evt[2] == keys.space
            page = page or printer.newPage()
            if not page then
                barmsg = "Check ink/paper."
                return
            end
            for k,v in pairs(usedDots[color]) do
                printer.setCursorPos(v.x, v.y)
                printer.write(v.char)
            end
        end
        printer.endPage()
        barmsg = "Printed."
    end
    local fileExport = function(menuX,getRightToIt,_fileName)
        local exportMode
        if not tonumber(getRightToIt) then
            exportMode = makeSubMenu(menuX or 8,scr_y-2,{"Paint","NFT","BLT","PAIN Native","GIF","UCG"})
        else
            exportMode = getRightToIt
        end
        if exportMode == false then return false end
        local pe, exportName, writeIndent, result
        if exportMode == 4 then
            local exNm = fileSave()
            if exNm then
                plc.changedImage = false
                return exNm
            else
                return nil
            end
        else
            checkBadDots()
            if _fileName then
                exportName, writeIndent = _fileName, #_fileName
            else
                exportName, writeIndent = bottomPrompt("Export to: /")
            end
            nfpoutput = ""
            if fs.combine("",exportName) == "" then
                barmsg = "Export cancelled."
                return
            end
            if fs.isReadOnly(exportName) then
                barmsg = "That's read-only."
                return
            end
            if fs.exists(exportName) and (not _fileName) then
                local plea = (plc.progname == fs.combine("",exportName)) and "Overwrite ORIGINAL file!?" or "Overwrite?"
                result, _wIn = bottomPrompt(plea.." (Y/N)",_,"yn",{keys.leftCtrl,keys.rightCtrl})
                writeIndent = writeIndent + _wIn
                if result ~= "y" then return end
            end
            local output
            pe = deepCopy(paintEncoded)
            if paint.doGray then
                pe = convertToGrayscale(pe)
            end
            local doSerializeBLT = false
        end
        if exportMode == 1 then
            output = exportToPaint(pe[frame])
            if plc.askToSerialize then
                result, _wIn = bottomPrompt("Save as serialized? (Y/N)",_,"yn",{})
                writeIndent = writeIndent + _wIn
            else result, _wIn = "n", 0 end
            if result == "y" then
                output = textutils.serialize(NFPserializeImage(output)):gsub(" ",""):gsub("\n",""):gsub(",}","}")
            end
        elseif exportMode == 2 then
            output = exportToNFT(pe[frame])
        elseif exportMode == 3 then
            local doAllFrames, _wIn = bottomPrompt("Save all frames, or current? (Y/N)",_,"yn",{keys.leftCtrl,keys.rightCtrl},writeIndent)
            writeIndent = writeIndent + _wIn
            if plc.askToSerialize then
                doSerializeBLT = bottomPrompt("Save as serialized? (Y/N)",_,"yn",{},writeIndent) == "y"
            end
            output = textutils.serialise(exportToBLT(pe,exportName,doAllFrames == "y",doSerializeBLT))
        elseif exportMode == 5 then
            getGIF()
            GIF.saveGIF(exportToGIF(pe),exportName)
        elseif exportMode == 6 then
            exportToUCG(exportName,pe[frame])
        end
        if ((exportMode ~= 3) and (exportMode ~= 4) and (exportMode ~= 5) and (exportMode ~= 6)) or doSerializeBLT then
            local file = fs.open(exportName,"w")
            file.write(output)
            file.close()
        end
        return exportName
    end

    local editClear = function(ignorePrompt)
        local outcum = ignorePrompt and "y" or bottomPrompt("Clear the frame? (Y/N)",_,"yn",{keys.leftCtrl,keys.rightCtrl})
        if outcum == "y" then
            paintEncoded[frame] = {}
            saveToUndoBuffer()
            barmsg = "Cleared frame "..frame.."."
        end
    end

    local editDelFrame = function()
        local outcum = bottomPrompt("Thou art sure? (Y/N)",_,"yn",{keys.leftCtrl,keys.rightCtrl})
        if outcum == "y" then
            if #paintEncoded == 1 then
                return editClear(true)
            end
            table.remove(paintEncoded,frame)
            barmsg = "Deleted frame "..frame.."."
            if paintEncoded[frame-1] then
                frame = frame - 1
            else
                frame = frame + 1
            end
            if #paintEncoded < frame then
                repeat
                    frame = frame - 1
                until #paintEncoded >= frame
            end
            saveToUndoBuffer()
        end
    end
    local editCrop = function()
        local outcum = bottomPrompt("Crop all but visible? (Y/N)",_,"yn",{keys.leftCtrl,keys.rightCtrl})
        if outcum == "y" then
            local ppos = 1
            local deletedAmnt = 0
            for a = #paintEncoded[frame], 1, -1 do
                local x, y = paintEncoded[frame][a].x, paintEncoded[frame][a].y
                if (x <= paint.scrollX) or (x > paint.scrollX + scr_x) or (y <= paint.scrollY) or (y > paint.scrollY + scr_y) then
                    table.remove(paintEncoded[frame],a)
                    deletedAmnt = deletedAmnt + 1
                else
                    ppos = ppos + 1
                end
                if ppos > #paintEncoded[frame] then break end
            end
            saveToUndoBuffer()
            barmsg = "Cropped frame."
        end
    end
    local editBoxCharSelector = function()
        paint.c = boxCharSelector()
    end
    local editSpecialCharSelector = function()
        paint.c = specialCharSelector()
    end

    local windowSetScrSize = function()
        local x,y
        x = bottomPrompt("Scr.X OR monitor name:",{},nil,{keys.leftCtrl,keys.rightCtrl})
        if x == "" then
            return
        elseif x == "pocket" then
            screenEdges = {26,20}
        elseif x == "turtle" then
            screenEdges = {39,13}
        elseif x == "computer" then
            screenEdges = {51,19}
        elseif tonumber(x) then
            if tonumber(x) <= 0 then
                barmsg = "Screen X must be greater than 0."
                return
            end
            screenEdges[1] = math.abs(tonumber(x))
            y = bottomPrompt("Scr.Y:",{},nil,{keys.leftCtrl,keys.rightCtrl})
            if tonumber(y) then
                if tonumber(y) <= 0 then
                    barmsg = "Screen Y must be greater than 0."
                    return
                end
                screenEdges[2] = math.abs(tonumber(y))
            end
            barmsg = "Screen size changed."
        else
            local mon = peripheral.wrap(x)
            if not mon then
                barmsg = "No such monitor."
                return
            else
                if peripheral.getType(x) ~= "monitor" then
                    barmsg = "That's not a monitor."
                    return
                else
                    screenEdges[1], screenEdges[2] = mon.getSize()
                    barmsg = "Screen size changed."
                    return
                end
            end
        end
    end
    local aboutPAIN = function()
        local helpText = [[

      
         
       
           
         

Advanced Paint Program
 by LDDestroier
 or EldidiStroyrr
  if you please!

PAIN is a multi-frame paint program with the intention of becoming a stable, well-used, and mondo-useful CC drawing utility.

The main focus during development is to add many functions that you might see in real programs like MSPAINT, such as lines or a proper fill tool, as well as to export/import to and from as many image formats as possible.

My ultimate goal is to have PAIN be the default paint program for most every operating system on the forums (for what it's worth). In order to do this, I'll need to make sure that PAIN is stable, easy to use, and can be easily limited by an OS to work with more menial tasks like making a single icon or what have you.

I hope my PAIN brings you joy.
]]
        guiHelp(helpText)
    end
    local aboutFileFormats = function()
        local helpText = [[
Here's info on the file formats.

 "NFP":
Used in rom/programs/paint, and the format for paintutils. It's a handy format, but the default rendering function is inefficient as hell, and it does not store text data, only background.
Cannot save multiple frames.

 "NFT":
Used in npaintpro and most everything else, it's my favorite of the file formats because it does what NFP does, but allows for text in the pictures. Useful for storing screenshots or small icons where an added level of detail is handy. Created by nitrogenfingers, thank him.
Cannot save multiple frames.

 "BLT":
Used exclusively with Bomb Bloke's BLittle API, and as such is handy with making pictures with block characters. Just keep in mind that those 2*3 grid squares in PAIN represent individual characters in BLT.
BLT can save multiple frames!

 "PAIN Native":
The basic, tabular, and wholly inefficient format that PAIN uses. Useful for doing math within the program, not so much for long term file storage. It stores text, but just use NFT if you don't need multiple frames.
Obviously, this can save multiple frames.

 "GIF":
The API was made by Bomb Bloke, huge thanks for that, but GIF is a universal file format used in real paint programs. Very useful for converting files on your computer to something like NFP, but doesn't store text. Be careful when opening up big GIF files, they can take a long time to load.
Being GIF, this saves multiple frames!

 "UCG":
Stands for Universal Compressed Graphics. This format was made by ardera, and uses Huffman Code and run-length encoding in order to reduce file sizes tremendously. However, it only saves backgrounds and not text data.
Cannot save multiple frames.


I recommend using NFT if you don't need multiple frames, NFP if you don't need text, UCG if the picture is really big, Native PAIN if you need both text and multiframe support, and GIF if you want to use something like MS Paint or Pinta or GIMP or whatever.
]]
        guiHelp(helpText)
    end
    local menuPoses = {}
    local menuFunctions = {
        [1] = function() --File
            while true do
                local output, longestLen = makeSubMenu(1,cleary-1,{
                    "Save",
                    "Save As",
                    "Export",
                    "Open",
                    ((peripheral.find("printer")) and "Print" or nil)
                })
                if output == 1 then -- Save
                    local _fname = fileExport(_,plc.defaultSaveFormat,plc.fileName)
                    if _fname then
                        barmsg = "Saved as '".._fname.."'"
                        lastPaintEncoded = deepCopy(paintEncoded)
                        plc.changedImage = false
                    end
                    break
                elseif output == 2 then -- Save As
                    local oldfilename = plc.fileName
                    plc.fileName = nil
                    local res = fileExport(_,plc.defaultSaveFormat)
                    if not res then
                        plc.fileName = oldfilename
                    else
                        barmsg = "Saved as '"..plc.fileName.."'"
                    end
                    break
                elseif output == 3 then --Export
                    local res = fileExport(longestLen+1)
                    if res then
                        barmsg = "Exported as '"..res.."'"
                    end
                    break
                elseif output == 4 then -- Open
                    renderBottomBar("Pick an image file.")
                    local newPath = lddfm.makeMenu(2, 2, scr_x-1, scr_y-2, fs.getDir(plc.fileName or plc.progname), false, false, false, true, false, nil, true)
                    if newPath then
                        local pen, form = openNewFile(newPath, painconfig.readNonImageAsNFP)
                        if not pen then
                            barmsg = form
                        else
                            plc.fileName = newPath
                            paintEncoded, lastPaintEncoded = pen, deepCopy(pen)
                            plc.defaultSaveFormat = form
                            plc.undoPos = 1
                            plc.undoBuffer = {deepCopy(paintEncoded)}
                            barmsg = "Opened '" .. fs.getName(newPath) .. "'"
                            paint.scrollX, paint.scrollY, paint.doGray = 1, 1, false
                        end
                    end
                    break
                elseif output == 5 then -- Print
                    filePrint()
                    break
                elseif output == false then
                    return "nobreak"
                end
                reRenderPAIN(true)
            end
        end,
        [2] = function() --Edit
            local output = makeSubMenu(6,cleary-1,{
                "Delete Frame",
                "Clear Frame",
                "Crop Frame",
                "Choose Box Character",
                "Choose Special Character",
                "BLittle Shrink",
                "BLittle Grow",
                "Copy Region",
                "Cut Region",
                "Paste Region"
            })
            if output == 1 then
                editDelFrame()
            elseif output == 2 then
                editClear()
            elseif output == 3 then
                editCrop()
            elseif output == 4 then
                editBoxCharSelector()
            elseif output == 5 then
                editSpecialCharSelector()
            elseif output == 6 then
                local res = bottomPrompt("You sure? It's lossy! (Y/N)",_,"yn",{keys.leftCtrl,keys.rightCtrl})
                if res == "y" then
                    getBlittle()
                    local bltPE = blittle.shrink(NFPserializeImage(exportToPaint(paintEncoded[frame])))
                    _G.SHRINKOUT = bltPE
                    paintEncoded[frame] = {}
                    for y = 1, bltPE.height do
                        for x = 1, bltPE.width do
                            paintEncoded[frame][#paintEncoded[frame]+1] = {
                                c = bltPE[1][y]:sub(x,x),
                                t = BTC(bltPE[2][y]:sub(x,x),true),
                                b = BTC(bltPE[3][y]:sub(x,x),true),
                                x = x,
                                y = y,
                            }
                        end
                    end
                    saveToUndoBuffer()
                    barmsg = "Shrunk image."
                end
            elseif output == 7 then
                paintEncoded[frame] = blockEnlargeFrame(frame)
            elseif output == 8 then
                editFuncs.copy()
            elseif output == 9 then
                editFuncs.cut()
            elseif output == 10 then
                editFuncs.paste()
            elseif output == false then
                return "nobreak"
            end
        end,
        [3] = function() --Window
            local output = makeSubMenu(11,cleary-1,{
                "Set Screen Size",
                "Set Scroll XY",
                "Set Grid Colors"
            })
            if output == 1 then
                windowSetScrSize()
            elseif output == 2 then
                gotoCoords()
            elseif output == 3 then
                rendback.b = paint.b
                rendback.t = paint.t
            elseif output == false then
                return "nobreak"
            end
        end,
        [4] = function() --Set
            local output = makeSubMenu(17,cleary-1,{
                (painconfig.readNonImageAsNFP   and "(T)" or "(F)") .. " Load Non-images",
                (painconfig.useFlattenGIF       and "(T)" or "(F)") .. " Flatten GIFs",
                (painconfig.gridBleedThrough    and "(T)" or "(F)") .. " Always Render Grid",
                (painconfig.doFillDiagonal      and "(T)" or "(F)") .. " Fill Diagonally",
                (painconfig.doFillAnimation     and "(T)" or "(F)") .. " Do Fill Animation",
                (painconfig.useSetVisible       and "(T)" or "(F)") .. " Use setVisible()",
                "(" .. painconfig.undoBufferSize .. ") Set Undo Buffer Size",
            })
            if output == 1 then
                painconfig.readNonImageAsNFP = not painconfig.readNonImageAsNFP
            elseif output == 2 then
                painconfig.useFlattenGIF = not painconfig.useFlattenGIF
            elseif output == 3 then
                painconfig.gridBleedThrough = not painconfig.gridBleedThrough
            elseif output == 4 then
                painconfig.doFillDiagonal = not painconfig.doFillDiagonal
            elseif output == 5 then
                painconfig.doFillAnimation = not painconfig.doFillAnimation
            elseif output == 6 then
                painconfig.useSetVisible = not painconfig.useSetVisible
            elseif output == 7 then
                local newUndoBufferSize = bottomPrompt("New undo buffer size: ")
                if tonumber(newUndoBufferSize) then
                    painconfig.undoBufferSize = math.abs(tonumber(newUndoBufferSize))
                    plc.undoBuffer = {deepCopy(paintEncoded)}
                    plc.undoPos = 1
                else
                    return
                end
            end
            useConfig("save")
        end,
        [5] = function() --About
            local output = makeSubMenu(17,cleary-1,{
                "PAIN",
                "File Formats",
                "Help!"
            })
            if output == 1 then
                aboutPAIN()
            elseif output == 2 then
                aboutFileFormats()
            elseif output == 3 then
                guiHelp()
            end
        end,
        [6] = function() --Exit
            if plc.changedImage then
                local outcum = bottomPrompt("Abandon unsaved work? (Y/N)",_,"yn",{keys.leftCtrl,keys.rightCtrl})
                sleep(0)
                if outcum == "y" then
                    return "exit"
                else
                    return nil
                end
            else
                return "exit"
            end
        end,
    }
    local cursor = 1
    local redrawmenu = true
    local initial = os.time()
    local clickdelay = 0.003

    local redrawTheMenu = function()
        for a = cleary,scr_y do
            term.setCursorPos(1,a)
            term.setBackgroundColor(colors.lightGray)
            term.clearLine()
        end
        term.setCursorPos(2,cleary)
        for a = 1, #menuOptions do
            if a == cursor then
                term.setTextColor(colors.black)
                term.setBackgroundColor(colors.white)
            else
                term.setTextColor(colors.black)
                term.setBackgroundColor(colors.lightGray)
            end
            menuPoses[a] = {term.getCursorPos()}
            write(menuOptions[a])
            term.setBackgroundColor(colors.lightGray)
            if a ~= #menuOptions then
                write(" ")
            end
        end
        redrawmenu = false
    end

    while true do
        if redrawmenu then
            redrawTheMenu()
            redrawmenu = false
        end
        local event,key,x,y = getEvents("key","char","mouse_click","mouse_up","mouse_drag")
        if event == "key" then
            if key == keys.left then
                redrawmenu = true
                cursor = cursor - 1
            elseif key == keys.right then
                redrawmenu = true
                cursor = cursor + 1
            elseif key == keys.enter then
                redrawmenu = true
                local res = menuFunctions[cursor]()
                resetInputState()
                if res == "exit" then
                    doRender = true
                    return "exit"
                elseif res == "nobreak" then
                    reRenderPAIN(true)
                else
                    doRender = true
                    return
                end
            elseif key == keys.leftCtrl or key == keys.rightCtrl then
                doRender = true
                return
            end
        elseif event == "char" then
            for a = 1, #menuOptions do
                if key:lower() == menuOptions[a]:sub(1,1):lower() and a ~= cursor then
                    cursor = a
                    redrawmenu = true
                    break
                end
            end
        elseif event == "mouse_click" or event == "mouse_up" then
            if y < cleary then
                resetInputState()
                doRender = true
                return
            elseif key == 1 and initial+clickdelay < os.time() then --key? more like button
                for a = 1, #menuPoses do
                    if y == menuPoses[a][2] then
                        if x >= menuPoses[a][1] and x <= menuPoses[a][1]+#menuOptions[a] then
                            cursor = a
                            redrawTheMenu()
                            local res = menuFunctions[a]()
                            os.queueEvent("queue")
                            os.pullEvent("queue")
                            resetInputState()
                            doRender = true
                            if res == "exit" then
                                return "exit"
                            else
                                return
                            end
                        end
                    end
                end
            end
        end
        if (initial+clickdelay < os.time()) and string.find(event,"mouse") then
            if key == 1 then --key? key? what key? all I see is button!
                for a = 1, #menuPoses do
                    if y == menuPoses[a][2] then
                        if x >= menuPoses[a][1] and x <= menuPoses[a][1]+#menuOptions[a] then
                            cursor = a
                            redrawmenu = true
                            break
                        end
                    end
                end
            end
        end
        if cursor < 1 then
            cursor = #menuOptions
        elseif cursor > #menuOptions then
            cursor = 1
        end
    end
end

local lastMX,lastMY,isDragging

local doNonEventDrivenMovement = function() --what a STUPID function name, dude
    local didMove
    while true do
        didMove = false
        if (not keysDown[keys.leftShift]) and (not isDragging) and (not keysDown[keys.tab]) then
            if keysDown[keys.right] then
                paint.scrollX = paint.scrollX + 1
                didMove = true
            elseif keysDown[keys.left] then
                paint.scrollX = paint.scrollX - 1
                didMove = true
            end
            if keysDown[keys.down] then
                paint.scrollY = paint.scrollY + 1
                didMove = true
            elseif keysDown[keys.up] then
                paint.scrollY = paint.scrollY - 1
                didMove = true
            end
            if didMove then
                if lastMX and lastMY then
                    if miceDown[1] then
                        os.queueEvent("mouse_click",1,lastMX,lastMY)
                    end
                    if miceDown[2] then
                        os.queueEvent("mouse_click",2,lastMX,lastMY)
                    end
                end
                doRender = true
            end
        end
        sleep(0)
    end
end

local linePoses = {}
local dragPoses = {}

local listAllMonitors = function()
    term.setBackgroundColor(colors.gray)
    term.setTextColor(colors.white)
    local periphs = peripheral.getNames()
    local mons = {}
    for a = 1, #periphs do
        if peripheral.getType(periphs[a]) == "monitor" then
            mons[#mons+1] = periphs[a]
        end
    end
    if #mons == 0 then
        mons[1] = "No monitors found."
    end
    term.setCursorPos(3,1)
    term.clearLine()
    term.setTextColor(colors.yellow)
    term.write("All monitors:")
    term.setTextColor(colors.white)
    for y = 1, #mons do
        term.setCursorPos(2,y+1)
        term.clearLine()
        term.write(mons[y])
    end
    sleep(0)
    getEvents("char","mouse_click")
    doRender = true
end

local getInput = function() --gotta catch them all
    local drawEveryEvent = false
    local doot = function()
        local button, x, y, oldmx, oldmy, origx, origy
        local isDragging = false
        local proceed = false
        local evt, oldx, oldy = {}
        local button, points, key, dir
        renderBar(barmsg)
        while true do
            evt = {getEvents("mouse_scroll","mouse_click", "mouse_drag","mouse_up","key","key_up",true)}

            --doRender = false
            oldx, oldy = paint.scrollX,paint.scrollY

            if (evt[1] == "mouse_scroll") and (not viewing) then
                dir = evt[2]
                if dir == 1 then
                    if keysDown[keys.leftShift] or keysDown[keys.rightShift] then
                        paint.t = paint.t * 2
                        if paint.t > 32768 then
                            paint.t = 32768
                        end
                    else
                        paint.b = paint.b * 2
                        if paint.b > 32768 then
                            paint.b = 32768
                        end
                    end
                else
                    if keysDown[keys.leftShift] or keysDown[keys.rightShift] then
                        paint.t = math.ceil(paint.t / 2)
                        if paint.t < 1 then
                            paint.t = 1
                        end
                    else
                        paint.b = math.ceil(paint.b / 2)
                        if paint.b < 1 then
                            paint.b = 1
                        end
                    end
                end
                renderBar(barmsg)
            elseif ((evt[1] == "mouse_click") or (evt[1] == "mouse_drag")) and (not viewing) then
                if evt[1] == "mouse_click" then
                    origx, origy = evt[3], evt[4]
                end
                oldmx,oldmy = x or evt[3], y or evt[4]
                lastMX,lastMY = evt[3],evt[4]
                button,x,y = evt[2],evt[3],evt[4]
                if plc.renderBlittle then
                    x = 2*x
                    y = 3*y
                    lastMX = 2*lastMX
                    lastMY = 3*lastMY
                end
                linePoses = {{x=oldmx,y=oldmy},{x=x,y=y}}
                miceDown[button] = true
                if y <= scr_y-(plc.renderBlittle and 0 or doRenderBar) then
                    if (button == 3) then
                        putDownText(x,y)
                        miceDown = {}
                        keysDown = {}
                        doRender = true
                    elseif button == 1 then
                        if keysDown[keys.leftShift] and evt[1] == "mouse_click" then
                            isDragging = true
                        end
                        if isDragging then
                            if evt[1] == "mouse_click" or dontDragThisTime then
                                dragPoses[1] = {x=x,y=y}
                            end
                            dragPoses[2] = {x=x,y=y}
                            points = getDotsInLine(dragPoses[1].x,dragPoses[1].y,dragPoses[2].x,dragPoses[2].y)
                            renderAllPAIN()
                            for a = 1, #points do
                                term.setCursorPos(points[a].x, points[a].y)
                                term.blit(paint.c, CTB(paint.t), CTB(paint.b))
                            end
                        elseif (not dontDragThisTime) then
                            if evt[1] == "mouse_drag" then
                                points = getDotsInLine(linePoses[1].x,linePoses[1].y,linePoses[2].x,linePoses[2].y)
                                for a = 1, #points do
                                    putDotDown({x=points[a].x, y=points[a].y})
                                end
                            else
                                putDotDown({x=x, y=y})
                            end
                            plc.changedImage = true
                            doRender = true
                        end
                        dontDragThisTime = false
                    elseif button == 2 and y <= scr_y-(plc.renderBlittle and 0 or doRenderBar) then
                        deleteDot(x+paint.scrollX,y+paint.scrollY)
                        plc.changedImage = true
                        doRender = true
                    end
                elseif origy >= scr_y-(plc.renderBlittle and 0 or doRenderBar) then
                    miceDown = {}
                    keysDown = {}
                    isDragging = false
                    local res = displayMenu()
                    if res == "exit" then break end
                    doRender = true
                end
            elseif (evt[1] == "mouse_up") and (not viewing) and (not plc.isCurrentlyFilling) then
                origx,origy = 0,0
                button = evt[2]
                miceDown[button] = false
                oldmx,oldmy = nil,nil
                lastMX, lastMY = nil,nil
                if isDragging then
                    points = getDotsInLine(dragPoses[1].x,dragPoses[1].y,dragPoses[2].x,dragPoses[2].y)
                    for a = 1, #points do
                        putDotDown({x=points[a].x, y=points[a].y})
                    end
                    plc.changedImage = true
                    doRender = true
                end
                saveToUndoBuffer()
                isDragging = false
            elseif evt[1] == "key" then
                key = evt[2]
                if (isDragging or not keysDown[keys.leftShift]) and (keysDown[keys.tab]) then
                    if key == keys.right and (not keysDown[keys.right]) then
                        paint.scrollX = paint.scrollX + 1
                        doRender = true
                    elseif key == keys.left and (not keysDown[keys.left]) then
                        paint.scrollX = paint.scrollX - 1
                        doRender = true
                    end
                    if key == keys.down and (not keysDown[keys.down]) then
                        paint.scrollY = paint.scrollY + 1
                        doRender = true
                    elseif key == keys.up and (not keysDown[keys.up]) then
                        paint.scrollY = paint.scrollY - 1
                        doRender = true
                    end
                end
                keysDown[key] = true
                if key == keys.space then
                    if keysDown[keys.leftShift] then
                        plc.evenDrawGrid = not plc.evenDrawGrid
                    else
                        doRenderBar = math.abs(doRenderBar-1)
                    end
                    doRender = true
                end
                if key == keys.b then
                    local blTerm, oldTerm = getBlittle()
                    plc.renderBlittle = not plc.renderBlittle
                    isDragging = false
                    term.setBackgroundColor(rendback.b)
                    term.clear()
                    if plc.renderBlittle then
                        term.redirect(blTerm)
                        blTerm.setVisible(true)
                    else
                        term.redirect(oldTerm)
                        blTerm.setVisible(false)
                    end
                    doRender = true
                    scr_x, scr_y = term.current().getSize()
                end
                if keysDown[keys.leftAlt] then
                    if (not plc.renderBlittle) then
                        if (key == keys.c) then
                            editFuncs.copy()
                        elseif (key == keys.x) then
                            editFuncs.cut()
                        elseif (key == keys.v) then
                            editFuncs.paste()
                        end
                    end
                else
                    if (key == keys.c) and (not plc.renderBlittle) then
                        gotoCoords()
                        resetInputState()
                        doRender = true
                    end
                end
                if (keysDown[keys.leftShift]) and (not isDragging) then
                    if key == keys.left then
                        paintEncoded[frame] = movePaintEncoded(paintEncoded[frame],-1,0)
                        saveToUndoBuffer()
                        doRender = true
                        plc.changedImage = true
                    elseif key == keys.right then
                        paintEncoded[frame] = movePaintEncoded(paintEncoded[frame],1,0)
                        saveToUndoBuffer()
                        doRender = true
                        plc.changedImage = true
                    elseif key == keys.up then
                        paintEncoded[frame] = movePaintEncoded(paintEncoded[frame],0,-1)
                        saveToUndoBuffer()
                        doRender = true
                        plc.changedImage = true
                    elseif key == keys.down then
                        paintEncoded[frame] = movePaintEncoded(paintEncoded[frame],0,1)
                        saveToUndoBuffer()
                        doRender = true
                        plc.changedImage = true
                    end
                end
                if keysDown[keys.leftAlt] then
                    if #paintEncoded > 1 then
                        if key == keys.equals and paintEncoded[frame+1] then --basically plus
                            local first = deepCopy(paintEncoded[frame])
                            local next = deepCopy(paintEncoded[frame+1])
                            paintEncoded[frame] = next
                            paintEncoded[frame+1] = first
                            frame = frame + 1
                            barmsg = "Swapped prev frame."
                            doRender = true
                            plc.changedImage = true
                            saveToUndoBuffer()
                        end
                        if key == keys.minus and paintEncoded[frame-1] then
                            local first = deepCopy(paintEncoded[frame])
                            local next = deepCopy(paintEncoded[frame-1])
                            paintEncoded[frame] = next
                            paintEncoded[frame-1] = first
                            frame = frame - 1
                            barmsg = "Swapped next frame."
                            doRender = true
                            plc.changedImage = true
                            saveToUndoBuffer()
                        end
                    end
                elseif keysDown[keys.leftShift] then
                    if #paintEncoded > 1 then
                        if key == keys.equals and paintEncoded[frame+1] then --basically plus
                            for a = 1, #paintEncoded[frame] do
                                paintEncoded[frame+1][#paintEncoded[frame+1] + 1] = paintEncoded[frame][a]
                            end
                            table.remove(paintEncoded, frame)
                            paintEncoded = clearAllRedundant(paintEncoded)
                            barmsg = "Merged next frame."
                            doRender = true
                            plc.changedImage = true
                            saveToUndoBuffer()
                        end
                        if key == keys.minus and paintEncoded[frame-1] then
                            for a = 1, #paintEncoded[frame] do
                                paintEncoded[frame-1][#paintEncoded[frame-1] + 1] = paintEncoded[frame][a]
                            end
                            table.remove(paintEncoded, frame)
                            frame = frame - 1
                            paintEncoded = clearAllRedundant(paintEncoded)
                            barmsg = "Merged previous frame."
                            doRender = true
                            plc.changedImage = true
                            saveToUndoBuffer()
                        end
                    end
                else
                    if key == keys.equals then --basically 'plus'
                        if plc.renderBlittle then
                            frame = frame + 1
                            if frame > #paintEncoded then frame = 1 end
                        else
                            if not paintEncoded[frame+1] then
                                paintEncoded[frame+1] = {}
                                local sheet = paintEncoded[frame]
                                if keysDown[keys.rightShift] then
                                    paintEncoded[frame+1] = deepCopy(sheet)
                                end
                            end
                            frame = frame + 1
                        end
                        saveToUndoBuffer()
                        doRender = true
                        plc.changedImage = true
                    elseif key == keys.minus then
                        if plc.renderBlittle then
                            frame = frame - 1
                            if frame < 1 then frame = #paintEncoded end
                        else
                            if frame > 1 then
                                frame = frame - 1
                            end
                        end
                        saveToUndoBuffer()
                        doRender = true
                        plc.changedImage = true
                    end
                end
                if not plc.renderBlittle then
                    if key == keys.m then
                        local incum = bottomPrompt("Set meta: ",metaHistory)
                        paint.m = incum:gsub(" ","") ~= "" and incum or paint.m
                        if paint.m ~= metaHistory[#metaHistory] then
                            metaHistory[#metaHistory+1] = paint.m
                        end
                        doRender = true
                        isDragging = false
                    end
                    if key == keys.f7 then
                        plc.bepimode = not plc.bepimode
                        doRender = true
                    end
                    if key == keys.t then
                        renderBottomBar("Click to place text.")
                        local mevt
                        repeat
                            mevt = {os.pullEvent()}
                        until (mevt[1] == "key" and mevt[2] == keys.x) or (mevt[1] == "mouse_click" and mevt[2] == 1 and (mevt[4] or scr_y) <= scr_y-(plc.renderBlittle and 0 or doRenderBar))
                        if not (mevt[1] == "key" and mevt[2] == keys.x) then
                            local x,y = mevt[3],mevt[4]
                            if plc.renderBlittle then
                                x = 2*x
                                y = 3*y
                            end
                            putDownText(x,y)
                            miceDown = {}
                            keysDown = {}
                        end
                        doRender = true
                        plc.changedImage = true
                        isDragging = false
                    end
                    if key == keys.f and not (keysDown[keys.leftShift] or keysDown[keys.rightShift]) and (not plc.isCurrentlyFilling) then
                        renderBottomBar("Click to fill area.")
                        local mevt
                        repeat
                            mevt = {os.pullEvent()}
                        until (mevt[1] == "key" and mevt[2] == keys.x) or (mevt[1] == "mouse_click" and mevt[2] <= 2 and (mevt[4] or scr_y) <= scr_y-(renderBlittle and 0 or doRenderBar))
                        if not (mevt[1] == "key" and mevt[2] == keys.x) then
                            local x,y = mevt[3],mevt[4]
                            if plc.renderBlittle then
                                x = 2*x
                                y = 3*y
                            end
                            miceDown = {}
                            keysDown = {}
                            os.queueEvent("filltool_async", frame, x, y, paint, mevt[2] == 2)
                        end
                        doRender = true
                        plc.changedImage = true
                        isDragging = false
                    end
                    if key == keys.p then
                        renderBottomBar("Pick color with cursor:")
                        paintEncoded = clearAllRedundant(paintEncoded)
                        local mevt
                        repeat
                            mevt = {os.pullEvent()}
                        until (mevt[1] == "key" and mevt[2] == keys.x) or (mevt[2] == 1 and mevt[4] <= scr_y)
                        if not (mevt[1] == "key" and mevt[2] == keys.x) then
                            local x, y = mevt[3]+paint.scrollX, mevt[4]+paint.scrollY
                            if plc.renderBlittle then
                                x = 2*x
                                y = 3*y
                            end
                            local p
                            for a = 1, #paintEncoded[frame] do
                                p = paintEncoded[frame][a]
                                if (p.x == x) and (p.y == y) then
                                    paint.t = p.t or paint.t
                                    paint.b = p.b or paint.b
                                    paint.c = p.c or paint.c
                                    paint.m = p.m or paint.m
                                    miceDown = {}
                                    keysDown = {}
                                    doRender = true
                                    isDragging = false
                                    break
                                end
                            end
                            resetInputState()
                        end
                        doRender = true
                        isDragging = false
                    end
                    if (key == keys.leftCtrl or key == keys.rightCtrl) then
                        keysDown = {[207] = keysDown[207]}
                        isDragging = false
                        local res = displayMenu()
                        paintEncoded = clearAllRedundant(paintEncoded)
                        if res == "exit" then break end
                        doRender = true
                    end
                end
                if (key == keys.f and keysDown[keys.leftShift]) then
                    local deredots = {}
                    plc.changedImage = true
                    for a = 1, #paintEncoded[frame] do
                        local dot = paintEncoded[frame][a]
                        if dot.x-paint.scrollX > 0 and dot.x-paint.scrollX <= scr_x then
                            if dot.y-paint.scrollY > 0 and dot.y-paint.scrollY <= scr_y then
                                deredots[#deredots+1] = {dot.x-paint.scrollX, dot.y-paint.scrollY}
                            end
                        end
                    end
                    for y = 1, scr_y do
                        for x = 1, scr_x do
                            local good = true
                            for a = 1, #deredots do
                                if (deredots[a][1] == x) and (deredots[a][2] == y) then
                                    good = bad
                                    break
                                end
                            end
                            if good then
                                putDotDown({x=x, y=y})
                            end
                        end
                    end
                    saveToUndoBuffer()
                    doRender = true
                end
                if key == keys.g then
                    paint.doGray = not paint.doGray
                    plc.changedImage = true
                    saveToUndoBuffer()
                    doRender = true
                end
                if key == keys.a then
                    paint.scrollX = 0
                    paint.scrollY = 0
                    doRender = true
                end
                if key == keys.n then
                    if keysDown[keys.leftShift] then
                        paint.c = specialCharSelector()
                    else
                        paint.c = boxCharSelector()
                    end
                    resetInputState()
                    doRender = true
                end
                if key == keys.f1 then
                    guiHelp()
                    resetInputState()
                    isDragging = false
                end
                if key == keys.f3 then
                    listAllMonitors()
                    resetInputState()
                    isDragging = false
                end
                if key == keys.leftBracket then
                    os.queueEvent("mouse_scroll",2,1,1)
                elseif key == keys.rightBracket then
                    os.queueEvent("mouse_scroll",1,1,1)
                end
                if key == keys.z then
                    if keysDown[keys.leftAlt] and plc.undoPos < #plc.undoBuffer then
                        doRedo()
                        barmsg = "Redood."
                        doRender = true
                    elseif plc.undoPos > 1 then
                        doUndo()
                        barmsg = "Undood."
                        doRender = true
                    end
                end
            elseif evt[1] == "key_up" then
                local key = evt[2]
                keysDown[key] = false
            end
            if (oldx~=paint.scrollX) or (oldy~=paint.scrollY) then
                doRender = true
            end
            if drawEveryEvent and doRender then
                renderAllPAIN()
                doRender = false
            end
        end
    end
    if drawEveryEvent then
        doot()
    else
        parallel.waitForAny(doot, function()
            while true do
                sleep(0.05)
                if doRender then
                    renderAllPAIN()
                    doRender = false
                end
            end
        end)
    end
end

runPainEditor = function(...) --needs to be cleaned up
    local tArg = table.pack(...)
    if not (tArg[1] == "-n" or (not tArg[1])) then
        plc.fileName = shell.resolve(tostring(tArg[1]))
    end

    if not plc.fileName then
        paintEncoded = {{}}
    elseif not fs.exists(plc.fileName) then
        local ex = plc.fileName:sub(-4):lower()
        if ex == ".nfp" then
            plc.defaultSaveFormat = 1
        elseif ex == ".nft" then
            plc.defaultSaveFormat = 2
        elseif ex == ".blt" then
            plc.defaultSaveFormat = 3
        elseif ex == ".gif" then
            plc.defaultSaveFormat = 5
        elseif ex == ".ucg" then
            plc.defaultSaveFormat = 6
        else
            plc.defaultSaveFormat = 4
        end
        paintEncoded = {{}}
    elseif fs.isDir(plc.fileName) then
        if math.random(1,32) == 1 then
            write("Oh") sleep(0.2)
            write(" My") sleep(0.2)
            print(" God") sleep(0.3)
            write("That is a") sleep(0.1) term.setTextColor(colors.red)
            write(" FLIPPING") sleep(0.4)
            print(" FOLDER.") sleep(0.2) term.setTextColor(colors.white)
            print("You crazy person.") sleep(0.2)
        else
            print("That's a folder.")
        end
        return
    else
        paintEncoded, plc.defaultSaveFormat = openNewFile(plc.fileName, readNonImageAsNFP)
        if not paintEncoded then
            return print(plc.defaultSaveFormat)
        end
    end

    local asyncFillTool = function()
        local event, frameNo, x, y, dot
        plc.isCurrentlyFilling = false
        while true do
            event, frameNo, x, y, dot, isDeleting = os.pullEvent("filltool_async")
            plc.isCurrentlyFilling = true
            renderBottomBar("Filling area...")
            fillTool(frameNo, x, y, dot, isDeleting)
            saveToUndoBuffer()
            plc.isCurrentlyFilling = false
            reRenderPAIN(doRenderBar == 0)
        end
    end

    if not paintEncoded[frame] then paintEncoded = {paintEncoded} end
    if plc.pMode == 1 then
        doRenderBar = 0
        renderPAIN(paintEncoded[tonumber(tArg[5]) or 1],-(tonumber(tArg[3]) or 0),-(tonumber(tArg[4]) or 0)) -- 'pain filename view X Y frame'
        sleep(0)
        return
    else
        renderPAIN(paintEncoded[frame],paint.scrollX,paint.scrollY,true)
    end
    lastPaintEncoded = deepCopy(paintEncoded)
    plc.undoBuffer = {deepCopy(paintEncoded)}
    parallel.waitForAny(getInput, doNonEventDrivenMovement, asyncFillTool)

    term.setCursorPos(1,scr_y)
    term.setBackgroundColor(colors.black)
    term.clearLine()
end

if not shell then error("shell API is required, sorry") end

runPainEditor(table.unpack(plc.tArg))