View difference between Paste ID: VxdRfhTc and YeYhXftV

 -- display API
 -- made by akaJag
 -- work in progress
 
 function round(num)
 	if type(num) ~= "number" then return num end
 	if num%1<.5 then num=math.floor(num) end
 	if num%1>=.5 then num=math.ceil(num) end
 	return num
 end
 
 function setupdaterate(class,s)
 	class.updaterate = s
 end
 
 function getupdaterate(class)
 	return class.updaterate
 end
 
 function removepixles(class)
 	local w,h = class.obj.getSize()
 
 	-- check row
 	local width = next(class.pixles)
 	while width do
 		if width > w or width < 0 then
 			-- remove row
 			local tmpw = width
 			width = next(class.pixles,width)
 			class.pixles[tmpw] = nil
 		else
 			-- check column
 			local height = next(class.pixles[width])
 			while height do
 				if height > h or height < 0 then
 					-- remove column
 					local tmph = height
 					height = next(class.pixles[width],height)
 					class.pixles[width][tmph] = nil
 				else
 					-- next iteration
 					height = next(class.pixles[width],height)
 				end
 			end
 			-- next iteration
 			width = next(class.pixles,width)
 		end
 	end
 end
 
 function fixpixles(class)
 	local w,h = class.obj.getSize()
 	for width = 1,w do
 		if class.pixles[width] == nil then class.pixles[width] = {} end
 		for height = 1,h do
 			if class.pixles[width][height] == nil then
 				class.pixles[width][height] = {sym=" ",bg=colors.black,fg=colors.white}
 			end
 		end
 	end
 end
 
 -- returns:
 --	(number) update time
 function update(class)
 	local startupdate = os.clock()
 
 	class:removepixles()
 	class:fixpixles()
 
 	local endupdate = os.clock()
 	return endupdate - startupdate
 end
 
 function draw(class)
 	local startdraw = os.clock()
 
 	for w in pairs(class.pixles) do
 		for h,pixle in pairs(class.pixles[w]) do
 			class.obj.setCursorPos(w,h)
 			class.obj.setBackgroundColor(pixle.bg or colors.black)
 			class.obj.setTextColor(pixle.fg or colors.white)
 			class.obj.write(pixle.sym or " ")
 		end
 	end
 
 	local enddraw = os.clock()
 	return enddraw - startdraw
 end
 
 -- can be used in a parallel loop
 -- dont forget to do prepareloop() before running
 -- stop it with stoploop()
 function loop(class)
 	if not running then return end
 	local s = class:update()
 	s = s + class:draw()
 	sleep(updaterate - s)
 end
 
 function prepareloop(class)
 	class.looprunning = true
 	class.looptime = os.clock()
 end
 
 -- returns the time the loop has been on
 function stoploop()
 	class.looprunning = false
 	return os.clock - class.looptime
 end
 
 function setcolor(class,fg,bg)
 	class.fgcolor = fg or class.fgcolor
 	class.bgcolor = bg or class.bgcolor
 end
 
 function getcolor(class)
 	return class.fgcolor,class.bgcolor
 end
 
 function setfgcolor(class,col)
 	class.fgcolor = col
 end
 
 function getfgcolor(class)
 	return class.fgcolor
 end
 
 function setbgcolor(class,col)
 	class.bgcolor = col
 end
 
 function getbgcolor(class)
 	return class.bgcolor
 end
 
 -- stroke is only used with "line" draw mode
 function setstroke(class,var)
 	class.stroke=var
 end
 
 function getstroke(class)
 	return class.stroke
 end
 
 -- clears the entire screen
 -- bg = only change background, ignore text
 function clear(class,bg)
 	for w in pairs(class.pixles) do
 		for h,pixle in pairs(class.pixles[w]) do
 			class.pixles[w][h].bg = class.bgcolor
 			if bg ~= true then
 				class.pixles[w][h].sym = " "
 			end
 		end
 	end
 end
 
 -- trans = transparant option
 function write(class,str,x,y,trans)
 	x=round(x) y=round(y)
 	for count = 1,#str do
 		if class.pixles[x+count-1] then
 			if class.pixles[x+count-1][y] then
 				class.pixles[x+count-1][y].sym = str:sub(count,count)
 				class.pixles[x+count-1][y].fg = class.fgcolor
 				if trans ~= true then
 					class.pixles[x+count-1][y].bg = class.bgcolor
 				end
 			end
 		end
 	end
 end
 
 function line(class,x1,y1,x2,y2,bg)
 	-- Bresenham's algorithm
 	local dx = x2 - x1
 	if dx < 0 then dx = -dx end
 	local dy = y2 - y1
 	if dy < 0 then dy = -dy end
 
 	local sx,sy
 	if x1 < x2 then sx = 1
 	else sx = -1 end
 	if y1 < y2 then sy = 1
 	else sy = -1 end
 
 	local err = dx - dy
 
 	repeat
 		local x,y = round(x1),round(y1)
 		if class.pixles[x] then
 			if class.pixles[x][y] then
 				class.pixles[x][y].bg = class.bgcolor
 				if bg ~= true then
 					class.pixles[x][y].sym = " "
 				end
 			end
 		end
 
 		if x1 == x2 and y1 == y2 then break end
 		local e2 = 2*err
 		if e2 > -dy then
 			err = err - dy
 			x1 = x1 + sx
 		end
 		if e2 < dx then
 			err = err + dx
 			y1 = y1 + sy
 		end
 	until false
 end
 
 -- supported modes: fill, line
 -- bg = only set background color
 function rect(class,mode,x1,y1,x2,y2,bg)
 	x1=round(x1) y1=round(y1) x2=round(x2) y2=round(y2)
 	if mode == "fill" then
 		for x = x1,x2 do
 			for y = y1,y2 do
 				if class.pixles[x] ~= nil then
 					if class.pixles[x][y] ~= nil then
 						class.pixles[x][y].bg = class.bgcolor
 						if bg ~= true then
 							class.pixles[x][y].sym = " "
 						end
 					end
 				end
 			end
 		end
 	elseif mode == "line" then
 		-- top line
 		for x = x1,x2 do
 			for y = y1,y1+class.stroke-1 do
 				if class.pixles[x] ~= nil then
 					if class.pixles[x][y] ~= nil then
 						class.pixles[x][y].bg = class.bgcolor
 						if bg ~= true then
 							class.pixles[x][y].sym = " "
 						end
 					end
 				end
 			end
 		end
 		-- bottom line
 		for x = x1,x2 do
 			for y = y2-class.stroke+1,y2 do
 				if class.pixles[x] ~= nil then
 					if class.pixles[x][y] ~= nil then
 						class.pixles[x][y].bg = class.bgcolor
 						if bg ~= true then
 							class.pixles[x][y].sym = " "
 						end
 					end
 				end
 			end
 		end
 		-- right line
 		for x = x2-class.stroke+1,x2 do
 			for y = y1,y2 do
 				if class.pixles[x] ~= nil then
 					if class.pixles [x][y] ~= nil then
 						class.pixles[x][y].bg = class.bgcolor
 						if bg ~= true then
 							class.pixles[x][y].sym = " "
 						end
 					end
 				end
 			end
 		end
 		-- left line
 		for x = x1,x1+class.stroke-1 do
 			for y = y1,y2 do
 				if class.pixles[x] ~= nil then
 					if class.pixles [x][y] ~= nil then
 						class.pixles[x][y].bg = class.bgcolor
 						if bg ~= true then
 							class.pixles[x][y].sym = " "
 						end
 					end
 				end
 			end
 		end
 	end
 end
 
 -- supported modes: fill, line
 -- bg = only set background color
 function circle(class,mode,x,y,r,bg)
 	x=round(x) y=round(y)
 	for w in pairs(class.pixles) do
 		for h in pairs(class.pixles[w]) do
 			-- pythagrias sats
 			-- a^2 + b^2 = c^2
 			local dis = math.sqrt((w-x)^2 + (h-y)^2)
 			if dis <= r then
 				if mode == "fill" or
 				(mode == "line" and dis >= r-class.stroke) then
 					if class.pixles[w] ~= nil then
 						if class.pixles[w][h] ~= nil then
 							class.pixles[w][h].bg = class.bgcolor
 							if bg ~= true then
 								class.pixles[w][h].sym = " "
 							end
 						end
 					end
 				end
 			end
 		end
 	end
 end
 
 local function strtotbl(str)
 	local tbl = {}
 	for uchar in str:gmatch("([%z\1-\127\194-\244][\128-\191]*)") do
 		table.insert(tbl,uchar)
 	end
 	return tbl
 end
 
 local function tbltostr(tbl)
 	local str = ""
 	for _,value in pairs(tbl) do
