1608 lines
43 KiB
Lua
1608 lines
43 KiB
Lua
local terminal = term.current()
|
||
local deskIcons = lUtils.asset.load("LevelOS/assets/Desktop_Icons.limg")
|
||
local desktop = {}
|
||
local idReference = {}
|
||
local fc = fs.combine
|
||
|
||
local function locateEntry(tTable,tEntry)
|
||
if type(tTable) ~= "table" then
|
||
error("Invalid input #1",2)
|
||
end
|
||
for t=1,#tTable do
|
||
if tTable[t] == tEntry then
|
||
return true,t
|
||
end
|
||
end
|
||
return false,0
|
||
end
|
||
|
||
local fileTypes
|
||
if fs.exists("LevelOS/data/formats.lconf") then
|
||
fileTypes = lUtils.asset.load("LevelOS/data/formats.lconf")
|
||
end
|
||
|
||
if not fileTypes then
|
||
local copy = lUtils.instantiate
|
||
fileTypes = {
|
||
_VERSION="1.3",
|
||
|
||
[""] = {
|
||
name="File",
|
||
program="Lua",
|
||
contextMenu={
|
||
{"Execute","Edit"},
|
||
{"Lua","rom/programs/edit.lua"}
|
||
},
|
||
openWith={
|
||
"Lua",
|
||
"rom/programs/edit.lua"
|
||
},
|
||
icon=deskIcons[1]
|
||
},
|
||
|
||
lua = {
|
||
name="Lua script",
|
||
program="Lua",
|
||
contextMenu={
|
||
{"Execute","Edit"},
|
||
{"Lua","rom/programs/edit.lua"}
|
||
},
|
||
openWith={
|
||
"Lua",
|
||
"rom/programs/edit.lua"
|
||
},
|
||
icon=deskIcons[2],
|
||
emptyFilePreset=""
|
||
},
|
||
|
||
txt = {
|
||
name="Text file",
|
||
program="LevelOS/notepad.lua",
|
||
contextMenu={
|
||
{"Edit"},
|
||
{"LevelOS/notepad.lua"}
|
||
},
|
||
openWith={
|
||
"LevelOS/notepad.lua",
|
||
"rom/programs/edit.lua"
|
||
},
|
||
icon=deskIcons[5],
|
||
emptyFilePreset=""
|
||
},
|
||
|
||
lconf = {
|
||
name="Config file",
|
||
program="LevelOS/notepad.lua",
|
||
contextMenu={
|
||
{"Edit"},
|
||
{"LevelOS/notepad.lua"}
|
||
},
|
||
openWith={
|
||
"LevelOS/notepad.lua",
|
||
"rom/programs/edit.lua"
|
||
},
|
||
icon=deskIcons[6],
|
||
emptyFilePreset="{}"
|
||
},
|
||
|
||
sgui = {
|
||
name="Shapescape GUI",
|
||
program="Program_Files/Shapescape",
|
||
contextMenu={
|
||
{"Open","Execute"},
|
||
{"Program_Files/Shapescape","Lua"}
|
||
},
|
||
openWith={
|
||
"Lua",
|
||
"Program_Files/Shapescape",
|
||
"rom/programs/edit.lua"
|
||
},
|
||
icon=deskIcons[8],
|
||
emptyFilePreset="return {assets={},slides={{contextMenu=1,objs={},w=51,h=19}}}"
|
||
},
|
||
|
||
sml = {
|
||
name="SML Document",
|
||
program="Program_Files/sml",
|
||
contextMenu={
|
||
{"Open","Edit"},
|
||
{"Program_Files/sml","rom/programs/edit.lua"}
|
||
},
|
||
openWith={
|
||
"Program_Files/sml",
|
||
"rom/programs/edit.lua"
|
||
},
|
||
icon=deskIcons[9],
|
||
emptyFilePreset=""
|
||
},
|
||
|
||
limg = {
|
||
name="Image",
|
||
program="LevelOS/imageviewer.lua",
|
||
contextMenu={
|
||
{"View","Edit"},
|
||
{"LevelOS/imageviewer.lua","rom/programs/edit.lua"}
|
||
},
|
||
openWith={
|
||
"LevelOS/imageviewer.lua",
|
||
"rom/programs/edit.lua"
|
||
},
|
||
icon=copy(deskIcons[10])
|
||
},
|
||
|
||
bimg = {
|
||
name="Image",
|
||
program="LevelOS/imageviewer.lua",
|
||
contextMenu={
|
||
{"View","Edit"},
|
||
{"LevelOS/imageviewer.lua","rom/programs/edit.lua"}
|
||
},
|
||
openWith={
|
||
"LevelOS/imageviewer.lua",
|
||
"rom/programs/edit.lua"
|
||
},
|
||
icon=copy(deskIcons[10])
|
||
},
|
||
|
||
nfp = {
|
||
name="NFP Image",
|
||
program="LevelOS/imageviewer.lua",
|
||
contextMenu={
|
||
{"View","Edit"},
|
||
{"LevelOS/imageviewer.lua","rom/programs/fun/advanced/paint.lua"}
|
||
},
|
||
openWith={
|
||
"LevelOS/imageviewer.lua",
|
||
"rom/programs/fun/advanced/paint.lua",
|
||
"rom/programs/edit.lua"
|
||
},
|
||
icon=copy(deskIcons[10]),
|
||
emptyFilePreset=""
|
||
},
|
||
|
||
nfg = {
|
||
name="Animation",
|
||
program="LevelOS/imageviewer.lua",
|
||
contextMenu={
|
||
{"View","Edit"},
|
||
{"LevelOS/imageviewer.lua","rom/programs/edit.lua"}
|
||
},
|
||
openWith={
|
||
"LevelOS/imageviewer.lua",
|
||
"rom/programs/edit.lua"
|
||
},
|
||
icon=copy(deskIcons[10])
|
||
},
|
||
}
|
||
|
||
lUtils.asset.save(lUtils.instantiate(fileTypes),"LevelOS/data/formats.lconf", false)
|
||
|
||
end
|
||
|
||
if fileTypes._VERSION == "1.0" then
|
||
for k,v in pairs(fileTypes) do
|
||
if type(v) == "table" then
|
||
v.name = v.name or v.n
|
||
v.n = nil
|
||
v.program = v.program or v.p
|
||
v.p = nil
|
||
v.icon = v.icon or v.i
|
||
v.i = nil
|
||
v.contextMenu = v.contextMenu or v.c
|
||
v.c = nil
|
||
v.openWith = v.openWith or v.o
|
||
v.o = nil
|
||
v.emptyFilePreset = v.emptyFilePreset or v.e
|
||
end
|
||
end
|
||
fileTypes._VERSION = "1.1"
|
||
fileTypes["llnk"] = {name="Shortcut",program="Lua"}
|
||
lUtils.asset.save(lUtils.instantiate(fileTypes),"LevelOS/data/formats.lconf")
|
||
end
|
||
if fileTypes._VERSION == "1.1" then
|
||
for k,v in pairs(fileTypes) do
|
||
if type(v) == "table" then
|
||
v._VERSION = nil
|
||
end
|
||
end
|
||
for k,v in pairs(fileTypes.nfp.openWith) do
|
||
if v == "rom/programs/fun/paint.lua" then
|
||
fileTypes.nfp.openWith[k] = "rom/programs/fun/advanced/paint.lua"
|
||
end
|
||
end
|
||
fileTypes._VERSION = "1.2"
|
||
lUtils.asset.save(lUtils.instantiate(fileTypes),"LevelOS/data/formats.lconf",false)
|
||
end
|
||
if fileTypes._VERSION == "1.2" then
|
||
fileTypes.bimg = {
|
||
name="Image",
|
||
program="LevelOS/imageviewer.lua",
|
||
contextMenu={
|
||
{"View","Edit"},
|
||
{"LevelOS/imageviewer.lua","rom/programs/edit.lua"}
|
||
},
|
||
openWith={
|
||
"LevelOS/imageviewer.lua",
|
||
"rom/programs/edit.lua"
|
||
},
|
||
icon=deskIcons[10]
|
||
}
|
||
fileTypes._VERSION = "1.3"
|
||
lUtils.asset.save(lUtils.instantiate(fileTypes),"LevelOS/data/formats.lconf",false)
|
||
end
|
||
local dConfig
|
||
if not lOS.explorer then lOS.explorer = {} end
|
||
lOS.explorer.shortcache = {}
|
||
lOS.explorer.imgcache = {}
|
||
lOS.explorer.nimgcache = {}
|
||
lOS.explorer.desktopBackground = nil
|
||
lOS.fClipboard = {}
|
||
|
||
local disks = {}
|
||
lOS.explorer.disks = disks
|
||
local function reloadDisks()
|
||
for k,v in pairs(disks) do
|
||
disks[k] = nil
|
||
end
|
||
local ndisks = {peripheral.find("drive",function(name,object) return object.hasData() end)}
|
||
for t=1,#ndisks do
|
||
ndisks[ndisks[t].getMountPath()] = ndisks[t]
|
||
end
|
||
for k,v in pairs(ndisks) do
|
||
disks[k] = v
|
||
end
|
||
end
|
||
reloadDisks()
|
||
|
||
local function getName(path)
|
||
local isDisk = false
|
||
if disks[path] and disks[path].getDiskLabel() then
|
||
str = disks[path].getDiskLabel().." ("..string.gsub(path,"_"," ")..")"
|
||
isDisk = true
|
||
elseif path == "" then
|
||
str = "Local disk"
|
||
else
|
||
str = string.gsub(fs.getName(path),"_"," ")
|
||
if lUtils.getFileType(str) == ".llnk" then
|
||
str = str:sub(1,#str-5)
|
||
end
|
||
end
|
||
return str,isDisk
|
||
end
|
||
|
||
lOS.explorer.getName = getName
|
||
|
||
local symbols = {
|
||
["User/Cloud"] = {symbol=" ",color=colors.blue},
|
||
[""] = {symbol="",color=colors.lightGray},
|
||
["rom"] = {symbol="",color=colors.red},
|
||
["User"] = {symbol="",color=colors.lightBlue},
|
||
["User/Desktop"] = {symbol=" ",color=colors.lightBlue},
|
||
["User/Documents"] = {symbol="",color=colors.lightGray},
|
||
["User/Downloads"] = {symbol="",color=colors.blue},
|
||
["User/Images"] = {symbol="",color=colors.lightBlue},
|
||
["User/Scripts"] = {symbol="",color=colors.cyan},
|
||
["User/Games"] = {symbol="",color=colors.lightGray},
|
||
["User/Music"] = {symbol="",color=colors.blue},
|
||
}
|
||
|
||
lOS.explorer.getIcon = function(path)
|
||
local disks = {peripheral.find("drive",function(name,object) return object.hasData() end)}
|
||
for t=1,#disks do
|
||
disks[disks[t].getMountPath()] = disks[t]
|
||
end
|
||
if symbols[path] then
|
||
return symbols[path].symbol, symbols[path].color
|
||
elseif disks[path] then
|
||
return "", colors.blue
|
||
elseif fs.isDir(path) then
|
||
return "\143", colors.yellow
|
||
else
|
||
return "\143", colors.white
|
||
end
|
||
end
|
||
|
||
local function genFile(f)
|
||
if not fs.exists(f) then
|
||
error(f.." does not exist",2)
|
||
end
|
||
local file = {path=f,name=fs.getName(f),type=lUtils.getFileType(f):sub(2),readOnly=fs.isReadOnly(f),isDir=fs.isDir(f)}
|
||
if not ((file.isDir and file.readOnly) or disks[file.path]) then
|
||
local a = fs.attributes(f)
|
||
for k,v in pairs(a) do
|
||
file[k] = v
|
||
end
|
||
end
|
||
return file
|
||
end
|
||
|
||
local function uFP(filepath2) -- unique filepath
|
||
if fs.exists(filepath2) == true then
|
||
t = 1
|
||
while fs.exists(string.sub(filepath2,1,string.len(filepath2)-string.len(lUtils.getFileType(filepath2))).."_("..t..")"..lUtils.getFileType(filepath2)) == true do
|
||
t = t+1
|
||
end
|
||
filepath2 = string.sub(filepath2,1,string.len(filepath2)-string.len(lUtils.getFileType(filepath2))).."_("..t..")"..lUtils.getFileType(filepath2)
|
||
end
|
||
return filepath2
|
||
end
|
||
lOS.explorer.uFP = uFP
|
||
|
||
function lOS.genIco(path)
|
||
local name = getName(path)
|
||
if fs.isDir(path) and fs.exists(fs.combine(path,"main.lua")) then
|
||
path = fs.combine(path,"main.lua")
|
||
end
|
||
local pth = fs.combine("User/Desktop",name..".llnk")
|
||
lUtils.asset.save({path},pth)
|
||
os.queueEvent("explorer_reload")
|
||
end
|
||
|
||
local presetIcons = {
|
||
["User"] = deskIcons[12],
|
||
["User/Desktop"] = deskIcons[13],
|
||
["User/Documents"] = deskIcons[14],
|
||
["User/Downloads"] = deskIcons[15],
|
||
["User/Games"] = deskIcons[16],
|
||
["User/Images"] = deskIcons[17],
|
||
["User/Music"] = deskIcons[18],
|
||
["User/Scripts"] = deskIcons[19],
|
||
["User/Cloud"] = deskIcons[20],
|
||
["rom"] = deskIcons[21],
|
||
}
|
||
function lOS.explorer.drawIcon(path,fx,fy,onlyIcon,transparent,maxLines,shortcutIcon)
|
||
--local file = {path=path,type=lUtils.getFileType(path):sub(2)}
|
||
local ok,file = pcall(genFile,path)
|
||
if not ok then
|
||
lUtils.renderImg(deskIcons[11],fx+2,fy+1,nil,transparent)
|
||
return
|
||
end
|
||
local bg = term.getBackgroundColor()
|
||
local fg = term.getTextColor()
|
||
local cTerm = term.current()
|
||
local isCut = false
|
||
if lOS.fCut then
|
||
isCut = locateEntry(lOS.fCut,file.path)
|
||
end
|
||
local shortcache = lOS.explorer.shortcache
|
||
local imgcache = lOS.explorer.imgcache
|
||
local nimgcache = lOS.explorer.nimgcache
|
||
local fc = fs.combine
|
||
local rPath = path
|
||
local rType = file.type
|
||
local isShort = false
|
||
local lines = lUtils.wordwrap(lUtils.getFileName(file.path),7)
|
||
local lineH = math.min(#lines,4)
|
||
local fw,fh = 7,5
|
||
if #lines > lineH then
|
||
lines[4] = lines[4]:sub(1,5)..".."
|
||
end
|
||
fh = math.max(4+lineH,fh)
|
||
if not transparent then
|
||
lOS.boxClear(fx,fy,fx+7-1,fy+5-1+lineH-1)
|
||
end
|
||
if shortcache[file.path] then
|
||
isShort = true
|
||
rPath = shortcache[file.path][1]
|
||
rType = lUtils.getFileType(rPath):sub(2)
|
||
elseif file.type == "llnk" then
|
||
local info = lUtils.asset.load(file.path)
|
||
if info and type(info[1]) == "string" then
|
||
isShort = true
|
||
rPath = info[1]
|
||
if not fs.exists(rPath) then
|
||
imgcache[file.path] = {}
|
||
for i=0,15 do
|
||
imgcache[file.path][i] = deskIcons[4]
|
||
end
|
||
else
|
||
rType = lUtils.getFileType(info[1]):sub(2)
|
||
imgcache[file.path] = {}
|
||
for i=0,15 do
|
||
imgcache[file.path][i] = info.icon
|
||
end
|
||
end
|
||
shortcache[file.path] = info
|
||
end
|
||
end
|
||
local pFolder = fs.getDir(rPath)
|
||
if not isCut then
|
||
if not fs.exists(rPath) then
|
||
lUtils.renderImg(deskIcons[4],fx+2,fy+1,nil,transparent)
|
||
elseif presetIcons[rPath] then
|
||
lUtils.renderImg(presetIcons[rPath],fx+2,fy+1,nil,transparent)
|
||
elseif imgcache[file.path] and imgcache[file.path][bg] then
|
||
local win = imgcache[file.path][bg]
|
||
if win.reposition then
|
||
for t=1,3 do
|
||
term.setCursorPos(fx+2,fy+t)
|
||
term.blit(win.getLine(t))
|
||
end
|
||
else
|
||
lUtils.renderImg(win,fx+2,fy+1,nil,transparent)
|
||
end
|
||
elseif fs.getName(rPath) == "main.lua" --[[and fs.exists(fc(pFolder,"icon.limg"))]] then
|
||
if not nimgcache[file.path] and (fs.exists(fc(pFolder,"icon.limg")) or fs.exists(fc(pFolder,"icon.bimg"))) then
|
||
local img
|
||
if fs.exists(fc(pFolder,"icon.limg")) then
|
||
img = lUtils.asset.load(fc(pFolder,"icon.limg"))
|
||
else
|
||
img = lUtils.asset.load(fc(pFolder,"icon.bimg"))
|
||
end
|
||
img = img[1]
|
||
local iw = #img[1][1]
|
||
local ih = #img
|
||
if iw <= 3 and ih <= 3 then
|
||
--[[local tWin = window.create(cTerm,fx+2,fy+1,iw,ih,true)
|
||
term.redirect(tWin)
|
||
lUtils.renderImg(img,1,1)
|
||
term.redirect(cTerm)
|
||
imgcache[file.path] = tWin]]
|
||
if not imgcache[file.path] then
|
||
imgcache[file.path] = {}
|
||
end
|
||
imgcache[file.path][bg] = img
|
||
lUtils.renderImg(img,fx+2,fy+1,nil,transparent)
|
||
else
|
||
nimgcache[file.path] = true
|
||
end
|
||
else
|
||
lUtils.renderImg(deskIcons[3],fx+2,fy+1,nil,transparent)
|
||
end
|
||
elseif fs.isDir(rPath) then
|
||
if not nimgcache[file.path] and (fs.exists(fc(rPath,"icon.limg")) or fs.exists(fc(rPath,"icon.bimg"))) and fs.exists(fc(rPath,"main.lua")) then
|
||
local img
|
||
if fs.exists(fc(rPath,"icon.limg")) then
|
||
img = lUtils.asset.load(fc(rPath,"icon.limg"))
|
||
else
|
||
img = lUtils.asset.load(fc(rPath,"icon.bimg"))
|
||
end
|
||
img = img[1]
|
||
local iw = #img[1][1]
|
||
local ih = #img
|
||
if iw <= 3 and ih <= 3 then
|
||
local tWin = window.create(cTerm,fx+2,fy+1,iw,ih,true)
|
||
term.redirect(tWin)
|
||
if transparent then
|
||
for y=1,2 do
|
||
local line = {cTerm.getLine(fy+y)}
|
||
for t=1,3 do
|
||
line[t] = line[t]:sub(fx+2,fx+4)
|
||
end
|
||
term.setCursorPos(1,y)
|
||
term.blit(unpack(line))
|
||
end
|
||
else
|
||
term.setBackgroundColor(bg)
|
||
term.clear()
|
||
end
|
||
lUtils.renderImg(img,1,1,nil,transparent)
|
||
term.setBackgroundColor(colors.yellow)
|
||
term.setCursorPos(1,3)
|
||
term.write(" ")
|
||
term.redirect(cTerm)
|
||
if not imgcache[file.path] then
|
||
imgcache[file.path] = {}
|
||
end
|
||
imgcache[file.path][bg] = tWin
|
||
else
|
||
nimgcache[file.path] = true
|
||
end
|
||
else
|
||
lUtils.renderImg(deskIcons[7],fx+2,fy+1,nil,transparent)
|
||
end
|
||
elseif ((rType == "limg" or file.type == "bimg") and lUtils.asset.load(rPath)) or rType == "nfp" then
|
||
local iw,ih
|
||
local img
|
||
if rType == "nfp" then
|
||
img = lUtils.fread(rPath)
|
||
ih = 0
|
||
iw = 0
|
||
for line in img:gmatch("([^\n]*)\n?") do
|
||
iw = math.max(iw,#line)
|
||
ih = ih+1
|
||
end
|
||
else
|
||
img = lUtils.asset.load(rPath)
|
||
img = img[1]
|
||
iw = #img[1][1]
|
||
ih = #img
|
||
end
|
||
local tWin = window.create(cTerm,1,1,iw,ih,false)
|
||
term.redirect(tWin)
|
||
term.setBackgroundColor(bg)
|
||
term.clear()
|
||
lUtils.renderImg(img,1,1)
|
||
term.redirect(cTerm)
|
||
if not imgcache[file.path] then
|
||
imgcache[file.path] = {}
|
||
end
|
||
if iw <= 3 and ih <= 3 then
|
||
imgcache[file.path][bg] = img
|
||
lUtils.renderImg(img,fx+2,fy+1,nil,transparent)
|
||
else
|
||
local lWin = lUtils.littlewin(tWin,6,math.floor(9*(ih/iw)+0.5))
|
||
local fWin = window.create(cTerm,fx+2,fy+1,3,3,true)
|
||
--_G.debuglwin[file.path] = {lWin=lWin,tWin=tWin,img=img}
|
||
term.redirect(fWin)
|
||
local win = blittle.createWindow(fWin,1,1,3,3,true)
|
||
term.redirect(win)
|
||
if transparent then
|
||
for y=1,3 do
|
||
local line = {cTerm.getLine(fy+y)}
|
||
for t=1,3 do
|
||
line[t] = line[t]:sub(fx+2,fx+4)
|
||
end
|
||
term.setCursorPos(1,y)
|
||
term.blit(unpack(line))
|
||
end
|
||
else
|
||
term.setBackgroundColor(bg)
|
||
term.clear()
|
||
end
|
||
lWin.render(1,1)
|
||
term.redirect(fWin)
|
||
win.redraw()
|
||
term.redirect(cTerm)
|
||
fWin.redraw()
|
||
imgcache[file.path][bg] = fWin
|
||
end
|
||
elseif fileTypes[rType] and fileTypes[rType].icon then
|
||
lUtils.renderImg(fileTypes[rType].icon,fx+2,fy+1,nil,transparent)
|
||
else
|
||
lUtils.renderImg(deskIcons[4],fx+2,fy+1,nil,transparent)
|
||
end
|
||
if shortcutIcon then
|
||
if isShort and not onlyIcon then
|
||
term.setCursorPos(fx+2,fy+3)
|
||
term.blit(unpack(shortcutIcon))
|
||
elseif lOS.cloud and lOS.cloud.lastSync and lOS.cloud.files and lOS.cloud.files[file.path] then
|
||
term.setCursorPos(fx+2,fy+3)
|
||
local pix = {lUtils.getPixel(term.current(),fx+2,fy+3)}
|
||
term.setBackgroundColor(lUtils.toColor(pix[3]))
|
||
if lOS.cloud.conflicts[file.path] then
|
||
term.setTextColor(colors.red)
|
||
term.write("×")
|
||
elseif file.modification > lOS.cloud.lastSync then
|
||
term.setTextColor(colors.blue)
|
||
term.write("\24")
|
||
else
|
||
term.setTextColor(colors.lime)
|
||
term.write("\7")
|
||
end
|
||
end
|
||
end
|
||
end
|
||
term.setBackgroundColor(bg)
|
||
term.setTextColor(fg)
|
||
if not onlyIcon then
|
||
if maxLines then
|
||
lineH = math.min(maxLines,lineH)
|
||
end
|
||
for l=1,lineH do
|
||
local line = lines[l]:gsub("%s+$","")
|
||
term.setCursorPos(fx+math.floor(fw/2-#line/2),fy+3+l)
|
||
if transparent then
|
||
lUtils.transWrite(line,(not dConfig.textColor))
|
||
else
|
||
term.write(line)
|
||
end
|
||
end
|
||
end
|
||
return fh
|
||
end
|
||
|
||
dConfig = {_VERSION=1,files={},sizes={},shortcutIcon=true,background={color=colors.white}}
|
||
if fs.exists("LevelOS/data/desktop.lconf") then
|
||
dConfig = lUtils.asset.load("LevelOS/data/desktop.lconf")
|
||
end
|
||
|
||
if not dConfig._VERSION then
|
||
-- backup n shit
|
||
if fs.exists("LevelOS/data/olddesktop.lconf") then
|
||
fs.delete("LevelOS/data/olddesktop.lconf")
|
||
end
|
||
fs.move("LevelOS/data/desktop.lconf","LevelOS/data/olddesktop.lconf")
|
||
dConfig = {_VERSION=1,files={},sizes={},shortcutIcon=true,background={color=colors.white}}
|
||
end
|
||
|
||
lOS.explorer.desktopConfig = dConfig
|
||
|
||
function lOS.save()
|
||
lUtils.asset.save(dConfig,"LevelOS/data/desktop.lconf")
|
||
lUtils.fwrite("LevelOS/data/settings.lconf",textutils.serialize(lOS.settings))
|
||
return true
|
||
end
|
||
|
||
if not fs.exists("User/Desktop") then
|
||
fs.makeDir("User/Desktop")
|
||
-- my PC
|
||
lUtils.asset.save(
|
||
{
|
||
"Program_Files/LevelOS/Explorer/main.lua",
|
||
icon = {
|
||
{
|
||
"",
|
||
"ff ",
|
||
" f",
|
||
},
|
||
{
|
||
"",
|
||
"f f",
|
||
" f ",
|
||
},
|
||
{
|
||
"",
|
||
"fff",
|
||
" ",
|
||
}
|
||
},
|
||
},
|
||
"User/Desktop/My_PC.llnk"
|
||
)
|
||
-- shell
|
||
lUtils.asset.save(
|
||
{
|
||
"rom/programs/shell.lua",
|
||
icon = {
|
||
{
|
||
"",
|
||
" ",
|
||
"fff",
|
||
},
|
||
{
|
||
"",
|
||
"f44",
|
||
"4ff",
|
||
},
|
||
{
|
||
"",
|
||
"fff",
|
||
" ",
|
||
}
|
||
},
|
||
},
|
||
"User/Desktop/Shell.llnk"
|
||
)
|
||
local function makeShortcuts(folder)
|
||
local ls = fs.list(folder)
|
||
for i,f in ipairs(ls) do
|
||
local path = fc(folder,f)
|
||
if fs.isDir(path) then
|
||
if fs.exists(fc(path,"main.lua")) then
|
||
lUtils.asset.save({fc(path,"main.lua")},fc("User/Desktop",fs.getName(f))..".llnk")
|
||
else
|
||
makeShortcuts(path)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
makeShortcuts("Program_Files")
|
||
end
|
||
|
||
|
||
-- dConfig should be loaded after this
|
||
local currentID = 1
|
||
if not dConfig.files then dConfig.files = {} end
|
||
for id,path in pairs(dConfig.files) do
|
||
if id >= currentID then
|
||
currentID = id+1
|
||
end
|
||
idReference[path] = id
|
||
end
|
||
|
||
local desktopMap = setmetatable({}, {
|
||
__index = function(self, id)
|
||
local default = {}
|
||
self[id] = default
|
||
return default
|
||
end
|
||
})
|
||
_G.debugdesktopmap = desktopMap
|
||
|
||
local function clearDesktopMap()
|
||
for k,v in pairs(desktopMap) do
|
||
desktopMap[k] = nil
|
||
end
|
||
end
|
||
|
||
local function getDesktopSize()
|
||
local w,h = term.getSize()
|
||
if lOS.tbSize then
|
||
h = h - lOS.tbSize
|
||
end
|
||
local deskW,deskH = math.floor((w+1)/8),math.floor(h/5)
|
||
return deskW,deskH
|
||
end
|
||
|
||
local currentSize
|
||
do
|
||
local desktopWidth,desktopHeight = getDesktopSize()
|
||
currentSize = desktopWidth..","..desktopHeight
|
||
end
|
||
if not dConfig.sizes[currentSize] then
|
||
dConfig.sizes[currentSize] = {}
|
||
end
|
||
|
||
local function reloadDesktop()
|
||
|
||
if not fs.exists("User/Desktop") then
|
||
fs.makeDir("User/Desktop")
|
||
end
|
||
|
||
local desktopFiles = fs.list("User/Desktop")
|
||
local changed = false
|
||
for f=1,#desktopFiles do
|
||
local name = desktopFiles[f]
|
||
|
||
if not idReference[name] then
|
||
idReference[name] = currentID
|
||
dConfig.files[currentID] = name
|
||
currentID = currentID+1
|
||
changed = true
|
||
end
|
||
|
||
end
|
||
|
||
if changed then
|
||
lUtils.asset.save(dConfig,"LevelOS/data/desktop.lconf")
|
||
end
|
||
-- i only need to store position, but if i store them based on names everything gets messed up if a file gets renamed...
|
||
-- iterate through IDs too to see if theres a file there that doesnt exist anymore wait nah just do in the thing actually wait hmm
|
||
|
||
end
|
||
|
||
reloadDesktop()
|
||
|
||
local function drawBackground(background)
|
||
for i=0,15 do
|
||
term.setPaletteColor(2^i,term.nativePaletteColor(2^i))
|
||
end
|
||
if not background then
|
||
term.setBackgroundColor(colors.white)
|
||
term.clear()
|
||
elseif background.path and fs.exists(background.path) then
|
||
local col = background.color or colors.white
|
||
local tw,th = term.getSize()
|
||
local rImg
|
||
local img
|
||
local w,h
|
||
local t = lUtils.getFileType(background.path)
|
||
if t == ".bimg" or t == ".limg" or t == ".nfg" then
|
||
img = lUtils.asset.load(background.path)
|
||
rImg = img[1]
|
||
w = #rImg[1][1]
|
||
h = #rImg
|
||
elseif t == ".nfp" then
|
||
rImg = lUtils.fread(background.path)
|
||
h = 0
|
||
w = 0
|
||
local emptyLine = false
|
||
for line in rImg:gmatch("([^\n]*)\n?") do
|
||
w = math.max(w,#line)
|
||
h = h+1
|
||
if line == "" then
|
||
emptyLine = true
|
||
else
|
||
emptyLine = false -- only if emptyLine is at end itll be true, very good
|
||
end
|
||
end
|
||
if emptyLine then -- fking craftos pc man
|
||
h = h-1
|
||
end
|
||
end
|
||
if background.resize == "stretch" then
|
||
local tWin = window.create(term.current(),1,1,w,h,false)
|
||
local oterm = term.current()
|
||
term.redirect(tWin)
|
||
term.setBackgroundColor(col)
|
||
term.clear()
|
||
lUtils.renderImg(rImg,1,1)
|
||
term.redirect(oterm)
|
||
if h/w > th/tw then -- height should overflow, width equals screen width
|
||
local iw,ih=tw,math.floor(tw*(h/w)+0.5)
|
||
local lWin = lUtils.littlewin(tWin,iw,ih)
|
||
lWin.render(1,math.floor(th/2-ih/2)+1)
|
||
else
|
||
local iw,ih=math.floor(th*(w/h)+0.5),th
|
||
local lWin = lUtils.littlewin(tWin,iw,ih)
|
||
lWin.render(math.floor(tw/2-iw/2)+1,1)
|
||
end
|
||
elseif background.resize == "center" then
|
||
lUtils.renderImg(rImg,math.floor(tw/2-w/2)+1,math.floor(th/2-h/2)+1,nil,true)
|
||
elseif background.resize == "repeat" or true then
|
||
local rw,rh = math.ceil(tw/w),math.ceil(th/h)
|
||
local frame = 1
|
||
for ry=0,rh-1 do
|
||
for rx=0,rw-1 do
|
||
if img then
|
||
lUtils.renderImg(img[frame],1+rx*w,1+ry*h,nil,true)
|
||
frame = frame+1
|
||
if frame > #img then
|
||
frame = 1
|
||
end
|
||
else
|
||
lUtils.renderImg(rImg,1+rx*w,1+ry*h,nil,true)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
elseif background.color then
|
||
term.setBackgroundColor(background.color)
|
||
term.clear()
|
||
end
|
||
end
|
||
local selected = {}
|
||
local drag
|
||
local oldWidth,oldHeight = getDesktopSize()
|
||
local function render(dodebug)
|
||
term.redirect(terminal)
|
||
-- if not position gen position
|
||
-- make order table with IDs, then sort that table and iterate through
|
||
local dolog
|
||
|
||
|
||
if lOS.explorer.desktopBackground then
|
||
local dw,dh = lOS.explorer.desktopBackground.getSize()
|
||
local tw,th = term.getSize()
|
||
if dh ~= th-lOS.tbSize then
|
||
lOS.explorer.desktopBackground = nil
|
||
else
|
||
lOS.explorer.desktopBackground.setVisible(true)
|
||
lOS.explorer.desktopBackground.setVisible(false)
|
||
end
|
||
end
|
||
if not lOS.explorer.desktopBackground then
|
||
local col = dConfig.background.color or colors.white
|
||
local tw,th = term.getSize()
|
||
th = th-lOS.tbSize
|
||
local cTerm = term.current()
|
||
local bWin = window.create(term.current(),1,1,tw,th,true)
|
||
term.redirect(bWin)
|
||
term.setBackgroundColor(col)
|
||
term.clear()
|
||
if dConfig.background and dConfig.background[1] and type(dConfig.background[1]) == "table" then
|
||
for t=1,#dConfig.background do
|
||
drawBackground(dConfig.background[t])
|
||
end
|
||
else
|
||
drawBackground(dConfig.background)
|
||
end
|
||
term.redirect(cTerm)
|
||
lOS.explorer.desktopBackground = bWin
|
||
lOS.explorer.desktopBackground.setVisible(false)
|
||
end
|
||
|
||
term.setTextColor(dConfig.textColor or colors.black)
|
||
local newWidth,newHeight = getDesktopSize()
|
||
if oldWidth ~= newWidth or oldHeight ~= newHeight then
|
||
currentSize = newWidth..","..newHeight
|
||
oldWidth = newWidth
|
||
oldHeight = newHeight
|
||
if not dConfig.sizes[currentSize] then
|
||
dConfig.sizes[currentSize] = {}
|
||
end
|
||
clearDesktopMap()
|
||
end
|
||
local order = {}
|
||
for path,id in pairs(idReference) do
|
||
local absolutePath = fc("User/Desktop",path)
|
||
if not fs.exists(absolutePath) then
|
||
if dConfig.sizes[currentSize][id] then
|
||
local self = dConfig.sizes[currentSize][id]
|
||
if desktopMap[self.x] then
|
||
desktopMap[self.x][self.y] = nil
|
||
end
|
||
dConfig.sizes[currentSize][id] = nil
|
||
end
|
||
idReference[path] = nil
|
||
dConfig.files[id] = nil
|
||
else
|
||
table.insert(order,id)
|
||
end
|
||
end
|
||
table.sort(order)
|
||
local icons = dConfig.sizes[currentSize]
|
||
for i=1,#order do
|
||
local id = order[i]
|
||
if not icons[id] then
|
||
icons[id] = {}
|
||
end
|
||
if not icons[id].x or not icons[id].y then
|
||
local x,y = 1,1
|
||
local success = true
|
||
while desktopMap[x][y] do
|
||
y = y+1
|
||
if y > newHeight then
|
||
y = 1
|
||
x = x+1
|
||
if x > newWidth then
|
||
success = false
|
||
break
|
||
end
|
||
end
|
||
end
|
||
if success then
|
||
icons[id].x,icons[id].y = x,y
|
||
desktopMap[x][y] = id
|
||
end
|
||
end
|
||
if icons[id].x and icons[id].y and not selected[id] then
|
||
local x,y = icons[id].x,icons[id].y
|
||
desktopMap[x][y] = id
|
||
local path = fc("User/Desktop",dConfig.files[id])
|
||
local maxLines = 1
|
||
term.setBackgroundColor(colors.white)
|
||
lOS.explorer.drawIcon(path,1+(x-1)*8,1+(y-1)*5,false,true,maxLines,{"\24","0","8"})
|
||
end
|
||
--os.sleep(0.5)
|
||
end
|
||
for id,v in pairs(selected) do
|
||
if not icons[id] then
|
||
selected[id] = nil
|
||
else
|
||
local x,y = icons[id].x,icons[id].y
|
||
local path = fc("User/Desktop",dConfig.files[id])
|
||
local maxLines = 4
|
||
term.setBackgroundColor(colors.lightBlue)
|
||
lOS.explorer.drawIcon(path,1+(x-1)*8,1+(y-1)*5,false,false,maxLines,{"\24","0","8"})
|
||
end
|
||
end
|
||
if drag and drag.moved then
|
||
lOS.explorer.drawIcon(fc("User/Desktop",dConfig.files[drag.id]),drag.x-drag.ox,drag.y-drag.oy,false,true,1,{"\24","0","8"})
|
||
end
|
||
end
|
||
|
||
|
||
-- CONTEXT MENU FUNCTIONS
|
||
|
||
local fTypes = fileTypes
|
||
local function fExec(obj)
|
||
local f = obj.file
|
||
--[[local num = obj.num
|
||
local p = fTypes[f.type].c[2][num]]
|
||
local p = obj.p
|
||
if p == "Lua" then
|
||
lOS.execute(f.path)
|
||
else
|
||
lOS.execute(p.." "..f.path)
|
||
end
|
||
end
|
||
lOS.explorer.fExec = fExec
|
||
|
||
local function fOpenWin(obj)
|
||
local f = obj.file
|
||
lOS.execute("Program_Files/LevelOS/Explorer "..f.path)
|
||
end
|
||
lOS.explorer.fOpenWin = fOpenWin
|
||
|
||
function lOS.explorer.fRename(obj,s,sl,render,LevelOS,isDesktop)
|
||
if type(obj) == "string" then
|
||
if isDesktop then
|
||
for i,v in pairs(dConfig.sizes[currentSize]) do
|
||
_G.debugcompare = {}
|
||
if obj == fs.combine("User/Desktop",dConfig.files[i]) then
|
||
local f = genFile(obj)
|
||
local x,y = v.x,v.y
|
||
f.x1,f.y1 = 1+(x-1)*8,1+(y-1)*5
|
||
local lineH = math.min(#lUtils.wordwrap(lUtils.getFileName(f.path),7),4)
|
||
f.x2,f.y2 = f.x1+6,f.y1+3+lineH
|
||
obj = {file=f}
|
||
break
|
||
end
|
||
table.insert(debugcompare,{obj,fs.combine("User/Desktop",dConfig.files[i])})
|
||
end
|
||
if type(obj) == "string" then
|
||
error("not found")
|
||
end
|
||
else
|
||
for k,v in ipairs(sl.files) do
|
||
if v.path == obj then
|
||
obj = {file=v}
|
||
break
|
||
end
|
||
end
|
||
end
|
||
end
|
||
LevelOS.overlay = nil
|
||
local f = obj.file
|
||
sl.renaming = f.path
|
||
if isDesktop then
|
||
term.setBackgroundColor(colors.white)
|
||
term.setTextColor(colors.black)
|
||
else
|
||
term.setBackgroundColor(colors.pink)
|
||
opink = {s.win.getPaletteColor(colors.pink)}
|
||
sl.opink = opink
|
||
s.win.setPaletteColor(colors.pink,0.15,0.15,0.15)
|
||
term.setTextColor(colors.white)
|
||
end
|
||
local fname
|
||
local isShortcut = false
|
||
if lUtils.getFileType(f.path) == ".llnk" then
|
||
fname = lUtils.getFileName(f.path,false)
|
||
isShortcut = true
|
||
else
|
||
fname = lUtils.getFileName(f.path,true)
|
||
end
|
||
fname = fname:gsub(" ","_")
|
||
local w,h = term.getSize()
|
||
if sl.rMode == 1 then
|
||
sl.renamebox = lUtils.input(sl.NAME.x+2,f.y2,sl.NAME.x+sl.NAME.width-2,f.y2,{overflowX="scroll",overflowY="none",text=fname,selectColor=colors.blue})
|
||
sl.renamebox.x2 = math.min(math.max(sl.NAME.width,#sl.renamebox.txt+5),w)
|
||
else
|
||
sl.renamebox = lUtils.input(f.x1,f.y1+4,f.x2,f.y2,{overflowX="scroll",overflowY="none",text=fname,selectColor=colors.blue}) -- ah fuck ah FCK shit fuck
|
||
if isDesktop then
|
||
sl.renamebox.opt.selectTxtColor = colors.white
|
||
end
|
||
-- put renamebox in sl or something i guess FUCK why did i make it this way
|
||
end
|
||
local renamebox = sl.renamebox
|
||
renamebox.isShortcut = isShortcut
|
||
renamebox.scrollX = 0
|
||
renamebox.state = true
|
||
local ext = lUtils.getFileType(f.path)
|
||
if ext == ".llnk" then
|
||
ext = ""
|
||
end
|
||
renamebox.select = {1,#fname-#ext}
|
||
renamebox.cursor.a = 1+#fname-#ext
|
||
renamebox.cursor.x = renamebox.cursor.a
|
||
renamebox.update("timer")
|
||
local ok,err = pcall(function() render(true) end)
|
||
if not ok then
|
||
lOS.bsod(err)
|
||
end
|
||
renamebox.render()
|
||
os.queueEvent("renamebox")
|
||
end
|
||
|
||
local function fInvShort(obj,updateFiles,render)
|
||
local o = {lUtils.popup("Problem with shortcut","The item '"..obj.file.sName.."' that this shortcut refers to has been changed or moved, so this shortcut will no longer work properly.\n\nDo you want to delete this shortcut?",37,13,{"Yes","No"})}
|
||
if o[1] and o[3] == "Yes" then
|
||
fs.delete(obj.file.path)
|
||
updateFiles()
|
||
end
|
||
term.setTextColor(colors.white)
|
||
render()
|
||
end
|
||
lOS.explorer.fInvShort = fInvShort
|
||
|
||
local function genContextMenu(f,s,sl,selected,updateFiles,render,LevelOS,isDesktop)
|
||
local shortcache = lOS.explorer.shortcache
|
||
local winObj = term.current()
|
||
|
||
local function fInvShortInternal(obj)
|
||
term.redirect(winObj)
|
||
LevelOS.overlay = nil
|
||
lOS.noEvents = false
|
||
LevelOS.self.window.events = nil
|
||
fInvShort(obj,updateFiles,render)
|
||
term.setTextColor(colors.white)
|
||
end
|
||
|
||
local function fDelete(obj)
|
||
for k,v in pairs(selected) do
|
||
fs.delete(k)
|
||
end
|
||
selected = {}
|
||
updateFiles()
|
||
end
|
||
|
||
local function fOpen(obj)
|
||
local f = obj.file
|
||
selected = {}
|
||
sl.folder = f.path
|
||
updateFiles()
|
||
scrollY = 0
|
||
end
|
||
|
||
local function fCut(obj)
|
||
lOS.fClipboard = {}
|
||
for k,v in pairs(selected) do
|
||
table.insert(lOS.fClipboard,k)
|
||
end
|
||
lOS.fCut = lUtils.instantiate(lOS.fClipboard)
|
||
selected = {}
|
||
end
|
||
|
||
local function fCopy(obj)
|
||
lOS.fClipboard = {}
|
||
lOS.fCut = {}
|
||
for k,v in pairs(selected) do
|
||
table.insert(lOS.fClipboard,k)
|
||
end
|
||
end
|
||
|
||
local function fPaste(obj)
|
||
local tFolder = sl.folder
|
||
for c=1,#lOS.fClipboard do
|
||
if fs.exists(lOS.fClipboard[c]) == true then
|
||
fs.copy(lOS.fClipboard[c],uFP(fs.combine(tFolder,fs.getName(lOS.fClipboard[c]))))
|
||
end
|
||
if locateEntry(lOS.fCut,lOS.fClipboard[c]) == true then
|
||
fs.delete(lOS.fClipboard[c])
|
||
table.remove(lOS.fCut,({locateEntry(lOS.fCut,lOS.fClipboard[c])})[2])
|
||
end
|
||
end
|
||
lOS.fClipboard = {}
|
||
lOS.fCut = {}
|
||
updateFiles()
|
||
end
|
||
|
||
local opink
|
||
local function fRename(obj)
|
||
lOS.explorer.fRename(obj,s,sl,render,LevelOS,isDesktop)
|
||
if isDesktop then
|
||
local renamebox = sl.renamebox
|
||
term.redirect(terminal)
|
||
render()
|
||
renamebox.render()
|
||
lOS.noEvents = false
|
||
while true do
|
||
local e = {os.pullEventRaw()}
|
||
if e[1] == "char" and e[2] == " " then
|
||
e[2] = "_"
|
||
end
|
||
if e[1] == "key" and e[2] == keys.enter then
|
||
renamebox.state = false
|
||
--sl.renaming = nil
|
||
else
|
||
renamebox.update(unpack(e))
|
||
--render()
|
||
renamebox.render()
|
||
end
|
||
if not renamebox.state then
|
||
local pth = fs.combine("User/Desktop",renamebox.txt)
|
||
if renamebox.isShortcut then
|
||
pth = pth..".llnk"
|
||
end
|
||
if pth == sl.renaming or fs.combine(pth,"") == "User/Desktop" then
|
||
-- nothing
|
||
elseif fs.exists(pth) then
|
||
local newPth = uFP(pth)
|
||
local r = {lUtils.popup("Rename File","Do you want to rename \""..fs.getName(sl.renaming):gsub("_"," ").."\" to \""..fs.getName(newPth):gsub("_"," ").."\"?\n\nThere is already a file with the same name in this location.",41,11,{"Yes","No"})}
|
||
if r[1] and r[3] == "Yes" then
|
||
fs.move(sl.renaming,newPth)
|
||
end
|
||
else
|
||
fs.move(sl.renaming,pth)
|
||
end
|
||
renamebox = nil
|
||
sl.renamebox = nil
|
||
sl.renaming = nil
|
||
term.setCursorBlink(false)
|
||
updateFiles()
|
||
render()
|
||
break
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
local function fNew(obj)
|
||
local pth = uFP(fs.combine(sl.folder,"New_"..obj.txt:gsub(" ","_").."."..obj.format))
|
||
lUtils.fwrite(pth,obj.preset)
|
||
term.redirect(winObj)
|
||
updateFiles()
|
||
render()
|
||
fRename(pth)
|
||
-- rename
|
||
end
|
||
|
||
local function fNewFolder(obj)
|
||
local pth = uFP(fs.combine(sl.folder,"New_Folder"))
|
||
fs.makeDir(pth)
|
||
term.redirect(winObj)
|
||
updateFiles()
|
||
render()
|
||
fRename(pth)
|
||
-- rename
|
||
end
|
||
|
||
local function fOpenWith(obj)
|
||
if LevelOS and LevelOS.self and LevelOS.self.window then
|
||
LevelOS.self.window.events = nil
|
||
end
|
||
LevelOS.overlay = nil
|
||
lOS.noEvents = false
|
||
local p = sl.openWith(obj.file)
|
||
if p then
|
||
p = p.path
|
||
local f = obj.file
|
||
if p == "Lua" then
|
||
lOS.execute(f.path)
|
||
else
|
||
lOS.execute(p.." "..f.path)
|
||
end
|
||
end
|
||
end
|
||
|
||
local function fPin(obj)
|
||
table.insert(sl.config.quickaccess,obj.file.path)
|
||
sl.saveConfig()
|
||
sl.reloadQuickAccess()
|
||
end
|
||
|
||
local function fUnpin(obj)
|
||
local s,i = locateEntry(sl.config.quickaccess,obj.file.path)
|
||
if s then
|
||
table.remove(sl.config.quickaccess,i)
|
||
sl.saveConfig()
|
||
sl.reloadQuickAccess()
|
||
end
|
||
end
|
||
|
||
local function fShortcut(obj)
|
||
local pth = uFP(fs.combine(obj.folder,obj.name:gsub(" ","_").."_-_Shortcut.llnk"))
|
||
lUtils.asset.save({obj.file.path},pth)
|
||
updateFiles()
|
||
render()
|
||
end
|
||
|
||
local function fDesktopShortcut(obj)
|
||
lOS.genIco(obj.file.path)
|
||
--[[local pth = uFP(fs.combine(obj.folder,obj.name:gsub(" ","_")..".llnk"))
|
||
lUtils.asset.save({obj.file.path},pth)
|
||
os.queueEvent("explorer_reload")]]
|
||
end
|
||
|
||
local function fBackground(obj)
|
||
lOS.explorer.desktopConfig.background = {path=obj.file.path,resize=obj.txt:lower()}
|
||
os.queueEvent("explorer_reload")
|
||
end
|
||
|
||
local function fAddToBackground(obj)
|
||
local dConfig = lOS.explorer.desktopConfig
|
||
if not dConfig.background[1] then
|
||
local obg = dConfig.background
|
||
dConfig.background = {color=obg.color,obg}
|
||
end
|
||
table.insert(dConfig.background,{path=obj.file.path,resize=obj.txt:lower()})
|
||
os.queueEvent("explorer_reload")
|
||
lOS.explorer.desktopBackground = nil
|
||
end
|
||
|
||
local function fCopyPath(obj)
|
||
ccemux.setClipboard(obj.file.path)
|
||
end
|
||
|
||
if isDesktop then
|
||
fOpen = fOpenWin
|
||
end
|
||
|
||
local options
|
||
if not f then
|
||
local newfiles = {}
|
||
for k,v in pairs(fTypes) do
|
||
if type(v) == "table" and type(v.emptyFilePreset) == "string" then
|
||
table.insert(newfiles,{txt=v.name,preset=v.emptyFilePreset,action=fNew,format=k})
|
||
end
|
||
end
|
||
table.insert(newfiles,{txt="bImg Icon",preset='{{{" "," "," "},{" "," "," "},{" "," "," "}}}',action=fNew,format="bimg"})
|
||
local opt = {
|
||
{{txt="Refresh",action=updateFiles}},
|
||
{{txt="Paste",action=fPaste,disabled=(#lOS.fClipboard == 0 or fs.isReadOnly(sl.folder))}},
|
||
{{txt="New",disabled=(fs.isReadOnly(sl.folder)),action={{txt="Folder",action=fNewFolder},newfiles}}} -- import from formats.lconf
|
||
}
|
||
if isDesktop then
|
||
local txtcolors = {}
|
||
for k,v in pairs(colors) do
|
||
if type(v) == "number" then
|
||
table.insert(txtcolors,k)
|
||
end
|
||
end
|
||
table.sort(txtcolors)
|
||
local txtcoloroptions = {}
|
||
for c=1,#txtcolors do
|
||
local col = colors[txtcolors[c]]
|
||
local name = txtcolors[c]:sub(1,1):upper()..txtcolors[c]:sub(2)
|
||
local b = lUtils.toBlit(col)
|
||
if dConfig.textColor == col then
|
||
table.insert(txtcoloroptions,{txt={" \7 "..name,nil,string.rep(b,3)}})
|
||
if col == colors.white then
|
||
txtcoloroptions[#txtcoloroptions].txt[2] = "fff"
|
||
end
|
||
else
|
||
table.insert(txtcoloroptions,{txt={" "..name,nil,string.rep(b,3)},action=function() dConfig.textColor = col updateFiles() render() end})
|
||
end
|
||
end
|
||
if not dConfig.textColor then
|
||
table.insert(txtcoloroptions,1,{txt=" \7 Automatic"})
|
||
else
|
||
table.insert(txtcoloroptions,1,{txt=" Automatic",action=function() dConfig.textColor = nil updateFiles() render() end})
|
||
end
|
||
table.insert(opt[1],1,{txt="View",action={
|
||
{txt="Text color",action={txtcoloroptions}}
|
||
}})
|
||
end
|
||
if ccemux then
|
||
table.insert(opt,{{txt="Open External Explorer",action=function() ccemux.openDataDir() end}})
|
||
end
|
||
options = opt
|
||
else
|
||
if type(f) == "string" then
|
||
f = genFile(f)
|
||
end
|
||
local file = f.path
|
||
local nf = f
|
||
local invalidShort
|
||
if shortcache[file] then
|
||
f.sPath = shortcache[file][1]
|
||
f.sName = fs.getName(f.sPath)
|
||
if fs.exists(f.sPath) then
|
||
nf = genFile(f.sPath)
|
||
else
|
||
invalidShort = true
|
||
end
|
||
end
|
||
options = {
|
||
{
|
||
|
||
},
|
||
{
|
||
{txt="Cut",action=fCut},
|
||
{txt="Copy",action=fCopy}
|
||
},
|
||
{
|
||
{txt="Delete",action=fDelete},
|
||
{txt="Rename",action=fRename,file=f,sl=sl}
|
||
}
|
||
}
|
||
local createshortcut = {txt="Create shortcut",file=nf,folder=sl.folder,name=nf.name,action=fShortcut}
|
||
local createshortcut2 = {txt="Create shortcut on desktop",file=nf,folder="User/Desktop",name=nf.name,action=fDesktopShortcut}
|
||
if fs.getName(nf.path) == "main.lua" then
|
||
createshortcut.name = fs.getName(fs.getDir(nf.path))
|
||
createshortcut2.name = fs.getName(fs.getDir(nf.path))
|
||
end
|
||
if invalidShort then
|
||
createshortcut.action = fInvShortInternal
|
||
createshortcut2.action = fInvShortInternal
|
||
end
|
||
if not isDesktop then
|
||
table.insert(options[3],1,createshortcut2)
|
||
table.insert(options[3],1,createshortcut)
|
||
end
|
||
local disabled = {}
|
||
if f.readOnly == true then
|
||
disabled = {Edit=true,Cut=true,Delete=true,Rename=true}
|
||
elseif disks[file] ~= nil then
|
||
disabled = {Edit=true,Cut=true,Delete=true,Rename=true}
|
||
disabled["Create Shortcut"] = true
|
||
end
|
||
local fc = fs.combine
|
||
if ccemux then
|
||
table.insert(options[3],{txt="Copy path",file=f,action=fCopyPath})
|
||
end
|
||
local fOpen = fOpen
|
||
local fOpenWin = fOpenWin
|
||
local fOpenWith = fOpenWith
|
||
local fExec = fExec
|
||
local fUnpin = fUnpin
|
||
local fPin = fPin
|
||
if invalidShort then
|
||
fOpen = fInvShortInternal
|
||
fOpenWin = fInvShortInternal
|
||
fOpenWith = fInvShortInternal
|
||
fExec = fInvShortInternal
|
||
fUnpin = fInvShortInternal
|
||
fPin = fInvShortInternal
|
||
end
|
||
if nf.isDir then
|
||
local etxt = ""
|
||
local isProgram = false
|
||
if fs.exists(fc(nf.path,"main.lua")) then
|
||
isProgram = true
|
||
etxt = "folder "
|
||
end
|
||
options[1] = {{txt="Open "..etxt,action=fOpen,file=nf}}
|
||
if not isDesktop then
|
||
table.insert(options[1],{txt="Open "..etxt.."in new window",action=fOpenWin,file=nf})
|
||
end
|
||
if isProgram then
|
||
table.insert(options[1],{txt="Execute",action=fExec,p="Lua",file=nf})
|
||
createshortcut.action = {{txt="To program",file=genFile(fc(nf.path,"main.lua")),folder=sl.folder,name=nf.name,action=fShortcut},{txt="To folder",file=nf,folder=sl.folder,name=nf.name,action=fShortcut}}
|
||
end
|
||
if not isDesktop then
|
||
if locateEntry(sl.config.quickaccess,nf.path) then
|
||
table.insert(options[1],{txt="Unpin from Quick access",action=fUnpin,file=nf})
|
||
else
|
||
table.insert(options[1],{txt="Pin to Quick access",action=fPin,file=nf})
|
||
end
|
||
end
|
||
elseif fTypes[nf.type] and fTypes[nf.type].contextMenu and not invalidShort then
|
||
local tbl = {}
|
||
for k,v in ipairs(fTypes[nf.type].contextMenu[1]) do
|
||
table.insert(tbl,{txt=v,file=nf,p=fTypes[nf.type].contextMenu[2][k],action=fExec})
|
||
end
|
||
if nf.type == "bimg" or nf.type == "limg" or nf.type == "nfp" then
|
||
table.insert(tbl,{txt="Set as desktop background",action={{{txt="Stretch",file=nf,action=fBackground},{txt="Repeat",file=nf,action=fBackground},{txt="Center",file=nf,action=fBackground}}}})
|
||
table.insert(tbl,{txt="Add to desktop background",action={{{txt="Repeat",file=nf,action=fAddToBackground},{txt="Center",file=nf,action=fAddToBackground}}},disabled=(not lOS.explorer.desktopConfig.background)})
|
||
end
|
||
options[1] = tbl
|
||
else
|
||
options[1] = {{txt="Edit",action=fExec,p="rom/programs/edit.lua",file=nf}}
|
||
end
|
||
if shortcache[file] then
|
||
if invalidShort then
|
||
table.insert(options[1],2,{txt="Open file location",disabled=true})
|
||
else
|
||
table.insert(options[1],2,{txt="Open file location",action=fOpen,file=genFile(fs.getDir(nf.path))})
|
||
end
|
||
end
|
||
local ow
|
||
if fTypes[nf.type] and fTypes[nf.type].openWith and not nf.isDir then
|
||
local owtbl = {}
|
||
for k,v in ipairs(fTypes[nf.type].openWith) do
|
||
table.insert(owtbl,{txt=lUtils.getFileName(v),file=nf,p=v,action=fExec})
|
||
end
|
||
ow = {txt="Open with",action={owtbl,{txt="Choose another app",action=fOpenWith,file=nf,disabled=isDesktop}}}
|
||
if invalidShort then
|
||
ow.disabled = true
|
||
end
|
||
table.insert(options[1],ow)
|
||
end
|
||
if nf.readOnly == true --[[and locateEntry(options[1],"Edit") == true]] then
|
||
for k,v in ipairs(options[1]) do
|
||
if type(v) == "table" and v.txt == "Edit" then
|
||
v.txt = "View"
|
||
end
|
||
end
|
||
--options[1][({locateEntry(options[1],"Edit")})[2]] = "View"
|
||
end
|
||
for _,cat in ipairs(options) do
|
||
for k,v in ipairs(cat) do
|
||
if type(v) == "string" and disabled[v] then
|
||
cat[k] = {txt=v,disabled=true}
|
||
elseif type(v) == "table" and disabled[v.txt] then
|
||
v.disabled = true
|
||
end
|
||
end
|
||
end
|
||
end
|
||
return options
|
||
end
|
||
|
||
lOS.explorer.genContextMenu = genContextMenu
|
||
|
||
local function cMenu(f, x, y)
|
||
local sel = {}
|
||
for k,v in pairs(selected) do
|
||
local path = fc("User/Desktop",dConfig.files[k])
|
||
sel[path] = true
|
||
end
|
||
local options = genContextMenu(f,{win=term.current()},{folder="User/Desktop"},sel,reloadDesktop,render,LevelOS,true)
|
||
local output = {lOS.contextmenu(x,y,30,options,nil,true)}
|
||
return unpack(output)
|
||
end
|
||
|
||
render()
|
||
os.sleep(0.05)
|
||
render()
|
||
local lastUpdate = os.epoch("utc")
|
||
local tID = os.startTimer(10)
|
||
while true do
|
||
local e = {os.pullEvent()}
|
||
if e[1] == "explorer_full_reload" then
|
||
lOS.explorer.shortcache = {}
|
||
lOS.explorer.imgcache = {}
|
||
lOS.explorer.nimgcache = {}
|
||
lOS.explorer.desktopBackground = nil
|
||
reloadDesktop()
|
||
render()
|
||
elseif e[1] == "term_resize" or e[1] == "explorer_reload" then
|
||
lOS.explorer.desktopBackground = nil
|
||
reloadDesktop()
|
||
render()
|
||
elseif e[1]:find("mouse") and e[3] and e[4] then
|
||
local x,y = math.ceil(e[3]/8),math.ceil(e[4]/5)
|
||
if e[1] == "mouse_click" then
|
||
lOS.focusWin = lOS.wins[0]
|
||
end
|
||
if e[1] == "mouse_drag" and drag then
|
||
drag.x,drag.y = e[3],e[4]
|
||
drag.moved = true
|
||
render()
|
||
elseif e[1] == "mouse_up" and drag then
|
||
if not desktopMap[x][y] then
|
||
desktopMap[x][y] = drag.id
|
||
local icon = dConfig.sizes[currentSize][drag.id]
|
||
desktopMap[icon.x][icon.y] = nil
|
||
icon.x,icon.y = x,y
|
||
lUtils.asset.save(dConfig,"LevelOS/data/desktop.lconf")
|
||
end
|
||
drag = nil
|
||
render()
|
||
elseif e[3]%8 ~= 0 and desktopMap[x][y] then
|
||
if e[1] == "mouse_click" then
|
||
local id = desktopMap[x][y]
|
||
if selected[id] and os.epoch("utc") < selected[id]+500 and e[2] == 1 then
|
||
local path = fc("User/Desktop",dConfig.files[id])
|
||
local rPath = path
|
||
local cmd = path
|
||
local shortcache = lOS.explorer.shortcache
|
||
local exec = false
|
||
local invalidShort = false
|
||
local f = genFile(path)
|
||
if shortcache[path] then
|
||
cmd = shortcache[path][1]
|
||
rPath = cmd
|
||
f.sName = rPath
|
||
if not fs.exists(rPath) then
|
||
invalidShort = true
|
||
end
|
||
if shortcache[path].args and #shortcache[path].args > 0 then
|
||
cmd = cmd.." "..table.concat(shortcache[path].args)
|
||
end
|
||
if shortcache[path].program then
|
||
if shortcache[path].program ~= "Lua" then
|
||
cmd = shortcache[path].program.." "..cmd
|
||
end
|
||
exec = true
|
||
end
|
||
end
|
||
if invalidShort then
|
||
fInvShort({file=f},reloadDesktop,render)
|
||
else
|
||
local fType = lUtils.getFileType(rPath):sub(2)
|
||
if exec then
|
||
lOS.execute(cmd)
|
||
elseif fs.isDir(rPath) then
|
||
lOS.execute("Program_Files/LevelOS/Explorer "..cmd)
|
||
elseif fileTypes[fType] and fileTypes[fType].program then
|
||
local p = fileTypes[fType].program
|
||
if p == "Lua" then
|
||
lOS.execute(cmd)
|
||
else
|
||
lOS.execute(p.." "..cmd)
|
||
end
|
||
elseif fType == "" then
|
||
lOS.execute(cmd)
|
||
end
|
||
end
|
||
selected = {}
|
||
else
|
||
if not (lUtils.isHolding(keys.leftCtrl) or lUtils.isHolding(keys.leftShift)) then
|
||
selected = {}
|
||
end
|
||
if e[2] == 1 then
|
||
selected[id] = os.epoch("utc")
|
||
drag = {id=id,ox=(e[3]-1)%8,oy=(e[4]-1)%5,x=e[3],y=e[4],moved=false}
|
||
else
|
||
selected[id] = 0
|
||
end
|
||
end
|
||
render()
|
||
elseif e[1] == "mouse_up" and e[2] == 2 then
|
||
local id = desktopMap[x][y]
|
||
local path = fc("User/Desktop",dConfig.files[id])
|
||
--[[local rPath = path
|
||
local cmd = path
|
||
local shortcache = lOS.explorer.shortcache
|
||
local exec = false]]
|
||
local f = genFile(path)
|
||
f.x1,f.y1 = 1+(x-1)*8,1+(y-1)*5
|
||
local lineH = math.min(#lUtils.wordwrap(lUtils.getFileName(f.path),7),4)
|
||
f.x2,f.y2 = f.x1+6,f.y1+3+lineH
|
||
cMenu(f,e[3],e[4])
|
||
end
|
||
elseif e[1] == "mouse_click" and not (lUtils.isHolding(keys.leftCtrl) or lUtils.isHolding(keys.leftShift)) then
|
||
selected = {}
|
||
render()
|
||
if e[2] == 2 then
|
||
cMenu(nil, e[3], e[4])
|
||
end
|
||
end
|
||
elseif (e[1] == "timer" and e[2] == tID) or os.epoch("utc")-10000 > lastUpdate then
|
||
lastUpdate = os.epoch("utc")
|
||
if not (e[1] == "timer" and e[2] == tID) then
|
||
os.cancelTimer(tID)
|
||
end
|
||
tID = os.startTimer(10)
|
||
reloadDesktop()
|
||
render()
|
||
end
|
||
if e[1] == "mouse_up" then
|
||
drag = nil
|
||
end
|
||
end |