-	local text = initstr
+		str=str..tostring(value)
-	local padding = text:len()-w
+
-	local cursor = text:len()
+
 
 -- x,y = top left corner of text field
 -- w = width of text field
 -- l = max lenght of text
 -- c = make the text look like a certain character
 -- trans = transparent
 -- callback = function, gets events as parameters, if returns true then exit
 function read(class,x,y,w,l,initstr,c,trans,callback)
 	x=round(x) y=round(y) w=round(w) l=round(l)
 	if type(l)~="number" then l=-1 end
 	if type(initstr)~="string" then initstr="" end
 	local running = true
 	local text = initstr or ""
 	local padding = #text-w
 	local cursor = #text
 
 	callback = callback or function(ev,p1,p2,p3,p4,p5)
 		if ev == "key" and p1 == keys.enter then
 			return true
-			local str = c:rep(math.floor(#text/#c)) .. c:sub(1,#text%#c)
+
 	end
 
-			class:write(text:sub(padding+1,padding+w+1),x,y,true)
+
 		-- fix cursor and padding
 		if cursor > #text then cursor = #text end
 		if cursor < 0 then cursor = 0 end
 		if padding > #text-1 then padding = #text-1 end
 		if padding < 0 then padding = 0 end
 
 		-- drawing
 		if trans ~= true then
 			class:rect("fill",x,y,x+w,y,false)
 		end
 		local tbl = strtotbl(text)
 		if type(c) == "string" then
 			local str = c:rep(math.floor(#tbl/#c)) .. c:sub(1,#tbl%#c)
 			class:write(str:sub(padding+1,padding+w+1),x,y,true)
 		else
 			local count = 0
 			for index = padding+1,padding+w+1 do
 				if text[index] then
 					class:write(text[index],x+count,y,true)
 				end
 				count = count + 1
 			end
 		end
 
 		class:update()
 		class:draw()
 
 		if cursor-padding <= w and cursor-padding >= 0 then
 			class.obj.setCursorPos(x+cursor-padding,y)
 			class.obj.setTextColor(class:getfgcolor())
 			class.obj.setCursorBlink(true)
 		end
 
 		local ev,p1,p2,p3,p4,p5 = os.pullEvent()
 
 		class.obj.setCursorBlink(false)
 
 		if callback(ev,p1,p2,p3,p4,p5) == true then
 			return text,ev,p1,p2,p3,p4,p5
 		end
 		if ev == "key" then
 			if p1 == keys.left then
 				-- move left
 				cursor = cursor - 1
 				if cursor<padding then padding = padding - 1 end
 			elseif p1 == keys.right then
 				-- move right
 				cursor = cursor + 1
 				if cursor-padding > w then padding = padding + 1 end
 			elseif p1 == keys.backspace then
 				-- remove a character
 				local num = cursor-1
 				if num < 0 then num = 0 end
 				text = text:sub(1,num) .. text:sub(cursor+1)
 				cursor = cursor - 1
 				if cursor<padding then padding = padding - 1 end
 			elseif p1 == keys.delete then
 				-- remove a character
 				text = text:sub(1,cursor) .. text:sub(cursor+2)
 			elseif p1 == keys.home then
 				cursor = 0
 				padding = 0
 			elseif p1 == keys["end"] then
 				cursor = text:len()
 				padding = text:len()-w
 			end
 		elseif ev == "char" then
 			if #text < l or l <= 0 then -- check length limit
 				-- add a character
 				text = text:sub(1,cursor) .. p1 .. text:sub(cursor+1)
 				cursor = cursor + 1
 				if cursor-padding > w then padding = padding + 1 end
 			end
 		elseif (ev == "mouse_click" and class.type == "term")
 		or (ev == "monitor_touch" and class.type == "monitor" and p1 == class.path) then
 			-- move cursor
 			-- x=p2, y=p3
 			if p2<x then p2=x end
 			if p2>x+w then p2=x+w end
 			cursor = p2-x+padding
 		elseif ev == "mouse_scroll" then
 			-- scrolling left/right
 			padding = padding + p1
 		end
 	end
 end
 
 function load(objpath)
 	local startload = os.clock()
 
 	tobj = {}
 
 	-- object variables
 	objpath = objpath or "N/A"
 	if peripheral.isPresent(objpath)
 	and peripheral.getType(objpath) == "monitor" then
 		tobj.obj = peripheral.wrap(objpath or "N/A")
 		tobj.type = "monitor"
 		tobj.path = objpath
 		tobj.eventname = "monitor_touch"
 	else
 		tobj.type = "term"
 		tobj.obj = term
 		tobj.path = "N/A"
 		tobj.eventname = "mouse_click"
 	end
 
 	-- variables
 	tobj.pixles = {}
 	tobj.updaterate = 0.2
 	tobj.looprunning = false
 	tobj.looptime = 0
 	tobj.stroke = 1
 	tobj.bgcolor = colors.black
 	tobj.fgcolor = colors.white
 
 	-- misc functions
 	tobj.setupdaterate = setupdaterate
 	tobj.getupdaterate = getupdaterate
 	tobj.removepixles = removepixles
 	tobj.fixpixles = fixpixles
 	tobj.update = update
 	tobj.draw = draw
 	tobj.loop = loop
 	tobj.prepareloop = prepareloop
 	tobj.stoploop = stoploop
 
 	-- color functions
 	tobj.setcolor = setcolor
 	tobj.setfgcolor = setfgcolor
 	tobj.setbgcolor = setbgcolor
 	tobj.getcolor = getcolor
 	tobj.getfgcolor = getfgcolor
 	tobj.getbgcolor = getbgcolor
 	tobj.setstroke = setstroke
 	tobj.getstroke = getstroke
 	-- british
 	tobj.setcolour = setcolor
 	tobj.setfgcolour = setfgcolor
 	tobj.setbgcolour = setbgcolor
 	tobj.getcolour = getcolor
 	tobj.getfgcolour = getfgcolor
 	tobj.getbgcolour = getbgcolor
 
 	-- drawing functions
 	tobj.clear = clear
 	tobj.write = write
 	tobj.line = line
 	tobj.rect = rect
 	tobj.circle = circle
 	tobj.read = read
 
 	tobj:removepixles()
 	tobj:fixpixles()
 
 	local endload = os.clock()
 	return tobj,endload-startload
 end